349 lines
15 KiB
Python
349 lines
15 KiB
Python
#!/usr/bin/env python3
|
|
"""Offene Container-Varianten (Military-Pack, container_001..008).
|
|
|
|
Aus jedem Pack-Container entstehen drei begehbare Varianten:
|
|
<oid>_offen1 eine Tuer (Stirnseite +Z) aufgeschwenkt, die andere zu
|
|
<oid>_offen2 beide Stirnseiten offen, Fluegel aufgeschwenkt
|
|
<oid>_ohne alle Tuer-Teile entfernt (freier Durchgang)
|
|
|
|
Das Pack-Original hat einseitige Waende (Innenseite wird weggecullt) — hier
|
|
bekommen Boden/Decke/Waende/Tuerblaetter eine umgedrehte Innenseite mit
|
|
Paletten-Textur (gleiche Pack-Textur, kein zweites Material -> keine Extra-
|
|
Draw-Calls auf der Quest). Die Kollision ist ein Trimesh aus derselben
|
|
Geometrie ohne Tuer-Beschlaege (Riegel/Scharniere/Griffe), damit Server,
|
|
Client und Editor dieselbe Form bauen.
|
|
|
|
Aufruf (aus dem Editor-Repo, Geschwister-Klone wie bei gen_bauteile.gd):
|
|
python3 tools/gen_container_varianten.py --client ../scopedvr-client \
|
|
--server ../scopedvr-match-server
|
|
Danach: im Match-Server python3 tools/merge_object_library.py und im Editor
|
|
tools/sync_objects.sh. Idempotent (gleiche Eingabe -> gleiche Dateien).
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
import argparse
|
|
import json
|
|
import math
|
|
import os
|
|
import struct
|
|
import sys
|
|
|
|
import numpy as np
|
|
|
|
KATEGORIE = "kisten"
|
|
FARBEN = range(1, 9)
|
|
VARIANTEN = [
|
|
# suffix, offene Enden, Tuer-Teile entfernen?, Namenszusatz
|
|
("offen1", ("+z",), False, "eine Tür offen"),
|
|
("offen2", ("+z", "-z"), False, "beide Türen offen"),
|
|
("ohne", (), True, "ohne Türen"),
|
|
]
|
|
AUF_WINKEL = 100.0 # Aufschwenkwinkel der Fluegel (Grad)
|
|
RUND = 2 # Kollisions-JSON wie im Pack: 2 Nachkommastellen
|
|
|
|
# Paletten-Texel (Demonstration_Textures1.png: 19 Spalten x 10 Zeilen, je 51,2 px)
|
|
def _texel(spalte: int, zeile: int) -> tuple:
|
|
return ((spalte + 0.5) * 51.2 / 1024.0, (zeile + 0.5) * 51.2 / 1024.0)
|
|
|
|
UV_WAND = _texel(17, 5) # Grau
|
|
UV_DECKE = _texel(17, 3) # helleres Grau
|
|
UV_BODEN = _texel(16, 6) # Holzbraun
|
|
|
|
|
|
def lade_glb(pfad):
|
|
b = open(pfad, "rb").read()
|
|
jl = struct.unpack("<I", b[12:16])[0]
|
|
j = json.loads(b[20:20 + jl])
|
|
off = 20 + jl
|
|
bl = struct.unpack("<I", b[off:off + 4])[0]
|
|
return j, b[off + 8:off + 8 + bl]
|
|
|
|
|
|
def accessor(j, binb, i):
|
|
a = j["accessors"][i]
|
|
bv = j["bufferViews"][a["bufferView"]]
|
|
n = {"SCALAR": 1, "VEC2": 2, "VEC3": 3}[a["type"]]
|
|
dt = {5126: "<f4", 5123: "<u2", 5125: "<u4"}[a["componentType"]]
|
|
o = bv.get("byteOffset", 0) + a.get("byteOffset", 0)
|
|
return np.frombuffer(binb, dtype=dt, count=a["count"] * n, offset=o).reshape(-1, n)
|
|
|
|
|
|
def schreibe_glb(pfad, j_alt, pos, nor, uv, trans):
|
|
"""Indiziertes GLB (ein Mesh, ein Material) — Material/Textur wie im Original."""
|
|
key = np.concatenate([pos, nor, uv], axis=1).astype(np.float32)
|
|
_, first, inv = np.unique(key, axis=0, return_index=True, return_inverse=True)
|
|
inv = inv.ravel()
|
|
# stabile Reihenfolge: nach erstem Auftreten
|
|
order = np.argsort(first)
|
|
rank = np.empty_like(order)
|
|
rank[order] = np.arange(len(order))
|
|
first = first[order]
|
|
idx = rank[inv].astype(np.uint32)
|
|
P = pos[first].astype("<f4"); N = nor[first].astype("<f4"); U = uv[first].astype("<f4")
|
|
parts = [P.tobytes(), N.tobytes(), U.tobytes(), idx.astype("<u4").tobytes()]
|
|
views, offs, o = [], [], 0
|
|
for k, p in enumerate(parts):
|
|
views.append({"buffer": 0, "byteOffset": o, "byteLength": len(p),
|
|
"target": 34963 if k == 3 else 34962})
|
|
o += len(p)
|
|
binb = b"".join(parts)
|
|
n = len(P)
|
|
accs = [
|
|
{"bufferView": 0, "componentType": 5126, "count": n, "type": "VEC3",
|
|
"min": P.min(0).tolist(), "max": P.max(0).tolist()},
|
|
{"bufferView": 1, "componentType": 5126, "count": n, "type": "VEC3"},
|
|
{"bufferView": 2, "componentType": 5126, "count": n, "type": "VEC2"},
|
|
{"bufferView": 3, "componentType": 5125, "count": len(idx), "type": "SCALAR"},
|
|
]
|
|
name = os.path.splitext(os.path.basename(pfad))[0]
|
|
j = {
|
|
"asset": j_alt["asset"],
|
|
"scene": 0,
|
|
"scenes": [{"name": "Scene", "nodes": [0]}],
|
|
"nodes": [{"mesh": 0, "name": name, "translation": trans}],
|
|
"meshes": [{"name": name + "_mesh", "primitives": [
|
|
{"attributes": {"POSITION": 0, "NORMAL": 1, "TEXCOORD_0": 2}, "indices": 3, "material": 0}]}],
|
|
"materials": j_alt["materials"],
|
|
"textures": j_alt["textures"],
|
|
"images": j_alt["images"],
|
|
"samplers": j_alt.get("samplers", [{}]),
|
|
"accessors": accs,
|
|
"bufferViews": views,
|
|
"buffers": [{"byteLength": len(binb)}],
|
|
}
|
|
js = json.dumps(j, separators=(",", ":")).encode()
|
|
js += b" " * (-len(js) % 4)
|
|
binb += b"\0" * (-len(binb) % 4)
|
|
total = 12 + 8 + len(js) + 8 + len(binb)
|
|
with open(pfad, "wb") as f:
|
|
f.write(struct.pack("<III", 0x46546C67, 2, total))
|
|
f.write(struct.pack("<II", len(js), 0x4E4F534A) + js)
|
|
f.write(struct.pack("<II", len(binb), 0x004E4942) + binb)
|
|
|
|
|
|
# ------------------------------------------------------------- Geometrie ----
|
|
|
|
def komponenten(tris_pos):
|
|
"""Union-Find ueber gemeinsame (gerundete) Eckpunkte -> Komponenten-ID je Dreieck."""
|
|
v = np.round(tris_pos, 3)
|
|
n = len(v)
|
|
par = list(range(n))
|
|
|
|
def f(x):
|
|
while par[x] != x:
|
|
par[x] = par[par[x]]
|
|
x = par[x]
|
|
return x
|
|
|
|
first = {}
|
|
for i in range(n):
|
|
for p in v[i]:
|
|
k = tuple(p)
|
|
if k in first:
|
|
par[f(i)] = f(first[k])
|
|
else:
|
|
first[k] = i
|
|
return np.array([f(i) for i in range(n)])
|
|
|
|
|
|
def ist_tuerteil(box_min, box_max, zc):
|
|
"""Tuer-Hardware/-Blatt: an einer Stirnseite, aber kein Eck-Beschlag."""
|
|
if abs(zc) <= 2.85:
|
|
return False
|
|
ecke = (box_max[1] < 0.3 or box_min[1] > 2.4) and max(abs(box_min[0]), abs(box_max[0])) > 0.95
|
|
return not ecke
|
|
|
|
|
|
def rot_y(pos, nor, pivot, grad):
|
|
"""Drehung um die senkrechte Achse durch pivot=(x,z). (a,b) -> (a cos - b sin, a sin + b cos)."""
|
|
w = math.radians(grad)
|
|
c, s = math.cos(w), math.sin(w)
|
|
p = pos.copy(); n = nor.copy()
|
|
a = pos[..., 0] - pivot[0]; b = pos[..., 2] - pivot[1]
|
|
p[..., 0] = pivot[0] + a * c - b * s
|
|
p[..., 2] = pivot[1] + a * s + b * c
|
|
n[..., 0] = nor[..., 0] * c - nor[..., 2] * s
|
|
n[..., 2] = nor[..., 0] * s + nor[..., 2] * c
|
|
return p, n
|
|
|
|
|
|
def baue(j, binb):
|
|
prim = j["meshes"][0]["primitives"][0]
|
|
P = accessor(j, binb, prim["attributes"]["POSITION"]).astype(np.float64)
|
|
N = accessor(j, binb, prim["attributes"]["NORMAL"]).astype(np.float64)
|
|
U = accessor(j, binb, prim["attributes"]["TEXCOORD_0"]).astype(np.float64)
|
|
I = accessor(j, binb, prim["indices"]).ravel().reshape(-1, 3)
|
|
trans = np.array(j["nodes"][0].get("translation", [0, 0, 0]), dtype=np.float64)
|
|
tp = P[I] + trans # (n,3,3) im Objekt-Fusspunkt-Raum (= Kollisions-JSON)
|
|
tn = N[I]
|
|
tu = U[I]
|
|
comp = komponenten(tp)
|
|
tuer = np.zeros(len(tp), dtype=bool)
|
|
ende = np.zeros(len(tp), dtype=np.int8) # +1 / -1 je Tuer-Dreieck
|
|
hardware = np.zeros(len(tp), dtype=bool) # Riegel/Scharniere/Griffe (nicht Blatt)
|
|
global _COMP_N, _KOMP
|
|
_KOMP = comp
|
|
_COMP_N = np.array([(comp == c).sum() for c in comp])
|
|
for c in np.unique(comp):
|
|
m = comp == c
|
|
pts = tp[m].reshape(-1, 3)
|
|
lo, hi = pts.min(0), pts.max(0)
|
|
zc = (lo[2] + hi[2]) / 2
|
|
if ist_tuerteil(lo, hi, zc):
|
|
tuer |= m
|
|
ende[m] = 1 if zc > 0 else -1
|
|
# Tuerblaetter = grosse ebene Dreiecke senkrecht Z, Rest = Hardware
|
|
area = np.linalg.norm(np.cross(tp[:, 1] - tp[:, 0], tp[:, 2] - tp[:, 0]), axis=1) / 2
|
|
nz = np.abs(np.cross(tp[:, 1] - tp[:, 0], tp[:, 2] - tp[:, 0])[:, 2]) / np.maximum(area * 2, 1e-9)
|
|
blatt = tuer & (area > 0.5) & (nz > 0.99)
|
|
# 60-Tri-Schale (Blatt mit Rahmenprofil, beide Fluegel verschweisst) gehoert ebenfalls zum Blatt
|
|
hardware = tuer & ~blatt
|
|
return tp, tn, tu, tuer, ende, blatt, hardware, trans
|
|
|
|
|
|
_COMP_N = None
|
|
_KOMP = None
|
|
|
|
|
|
def scharniere(tp, tuer, ende, hardware):
|
|
"""Drehpunkt (x,z) je (Ende, Seite) aus den Scharnier-Manschetten (16 Dreiecke, x ~ +-1,05)."""
|
|
piv = {}
|
|
cen = tp.mean(1)
|
|
for e in (1, -1):
|
|
for seite in (-1, 1):
|
|
m = tuer & (ende == e) & hardware & (_COMP_N == 16) & (np.sign(cen[:, 0]) == seite) & (np.abs(cen[:, 0]) > 0.95)
|
|
if not m.any():
|
|
raise SystemExit("Scharnier nicht gefunden (Ende %d Seite %d)" % (e, seite))
|
|
pts = tp[m].reshape(-1, 3)
|
|
piv[(e, seite)] = ((pts[:, 0].min() + pts[:, 0].max()) / 2, (pts[:, 2].min() + pts[:, 2].max()) / 2)
|
|
return piv
|
|
|
|
|
|
def variante(tp, tn, tu, tuer, ende, blatt, hardware, offene_enden, ohne_tuer):
|
|
"""-> (pos, nor, uv) sichtbar und kollisions-Dreiecke (n,3,3)."""
|
|
piv = scharniere(tp, tuer, ende, hardware)
|
|
sicht_p, sicht_n, sicht_u = [], [], []
|
|
kol = []
|
|
cen = tp.mean(1)
|
|
# --- statischer Koerper (kein Tuerteil) ---
|
|
k = ~tuer
|
|
sicht_p.append(tp[k]); sicht_n.append(tn[k]); sicht_u.append(tu[k])
|
|
# Kollision: nur Rahmen (grosse Komponente) + Wand-/Boden-/Deckenflaechen; die 6-cm-
|
|
# Rippen und Eckbeschlaege bleiben sichtbar, kollidieren aber nicht (Dreiecks-Budget
|
|
# der Registry: test_trimesh_alle S2 <= 130000).
|
|
gruppe = np.array([(_KOMP == c).sum() for c in _KOMP])
|
|
kol.append(tp[k & ((gruppe >= 60) | (gruppe == 2))])
|
|
area = np.linalg.norm(np.cross(tp[:, 1] - tp[:, 0], tp[:, 2] - tp[:, 0]), axis=1) / 2
|
|
nrm = np.cross(tp[:, 1] - tp[:, 0], tp[:, 2] - tp[:, 0])
|
|
nrm = nrm / np.maximum(np.linalg.norm(nrm, axis=1), 1e-9)[:, None]
|
|
|
|
def innen(mask, uvfix):
|
|
"""Umgedrehte Kopie (Innenseite) der Dreiecke in mask, mit Paletten-UV."""
|
|
p = tp[mask][:, ::-1, :].copy()
|
|
n = -tn[mask][:, ::-1, :].copy()
|
|
u = np.tile(np.array(uvfix, dtype=np.float64), (len(p), 3, 1))
|
|
return p, n, u
|
|
|
|
gross = ~tuer & (area > 5) # Waende / Decke / Boden (einseitig)
|
|
for mask, uvfix in (
|
|
(gross & (np.abs(nrm[:, 0]) > 0.99), UV_WAND),
|
|
(gross & (nrm[:, 1] > 0.99), UV_DECKE),
|
|
(gross & (nrm[:, 1] < -0.99), UV_BODEN),
|
|
):
|
|
p, n, u = innen(mask, uvfix)
|
|
sicht_p.append(p); sicht_n.append(n); sicht_u.append(u)
|
|
kol.append(p)
|
|
# --- Tuer-Teile ---
|
|
for e in (1, -1):
|
|
m_e = tuer & (ende == e)
|
|
if ohne_tuer:
|
|
continue
|
|
if (("+z" if e > 0 else "-z") in offene_enden):
|
|
for seite in (-1, 1):
|
|
ms = m_e & (np.where(cen[:, 0] < 0, -1, 1) == seite)
|
|
# Blatt-Innenseite (flach, einseitig) mit anhaengen
|
|
bl = ms & blatt
|
|
ip, inn, iu = innen(bl, UV_WAND)
|
|
p = np.concatenate([tp[ms], ip]); n = np.concatenate([tn[ms], inn]); u = np.concatenate([tu[ms], iu])
|
|
# Aufschwenken nach aussen: linkes Blatt am +Z-Ende dreht +w, rechtes -w; am -Z-Ende umgekehrt
|
|
w = AUF_WINKEL * seite * -1 * e
|
|
p, n = rot_y(p, n, piv[(e, seite)], w)
|
|
sicht_p.append(p); sicht_n.append(n); sicht_u.append(u)
|
|
# Kollision: nur die Blatt-Platten (ohne Beschlaege), mit gedreht
|
|
kb = np.concatenate([tp[bl], ip])
|
|
kb, _ = rot_y(kb, np.zeros_like(kb), piv[(e, seite)], w)
|
|
kol.append(kb)
|
|
else:
|
|
bl = m_e & blatt
|
|
ip, inn, iu = innen(bl, UV_WAND)
|
|
sicht_p.append(tp[m_e]); sicht_n.append(tn[m_e]); sicht_u.append(tu[m_e])
|
|
sicht_p.append(ip); sicht_n.append(inn); sicht_u.append(iu)
|
|
kol.append(tp[bl]); kol.append(ip)
|
|
cat = lambda L: np.concatenate(L).reshape(-1, 3)
|
|
return cat(sicht_p), cat(sicht_n), np.concatenate(sicht_u).reshape(-1, 2), np.concatenate(kol)
|
|
|
|
|
|
def kollisions_json(oid, glb_pfad, tris):
|
|
v = np.round(tris.reshape(-1, 3), RUND)
|
|
# entartete Dreiecke (nach Rundung) raus
|
|
t = v.reshape(-1, 3, 3)
|
|
ok = ~((t[:, 0] == t[:, 1]).all(1) | (t[:, 1] == t[:, 2]).all(1) | (t[:, 0] == t[:, 2]).all(1))
|
|
t = t[ok]
|
|
v = t.reshape(-1, 3)
|
|
return {
|
|
"aabb_max": [round(float(x), RUND) for x in v.max(0)],
|
|
"aabb_min": [round(float(x), RUND) for x in v.min(0)],
|
|
"dreiecke": int(len(t)),
|
|
"oid": oid,
|
|
"quelle_glb": "res://assets/objekte/military_desert/%s/%s.glb" % (KATEGORIE, oid),
|
|
"vertices": [[float(x) for x in p] for p in v],
|
|
}, t
|
|
|
|
|
|
def main():
|
|
ap = argparse.ArgumentParser()
|
|
ap.add_argument("--client", required=True)
|
|
ap.add_argument("--server", required=True)
|
|
ap.add_argument("--editor", default=os.path.join(os.path.dirname(__file__), ".."))
|
|
a = ap.parse_args()
|
|
glb_dir = os.path.join(a.client, "assets/objekte/military_desert", KATEGORIE)
|
|
kol_dirs = [os.path.join(d, "library/kollisions") for d in (a.server, a.client, a.editor)]
|
|
for d in kol_dirs:
|
|
os.makedirs(d, exist_ok=True)
|
|
fragment = {"objects": {}}
|
|
for n in FARBEN:
|
|
quelle = "container_%03d" % n
|
|
j, binb = lade_glb(os.path.join(glb_dir, quelle + ".glb"))
|
|
tp, tn, tu, tuer, ende, blatt, hardware, trans = baue(j, binb)
|
|
if n == 1:
|
|
print("Tuer-Dreiecke: %d (Blatt %d, Beschlaege %d) von %d" % (
|
|
tuer.sum(), blatt.sum(), hardware.sum(), len(tp)))
|
|
for suffix, enden, ohne, text in VARIANTEN:
|
|
oid = "%s_%s" % (quelle, suffix)
|
|
pos, nor, uv, kol = variante(tp, tn, tu, tuer, ende, blatt, hardware, enden, ohne)
|
|
# GLB im Fusspunkt-Raum (translation=0): Kollision == Sichtgeometrie
|
|
schreibe_glb(os.path.join(glb_dir, oid + ".glb"), j, pos.astype(np.float32),
|
|
nor.astype(np.float32), uv.astype(np.float32), [0.0, 0.0, 0.0])
|
|
kj, kt = kollisions_json(oid, None, kol)
|
|
s = json.dumps(kj, separators=(",", ":"), sort_keys=True)
|
|
for d in kol_dirs:
|
|
with open(os.path.join(d, oid + ".json"), "w") as f:
|
|
f.write(s)
|
|
size = [round(float(x), 2) for x in (kj["aabb_max"][i] - kj["aabb_min"][i] for i in range(3))]
|
|
fragment["objects"][oid] = {
|
|
"poly": int(len(pos) // 3),
|
|
"collision": {"shape": "trimesh", "size": size, "quelle": "kollisions/%s.json" % oid},
|
|
"glb": "res://assets/objekte/military_desert/%s/%s.glb" % (KATEGORIE, oid),
|
|
"kategorie": KATEGORIE,
|
|
"name_de": "Container %02d (%s)" % (n, text),
|
|
}
|
|
print("%s: %d Sicht-, %d Kollisions-Dreiecke" % (oid, len(pos) // 3, len(kt)))
|
|
frag = os.path.join(a.server, "library/objects.d/container_offen.json")
|
|
with open(frag, "w") as f:
|
|
f.write(json.dumps(fragment, indent=2, ensure_ascii=False) + "\n")
|
|
print("Fertig: %d Objekte." % len(fragment["objects"]))
|
|
|
|
|
|
if __name__ == "__main__":
|
|
sys.exit(main())
|