Files
neoLegacy-mac/tests/test_reconstructed_swf_draw_renderstate.py
2026-07-13 06:52:32 -05:00

422 lines
20 KiB
Python

import ctypes
import math
import os
from pathlib import Path
import shlex
import struct
import subprocess
import tempfile
import unittest
ROOT = Path(__file__).resolve().parents[1]
RECONSTRUCTED = ROOT / "iggy-decompiled/src/reconstructed"
SOURCE = RECONSTRUCTED / "swf_draw_renderstate.c"
VARIANTS = {
name: f"IGGY_RECONSTRUCT_SWF_DRAW_RENDERSTATE_{name.upper()}"
for name in ("durango", "orbis", "ps3", "vita")
}
OFFSETS = {
"durango": (0x1EC0, 0x1EC8, 0x1ED8, 0x1F20, 0x1F80, 0x2140, 0x2280, 0x2290),
"orbis": (0x1EC0, 0x1EC8, 0x1ED8, 0x1F20, 0x1F80, 0x2140, 0x2280, 0x2290),
"ps3": (0x1960, 0x1968, 0x1978, 0x19B0, 0x1A04, 0x1BC4, 0x1CE4, 0x1CF4),
"vita": (0x1960, 0x1968, 0x1978, 0x19B0, 0x1A04, 0x1BC4, 0x1CE4, 0x1CF4),
}
SUPPORT_SOURCE = r"""
#include <stdint.h>
#include <string.h>
int renderstate_test_begin_calls;
int renderstate_test_end_calls;
int renderstate_test_clear_calls;
int renderstate_test_stats_calls;
int renderstate_test_begin_result;
uintptr_t renderstate_test_end_result;
uint32_t renderstate_test_clear_bits;
uint32_t renderstate_test_begin_format;
uint32_t renderstate_test_begin_flags;
int32_t renderstate_test_begin_region[4];
void *renderstate_test_begin_unique_id;
void *iggy_tm_normal;
void renderstate_test_reset(void) {
renderstate_test_begin_calls = 0;
renderstate_test_end_calls = 0;
renderstate_test_clear_calls = 0;
renderstate_test_stats_calls = 0;
renderstate_test_begin_result = 1;
renderstate_test_end_result = 0;
renderstate_test_clear_bits = 0;
renderstate_test_begin_format = 0xffffffffU;
renderstate_test_begin_flags = 0;
memset(renderstate_test_begin_region, 0, sizeof(renderstate_test_begin_region));
renderstate_test_begin_unique_id = (void *)(uintptr_t)1;
iggy_tm_normal = 0;
}
void renderstate_test_clear_stencil_bits(uint32_t bits) {
++renderstate_test_clear_calls;
renderstate_test_clear_bits = bits;
}
int renderstate_test_texture_draw_buffer_begin(
const int32_t region[4], uint32_t format, uint32_t flags,
void *unique_id, void *stats) {
(void)stats;
++renderstate_test_begin_calls;
memcpy(renderstate_test_begin_region, region, sizeof(renderstate_test_begin_region));
renderstate_test_begin_format = format;
renderstate_test_begin_flags = flags;
renderstate_test_begin_unique_id = unique_id;
return renderstate_test_begin_result;
}
void *renderstate_test_texture_draw_buffer_end(void *stats) {
(void)stats;
++renderstate_test_end_calls;
return (void *)renderstate_test_end_result;
}
void renderstate_test_accumulate_stats(void *iggy, const void *stats) {
(void)iggy;
(void)stats;
++renderstate_test_stats_calls;
}
"""
class Bounds(ctypes.Structure):
_fields_ = [(name, ctypes.c_float) for name in ("x0", "y0", "x1", "y1")]
class RenderState(ctypes.Structure):
_fields_ = [
("identifier", ctypes.c_int32), ("flags", ctypes.c_uint32),
("modes", ctypes.c_uint8 * 12), ("blur_passes", ctypes.c_int32),
("cxf_add", ctypes.c_void_p), ("textures", ctypes.c_void_p * 3),
("edge_matrix", ctypes.POINTER(ctypes.c_float)),
("object_to_world", ctypes.c_void_p), ("color", ctypes.c_float * 4),
("scissor", ctypes.c_int32 * 4), ("texture_s", ctypes.c_float * 4),
("texture_t", ctypes.c_float * 4), ("focal", ctypes.c_float * 4),
("blur", ctypes.c_float * 2), ("shader", ctypes.c_float * 20),
]
class ColorTransform(ctypes.Structure):
_fields_ = [
("reserved", ctypes.c_uint8 * 2), ("enabled", ctypes.c_uint8),
("padding", ctypes.c_uint8), ("multiply", ctypes.c_float * 4),
]
class ReconstructedSwfDrawRenderstateTests(unittest.TestCase):
@classmethod
def setUpClass(cls):
cls.temp = tempfile.TemporaryDirectory()
build_directory = Path(os.environ.get("IGGY_TEST_BUILD_DIR", cls.temp.name))
build_directory.mkdir(parents=True, exist_ok=True)
support = build_directory / "swf_draw_renderstate_test_support.c"
support.write_text(SUPPORT_SOURCE, encoding="utf-8")
extra_flags = shlex.split(os.environ.get("IGGY_TEST_CFLAGS", ""))
cls.libraries = {}
for platform, define in VARIANTS.items():
output = build_directory / f"swf_draw_renderstate_{platform}.dylib"
result = subprocess.run([
"clang", "-dynamiclib", "-std=c11", "-O2", "-Wall", "-Wextra",
"-Werror", "-DIGGY_SWF_DRAW_RENDERSTATE_TEST=1", f"-D{define}=1",
"-I", str(RECONSTRUCTED), str(SOURCE), str(support), *extra_flags,
"-o", str(output),
], capture_output=True, text=True)
if result.returncode:
raise AssertionError((platform, result.stdout + result.stderr))
library = ctypes.CDLL(str(output))
cls.configure(library)
cls.libraries[platform] = library
@classmethod
def tearDownClass(cls):
cls.temp.cleanup()
@staticmethod
def configure(library):
library.iggy_clear_renderstate.argtypes = [ctypes.c_void_p, ctypes.POINTER(RenderState)]
library.iggy_setcolor_4f.argtypes = [
ctypes.POINTER(RenderState), *([ctypes.c_float] * 4),
]
byte_args = [ctypes.POINTER(RenderState), *([ctypes.c_uint8] * 4)]
library.iggy_setcolor_4ub.argtypes = byte_args
library.iggy_setcolor_4ub_cxf.argtypes = [
*byte_args, ctypes.POINTER(ColorTransform),
]
library.iggy_clear_active_bits.argtypes = [ctypes.c_void_p]
library.iggy_start_nested_draw.argtypes = [
ctypes.c_void_p, ctypes.POINTER(Bounds),
ctypes.c_int32, ctypes.c_int32, ctypes.c_int32,
]
library.iggy_start_nested_draw.restype = ctypes.c_int32
library.iggy_recompute_cull_rect.argtypes = [ctypes.c_void_p]
library.iggy_end_nested_draw.argtypes = [ctypes.c_void_p]
library.iggy_end_nested_draw.restype = ctypes.c_void_p
def setUp(self):
for library in self.libraries.values():
library.renderstate_test_reset()
@staticmethod
def context():
return (ctypes.c_uint8 * 0x2400)()
@staticmethod
def write_i32(context, offset, value):
ctypes.c_int32.from_buffer(context, offset).value = value
@staticmethod
def read_i32(context, offset):
return ctypes.c_int32.from_buffer(context, offset).value
@staticmethod
def write_floats(context, offset, values):
for index, value in enumerate(values):
ctypes.c_float.from_buffer(context, offset + 4 * index).value = value
@staticmethod
def read_floats(context, offset, count=4):
return tuple(ctypes.c_float.from_buffer(context, offset + 4 * i).value for i in range(count))
@staticmethod
def frame_offset(platform, depth):
return OFFSETS[platform][4] + depth * 0x1C
def test_clear_renderstate_initializes_only_recovered_fields(self):
for platform, library in self.libraries.items():
context = self.context()
depth_offset = OFFSETS[platform][7]
self.write_i32(context, depth_offset, 2)
frame = self.frame_offset(platform, 2)
context[frame + 5] = 0x34
context[frame + 6] = 0x56
context[frame + 8] = 1
for index, value in enumerate((11, 12, 31, 32)):
self.write_i32(context, frame + 0xC + 4 * index, value)
state = RenderState()
ctypes.memset(ctypes.byref(state), 0xA5, ctypes.sizeof(state))
library.iggy_clear_renderstate(context, ctypes.byref(state))
expected_scissor_flag = 0x10000000 if platform == "ps3" else 8
self.assertEqual(state.flags, expected_scissor_flag, platform)
self.assertEqual((state.modes[8], state.modes[9]), (0x34, 0x56), platform)
self.assertEqual(tuple(state.color), (1, 1, 1, 1), platform)
self.assertEqual(tuple(state.scissor), (11, 12, 31, 32), platform)
self.assertEqual(tuple(state.edge_matrix[:4]), (1, 0, 0, 1), platform)
self.assertFalse(state.object_to_world, platform)
raw = bytes(state)
self.assertEqual(raw[0x68:], b"\xA5" * (ctypes.sizeof(state) - 0x68), platform)
def test_color_setters_keep_exact_normalization_and_cxf_clamps(self):
expected_bits = (0, 0x3B808081, 0x3EFEFF00, 0x3F008081, 0x3F7EFF00, 0x3F800000)
for platform, library in self.libraries.items():
state = RenderState()
library.iggy_setcolor_4f(ctypes.byref(state), -2, 0.25, 3, 4)
self.assertEqual(tuple(state.color), (-2, 0.25, 3, 4), platform)
for value, bits in zip((0, 1, 127, 128, 254, 255), expected_bits):
library.iggy_setcolor_4ub(ctypes.byref(state), value, value, value, value)
actual = struct.unpack("=I", struct.pack("=f", state.color[0]))[0]
self.assertEqual(actual, bits, (platform, value))
transform = ColorTransform()
transform.enabled = 1
transform.multiply[:] = (-2, 0.5, 3, 4)
library.iggy_setcolor_4ub_cxf(
ctypes.byref(state), 255, 128, 64, 255, ctypes.byref(transform),
)
self.assertEqual(state.color[0], 0, platform)
self.assertAlmostEqual(state.color[1], (128 / 255) * 0.5, places=6)
self.assertAlmostEqual(state.color[2], (64 / 255) * 3, places=6)
self.assertEqual(state.color[3], 1, platform)
transform.multiply[:] = (2, 2, 2, -1)
library.iggy_setcolor_4ub_cxf(
ctypes.byref(state), 255, 255, 255, 255, ctypes.byref(transform),
)
self.assertEqual(tuple(state.color), (2, 2, 2, 0), platform)
transform.enabled = 0
library.iggy_setcolor_4ub_cxf(
ctypes.byref(state), 255, 128, 64, 0, ctypes.byref(transform),
)
expected = (1, 128 / 255, 64 / 255, 0)
for actual, wanted in zip(state.color, expected):
self.assertAlmostEqual(actual, wanted, places=6)
transform.enabled = 1
transform.multiply[:] = (math.nan,) * 4
library.iggy_setcolor_4ub_cxf(
ctypes.byref(state), 255, 255, 255, 255, ctypes.byref(transform),
)
if platform in ("durango", "vita"):
self.assertTrue(all(math.isnan(value) for value in state.color))
elif platform == "orbis":
self.assertTrue(all(math.isnan(value) for value in state.color[:3]))
self.assertEqual(state.color[3], 0)
else:
self.assertEqual(tuple(state.color), (0, 0, 0, 0))
def test_clear_active_bits_calls_gdraw_then_normalizes_counters(self):
values = (-3, -2, -1, 0, 1, 32767, -32768, -5)
expected = (-1, -1, -1, 0, 1, 32767, -1, -1)
for platform, library in self.libraries.items():
context = self.context()
counters, depth = OFFSETS[platform][6:8]
self.write_i32(context, depth, 1)
frame = self.frame_offset(platform, 1)
context[frame + 7] = 0xA5
for index, value in enumerate(values):
ctypes.c_int16.from_buffer(context, counters + 2 * index).value = value
library.iggy_clear_active_bits(context)
actual = tuple(ctypes.c_int16.from_buffer(context, counters + 2 * i).value for i in range(8))
self.assertEqual(actual, expected, platform)
self.assertEqual(ctypes.c_int.in_dll(library, "renderstate_test_clear_calls").value, 1)
self.assertEqual(ctypes.c_uint32.in_dll(library, "renderstate_test_clear_bits").value, 0xA5)
self.assertEqual(context[frame + 7], 0)
def test_start_nested_draw_rounds_flags_and_initializes_child_frame(self):
for platform, library in self.libraries.items():
viewport, base, current, _, _, _, _, depth = OFFSETS[platform]
for flags in range(8):
library.renderstate_test_reset()
context = self.context()
self.write_i32(context, viewport, 80)
self.write_i32(context, viewport + 4, 40)
self.write_floats(context, base, (1, 2, 70, 35))
parent = self.frame_offset(platform, 0)
self.write_i32(context, parent, 1234)
context[parent + 4], context[parent + 7] = 0x44, 0x77
bounds = Bounds(-1.2, 2.9, 100.1, 49)
result = library.iggy_start_nested_draw(
context, ctypes.byref(bounds), flags & 1,
flags & 2, flags & 4,
)
self.assertEqual(result, 1, platform)
self.assertEqual(self.read_i32(context, depth), 1, platform)
child = self.frame_offset(platform, 1)
self.assertEqual(self.read_i32(context, child), 1234)
self.assertEqual((context[child + 4], context[child + 7]), (0x44, 0x77))
self.assertEqual((context[child + 5], context[child + 6], context[child + 8]), (0, 0, 0))
self.assertEqual(self.read_floats(context, current), (1, 2, 70, 35))
region = (ctypes.c_int32 * 4).in_dll(library, "renderstate_test_begin_region")
self.assertEqual(tuple(region), (0, 2, 80, 40), platform)
expected_flags = 2 | (flags & 1) | ((flags & 2) << 1) | ((flags & 4) << 1)
self.assertEqual(ctypes.c_uint32.in_dll(library, "renderstate_test_begin_flags").value, expected_flags)
self.assertEqual(ctypes.c_uint32.in_dll(library, "renderstate_test_begin_format").value, 0)
self.assertFalse(ctypes.c_void_p.in_dll(library, "renderstate_test_begin_unique_id").value)
def test_start_invalid_is_side_effect_free_and_failure_only_rolls_back_depth(self):
for platform, library in self.libraries.items():
viewport, base, current, _, _, _, _, depth = OFFSETS[platform]
context = self.context()
self.write_i32(context, viewport, 80)
self.write_i32(context, viewport + 4, 40)
self.write_floats(context, current, (9, 8, 7, 6))
before = bytes(context)
bounds = Bounds(80.1, 0, 90, 10)
self.assertEqual(library.iggy_start_nested_draw(context, ctypes.byref(bounds), 1, 1, 1), 0)
self.assertEqual(bytes(context), before, platform)
self.assertEqual(ctypes.c_int.in_dll(library, "renderstate_test_begin_calls").value, 0)
ctypes.c_int.in_dll(library, "renderstate_test_begin_result").value = 0
self.write_floats(context, base, (1, 2, 30, 35))
bounds = Bounds(0, 0, 10, 10)
self.assertEqual(library.iggy_start_nested_draw(context, ctypes.byref(bounds), 0, 0, 0), 0)
self.assertEqual(self.read_i32(context, depth), 0, platform)
self.assertEqual(self.read_floats(context, current), (1, 2, 30, 35), platform)
self.assertEqual(ctypes.c_int.in_dll(library, "renderstate_test_stats_calls").value, 1)
def test_recompute_cull_rect_intersects_masks_and_scissor(self):
for platform, library in self.libraries.items():
_, base, current, _, _, clips, _, depth = OFFSETS[platform]
context = self.context()
self.write_i32(context, depth, 1)
self.write_floats(context, base, (0, 0, 100, 100))
self.write_floats(context, clips, (10, -5, 90, 120))
self.write_floats(context, clips + 2 * 16, (20, 30, 80, 70))
frame = self.frame_offset(platform, 1)
context[frame + 5] = 0b00000101
library.iggy_recompute_cull_rect(context)
self.assertEqual(self.read_floats(context, current), (20, 30, 80, 70), platform)
context[frame + 8] = 1
for index, value in enumerate((25, 5, 60, 65)):
self.write_i32(context, frame + 0xC + 4 * index, value)
library.iggy_recompute_cull_rect(context)
self.assertEqual(self.read_floats(context, current), (25, 30, 60, 65), platform)
self.write_floats(context, clips, (120, 0, 130, 100))
context[frame + 5] = 1
context[frame + 8] = 0
library.iggy_recompute_cull_rect(context)
self.assertEqual(self.read_floats(context, current), (120, 0, 100, 100), platform)
def test_recompute_cull_rect_target_nan_selection(self):
for platform, library in self.libraries.items():
_, base, current, _, _, clips, _, depth = OFFSETS[platform]
context = self.context()
self.write_i32(context, depth, 0)
frame = self.frame_offset(platform, 0)
context[frame + 5] = 1
self.write_floats(context, base, (1, 2, 3, 4))
self.write_floats(context, clips, (math.nan,) * 4)
library.iggy_recompute_cull_rect(context)
result = self.read_floats(context, current)
if platform != "ps3":
self.assertTrue(all(math.isnan(value) for value in result))
else:
self.assertEqual(result[:2], (1, 2))
self.assertTrue(math.isnan(result[2]) and math.isnan(result[3]))
self.write_floats(context, base, (math.nan,) * 4)
self.write_floats(context, clips, (10, 20, 30, 40))
library.iggy_recompute_cull_rect(context)
result = self.read_floats(context, current)
if platform != "ps3":
self.assertEqual(result, (10, 20, 30, 40))
else:
self.assertTrue(math.isnan(result[0]) and math.isnan(result[1]))
self.assertEqual(result[2:], (30, 40))
def test_end_nested_draw_returns_texture_and_propagates_recovered_fields(self):
sentinel = 0x12345678
for platform, library in self.libraries.items():
_, base, current, gate, _, _, _, depth = OFFSETS[platform]
context = self.context()
self.write_i32(context, depth, 2)
self.write_floats(context, base, (1, 2, 30, 40))
child = self.frame_offset(platform, 2)
parent = self.frame_offset(platform, 1)
self.write_i32(context, child, 0x11223344)
context[child + 4], context[child + 7] = 0x55, 0x77
ctypes.c_size_t.in_dll(library, "renderstate_test_end_result").value = sentinel
result = library.iggy_end_nested_draw(context)
self.assertEqual(result, sentinel, platform)
self.assertEqual(self.read_i32(context, depth), 1, platform)
self.assertEqual(self.read_i32(context, parent), 0x11223344)
self.assertEqual((context[parent + 4], context[parent + 7]), (0x55, 0x77))
self.assertEqual(self.read_floats(context, current), (1, 2, 30, 40))
self.assertEqual(ctypes.c_int.in_dll(library, "renderstate_test_end_calls").value, 1)
self.assertEqual(ctypes.c_int.in_dll(library, "renderstate_test_stats_calls").value, 1)
library.renderstate_test_reset()
self.write_i32(context, depth, 1)
root = self.frame_offset(platform, 0)
child = self.frame_offset(platform, 1)
self.write_i32(context, root, 10)
self.write_i32(context, child, 20)
self.write_i32(context, gate, 0)
library.iggy_end_nested_draw(context)
self.assertEqual(self.read_i32(context, root), 10, platform)
self.write_i32(context, depth, 1)
self.write_i32(context, child, 30)
self.write_i32(context, gate, 1)
library.iggy_end_nested_draw(context)
self.assertEqual(self.read_i32(context, root), 30, platform)
if __name__ == "__main__":
unittest.main()