422 lines
20 KiB
Python
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()
|