Files
Neutron/tests/test_extractors.py

147 lines
7.4 KiB
Python

import json
from pathlib import Path
import struct
import sys
import tempfile
import unittest
import zlib
ROOT = Path(__file__).resolve().parents[1]
ORIGINAL = ROOT.parent / 'Original'
sys.path.insert(0, str(ROOT / 'tools' / 'extractors'))
from omt import Database, FormatError, Reader, export_scene, read_canvas, read_material, read_shape, unpack_row, validate_output, write_png
from ase import read_ase, export_ase
from png import read_png
class BoundedReaders(unittest.TestCase):
def test_read_bounds_and_negative_size(self):
for size in (-1, 2):
with self.assertRaises(FormatError): Reader(b'x').take(size)
def test_serialized_bool_is_two_bytes(self):
r = Reader(b'\x00\x01\x00\x00')
self.assertTrue(r.boolean())
self.assertFalse(r.boolean())
r.end()
def test_packbits_bytes_and_pixel_words(self):
self.assertEqual(unpack_row(b'\x02abc\xfeZ', 6, 1), b'abcZZZ')
self.assertEqual(unpack_row(b'\x01\x00\x7c\x00\x03\xe0\xfe\xff\x00\x1f', 10, 2),
b'\x7c\x00\x03\xe0\x00\x1f\x00\x1f\x00\x1f')
def test_packbits_rejects_overrun_truncation_and_leftovers(self):
for encoded, expected, unit in ((b'\x7fX', 1, 1), (b'\xff', 2, 1), (b'\x00XY', 1, 1)):
with self.assertRaises(FormatError): unpack_row(encoded, expected, unit)
def test_canvas_rgb555_matches_original_shift_and_key(self):
# Original pixel converter uses channel<<3, yielding 248 at full intensity.
row = b'\x02\x00\x7c\x00\x03\xe0\x00\x1f'
pixel_data = struct.pack('>H', len(row)) + row
header = b'OmCv'+struct.pack('>I', 0)+b'OmGW'+struct.pack('>HHHBBH', 3, 1, 16, 1, 1, 6)
header += struct.pack('>HIHI', 1, 0x03e0, 0, len(pixel_data))
canvas = read_canvas(header+pixel_data)
self.assertEqual(canvas['rgba'], bytes((248,0,0,255,0,248,0,0,0,0,248,255)))
def test_png_roundtrip_payload(self):
rgba = bytes((4,5,6,255,10,20,30,0))
with tempfile.TemporaryDirectory() as t:
path = Path(t)/'test.png'
write_png(path, 2, 1, rgba)
data = path.read_bytes()
self.assertEqual(data[:8], b'\x89PNG\r\n\x1a\n')
p, compressed = 8, bytearray()
while p < len(data):
size = struct.unpack_from('>I', data, p)[0]
tag, payload = data[p+4:p+8], data[p+8:p+8+size]
self.assertEqual(zlib.crc32(tag+payload), struct.unpack_from('>I',data,p+8+size)[0])
if tag == b'IDAT': compressed.extend(payload)
p += size+12
self.assertEqual(zlib.decompress(compressed), b'\x00'+rgba)
self.assertEqual(read_png(path)['rgba'],rgba)
@unittest.skipUnless(ORIGINAL.exists(), 'Original game files are local integration fixtures')
class OriginalResources(unittest.TestCase):
def test_every_database_index_is_bounded(self):
paths = list(ORIGINAL.rglob('*.omt'))
self.assertEqual(len(paths), 100)
self.assertEqual(sum(len(Database(p).entries) for p in paths), 7027)
def test_first_scene_geometry_materials_and_textures(self):
db = Database(ORIGINAL/'omt'/'level1b.omt')
counts = {}
for entry in db.entries:
if entry.type == '3DSh': read_shape(db.payload(entry))
elif entry.type == '3DMa': read_material(db.payload(entry))
elif entry.type == 'Canv':
canvas = read_canvas(db.payload(entry))
self.assertEqual(len(canvas['rgba']), canvas['width']*canvas['height']*4)
counts[entry.type] = counts.get(entry.type, 0)+1
self.assertEqual(counts['Canv'], 33)
def test_scene_export_contains_original_geometry_and_texture_links(self):
db = Database(ORIGINAL/'omt'/'VR01.omt')
with tempfile.TemporaryDirectory() as t:
output = Path(t)/'scene'
scene = export_scene(db, output)
self.assertEqual(len(scene['indices']), 240)
self.assertEqual(len(scene['vertices']), 240)
self.assertEqual(len(scene['textures']), 7)
self.assertTrue(all(0 <= i < len(scene['vertices']) for i in scene['indices']))
self.assertEqual([list(v) for v in scene['vertices']], json.loads((output/'scene.json').read_text())['vertices'])
for texture in scene['textures']:
self.assertEqual((output/texture['path']).stat().st_size, texture['width']*texture['height']*4)
def test_extraction_cannot_target_original_directory(self):
db = Database(ORIGINAL/'omt'/'VR01.omt')
for target in (ORIGINAL, ORIGINAL/'omt', ORIGINAL/'omt'/'converted'):
with self.assertRaises(ValueError): validate_output(db, target)
def test_indexed_texture_recovery(self):
db = Database(ORIGINAL/'omt'/'sprites.omt')
entry = next(e for e in db.entries if e.type=='Canv' and e.name=='shadow2')
canvas = read_canvas(db.payload(entry))
self.assertEqual((canvas['width'],canvas['height'],canvas['depth']), (64,32,8))
self.assertIn(0, canvas['rgba'][3::4])
def test_ase_coordinate_uv_and_winding_match_original_omt(self):
db = Database(ORIGINAL/'omt'/'objects.omt')
for name in ('gate1','yokianpart'):
entry = next(e for e in db.entries if e.type=='3DSh' and e.name==name)
omt = read_shape(db.payload(entry))
ase = read_ase(ORIGINAL/'ASE'/(name+'.ASE'))['objects'][0]['samples'][0]
self.assertEqual(len(omt['vertices']),len(ase['vertices']))
self.assertEqual(len(omt['polygons']),len(ase['faces']))
for original,recovered in zip(omt['vertices'],ase['vertices']):
for a,b in zip(original,recovered): self.assertAlmostEqual(a,b,places=3)
for polygon,face,tf in zip(omt['polygons'],ase['faces'],ase['textureFaces']):
self.assertEqual(tuple(c['vertex'] for c in polygon['corners']),face)
for corner,uv_index in zip(polygon['corners'],tf):
for a,b in zip(corner['uv'],ase['uvs'][uv_index]): self.assertAlmostEqual(a,b,places=6)
def test_jimmy_morph_animation_samples_and_texture(self):
for name,count in (('jimstop.ase',2),('jimrun.ASE',5),('jimjump.ASE',3)):
animation=read_ase(ORIGINAL/'ASE'/name)
self.assertEqual((animation['framesPerSecond'],animation['ticksPerFrame']),(10,480))
self.assertEqual(len(animation['objects'][0]['samples']),count)
self.assertTrue(all(len(m['faces'])==814 for m in animation['objects'][0]['samples']))
texture=read_png(ORIGINAL/'png'/'jimycarl.png')
self.assertEqual((texture['width'],texture['height'],len(texture['rgba'])),(256,256,256*256*4))
def test_morph_reuses_textured_base_topology(self):
with tempfile.TemporaryDirectory() as t:
output=Path(t)
with self.assertRaises(FormatError):
export_ase(ORIGINAL/'ASE'/'jimrun.ASE',output/'invalid')
export_ase(ORIGINAL/'ASE'/'jimrun.ASE',output/'run',ORIGINAL/'ASE'/'jimstop.ase')
export_ase(ORIGINAL/'ASE'/'jimstop.ase',output/'base')
frame=json.loads((output/'run'/'frame_0000.json').read_text())
base=json.loads((output/'base'/'frame_0000.json').read_text())
self.assertEqual(frame['uvs'],base['uvs'])
self.assertTrue(any(uv != [0,0] for uv in frame['uvs']))
self.assertNotEqual(frame['vertices'],base['vertices'])
if __name__ == '__main__': unittest.main()