422 lines
13 KiB
Python
422 lines
13 KiB
Python
#!/usr/bin/env python3
|
|
"""Unit tests for the Shader system (Issue #106)
|
|
|
|
Tests cover:
|
|
- Shader creation and compilation
|
|
- Static uniforms (float, vec2, vec3, vec4)
|
|
- PropertyBinding for dynamic uniform values
|
|
- CallableBinding for computed uniform values
|
|
- Shader assignment to various drawable types
|
|
- Dynamic flag propagation
|
|
"""
|
|
|
|
import mcrfpy
|
|
import sys
|
|
|
|
|
|
def test_shader_creation():
|
|
"""Test basic shader creation"""
|
|
print("Testing shader creation...")
|
|
|
|
# Valid shader
|
|
shader = mcrfpy.Shader('''
|
|
uniform sampler2D texture;
|
|
void main() {
|
|
gl_FragColor = texture2D(texture, gl_TexCoord[0].xy);
|
|
}
|
|
''')
|
|
assert shader is not None, "Shader should be created"
|
|
assert shader.is_valid, "Shader should be valid"
|
|
assert shader.dynamic == False, "Shader should not be dynamic by default"
|
|
|
|
# Dynamic shader
|
|
dynamic_shader = mcrfpy.Shader('''
|
|
uniform sampler2D texture;
|
|
uniform float time;
|
|
void main() {
|
|
gl_FragColor = texture2D(texture, gl_TexCoord[0].xy);
|
|
}
|
|
''', dynamic=True)
|
|
assert dynamic_shader.dynamic == True, "Shader should be dynamic when specified"
|
|
|
|
print(" PASS: Basic shader creation works")
|
|
|
|
|
|
def test_shader_source():
|
|
"""Test that shader source is stored correctly"""
|
|
print("Testing shader source storage...")
|
|
|
|
source = '''uniform sampler2D texture;
|
|
void main() {
|
|
gl_FragColor = texture2D(texture, gl_TexCoord[0].xy);
|
|
}'''
|
|
shader = mcrfpy.Shader(source)
|
|
assert source in shader.source, "Shader source should be stored"
|
|
|
|
print(" PASS: Shader source is stored")
|
|
|
|
|
|
def test_static_uniforms():
|
|
"""Test static uniform values"""
|
|
print("Testing static uniforms...")
|
|
|
|
frame = mcrfpy.Frame(pos=(0, 0), size=(100, 100))
|
|
|
|
# Test float uniform
|
|
frame.uniforms['intensity'] = 0.5
|
|
assert abs(frame.uniforms['intensity'] - 0.5) < 0.001, "Float uniform should match"
|
|
|
|
# Test vec2 uniform
|
|
frame.uniforms['offset'] = (10.0, 20.0)
|
|
val = frame.uniforms['offset']
|
|
assert len(val) == 2, "Vec2 should have 2 components"
|
|
assert abs(val[0] - 10.0) < 0.001, "Vec2.x should match"
|
|
assert abs(val[1] - 20.0) < 0.001, "Vec2.y should match"
|
|
|
|
# Test vec3 uniform
|
|
frame.uniforms['color_rgb'] = (1.0, 0.5, 0.0)
|
|
val = frame.uniforms['color_rgb']
|
|
assert len(val) == 3, "Vec3 should have 3 components"
|
|
|
|
# Test vec4 uniform
|
|
frame.uniforms['color'] = (1.0, 0.5, 0.0, 1.0)
|
|
val = frame.uniforms['color']
|
|
assert len(val) == 4, "Vec4 should have 4 components"
|
|
|
|
print(" PASS: Static uniforms work")
|
|
|
|
|
|
def test_uniform_keys():
|
|
"""Test uniform collection keys/values/items"""
|
|
print("Testing uniform collection methods...")
|
|
|
|
frame = mcrfpy.Frame(pos=(0, 0), size=(100, 100))
|
|
frame.uniforms['a'] = 1.0
|
|
frame.uniforms['b'] = 2.0
|
|
frame.uniforms['c'] = 3.0
|
|
|
|
keys = frame.uniforms.keys()
|
|
assert 'a' in keys, "Key 'a' should be present"
|
|
assert 'b' in keys, "Key 'b' should be present"
|
|
assert 'c' in keys, "Key 'c' should be present"
|
|
assert len(keys) == 3, "Should have 3 keys"
|
|
|
|
# Test 'in' operator
|
|
assert 'a' in frame.uniforms, "'in' operator should work"
|
|
assert 'nonexistent' not in frame.uniforms, "'not in' should work"
|
|
|
|
# Test deletion
|
|
del frame.uniforms['b']
|
|
assert 'b' not in frame.uniforms, "Deleted key should be gone"
|
|
assert len(frame.uniforms.keys()) == 2, "Should have 2 keys after deletion"
|
|
|
|
print(" PASS: Uniform collection methods work")
|
|
|
|
|
|
def test_property_binding():
|
|
"""Test PropertyBinding for dynamic uniform values"""
|
|
print("Testing PropertyBinding...")
|
|
|
|
# Create source and target frames
|
|
source_frame = mcrfpy.Frame(pos=(100, 200), size=(50, 50))
|
|
target_frame = mcrfpy.Frame(pos=(0, 0), size=(100, 100))
|
|
|
|
# Create binding to source frame's x position
|
|
binding = mcrfpy.PropertyBinding(source_frame, 'x')
|
|
assert binding is not None, "PropertyBinding should be created"
|
|
assert binding.property == 'x', "Property name should be stored"
|
|
assert abs(binding.value - 100.0) < 0.001, "Initial value should be 100"
|
|
assert binding.is_valid == True, "Binding should be valid"
|
|
|
|
# Assign binding to uniform
|
|
target_frame.uniforms['source_x'] = binding
|
|
|
|
# Check that value tracks changes
|
|
source_frame.x = 300
|
|
assert abs(binding.value - 300.0) < 0.001, "Binding should track changes"
|
|
|
|
print(" PASS: PropertyBinding works")
|
|
|
|
|
|
def test_callable_binding():
|
|
"""Test CallableBinding for computed uniform values"""
|
|
print("Testing CallableBinding...")
|
|
|
|
counter = [0] # Use list for closure
|
|
|
|
def compute_value():
|
|
counter[0] += 1
|
|
return counter[0] * 0.1
|
|
|
|
binding = mcrfpy.CallableBinding(compute_value)
|
|
assert binding is not None, "CallableBinding should be created"
|
|
assert binding.is_valid == True, "Binding should be valid"
|
|
|
|
# Each access should call the function
|
|
v1 = binding.value
|
|
v2 = binding.value
|
|
v3 = binding.value
|
|
|
|
assert abs(v1 - 0.1) < 0.001, "First call should return 0.1"
|
|
assert abs(v2 - 0.2) < 0.001, "Second call should return 0.2"
|
|
assert abs(v3 - 0.3) < 0.001, "Third call should return 0.3"
|
|
|
|
# Assign to uniform
|
|
frame = mcrfpy.Frame(pos=(0, 0), size=(100, 100))
|
|
frame.uniforms['computed'] = binding
|
|
|
|
print(" PASS: CallableBinding works")
|
|
|
|
|
|
def test_shader_on_frame():
|
|
"""Test shader assignment to Frame"""
|
|
print("Testing shader on Frame...")
|
|
|
|
shader = mcrfpy.Shader('''
|
|
uniform sampler2D texture;
|
|
uniform float intensity;
|
|
void main() {
|
|
vec4 color = texture2D(texture, gl_TexCoord[0].xy);
|
|
color.rgb *= intensity;
|
|
gl_FragColor = color;
|
|
}
|
|
''')
|
|
|
|
frame = mcrfpy.Frame(pos=(0, 0), size=(100, 100))
|
|
assert frame.shader is None, "Shader should be None initially"
|
|
|
|
frame.shader = shader
|
|
assert frame.shader is not None, "Shader should be assigned"
|
|
|
|
frame.uniforms['intensity'] = 0.8
|
|
assert abs(frame.uniforms['intensity'] - 0.8) < 0.001, "Uniform should be set"
|
|
|
|
# Test shader removal
|
|
frame.shader = None
|
|
assert frame.shader is None, "Shader should be removable"
|
|
|
|
print(" PASS: Shader on Frame works")
|
|
|
|
|
|
def test_shader_on_sprite():
|
|
"""Test shader assignment to Sprite"""
|
|
print("Testing shader on Sprite...")
|
|
|
|
shader = mcrfpy.Shader('''
|
|
uniform sampler2D texture;
|
|
void main() {
|
|
gl_FragColor = texture2D(texture, gl_TexCoord[0].xy);
|
|
}
|
|
''')
|
|
|
|
sprite = mcrfpy.Sprite(pos=(0, 0))
|
|
assert sprite.shader is None, "Shader should be None initially"
|
|
|
|
sprite.shader = shader
|
|
assert sprite.shader is not None, "Shader should be assigned"
|
|
|
|
sprite.uniforms['test'] = 1.0
|
|
assert abs(sprite.uniforms['test'] - 1.0) < 0.001, "Uniform should be set"
|
|
|
|
print(" PASS: Shader on Sprite works")
|
|
|
|
|
|
def test_shader_on_caption():
|
|
"""Test shader assignment to Caption"""
|
|
print("Testing shader on Caption...")
|
|
|
|
shader = mcrfpy.Shader('''
|
|
uniform sampler2D texture;
|
|
void main() {
|
|
gl_FragColor = texture2D(texture, gl_TexCoord[0].xy);
|
|
}
|
|
''')
|
|
|
|
caption = mcrfpy.Caption(text="Test", pos=(0, 0))
|
|
assert caption.shader is None, "Shader should be None initially"
|
|
|
|
caption.shader = shader
|
|
assert caption.shader is not None, "Shader should be assigned"
|
|
|
|
caption.uniforms['test'] = 1.0
|
|
assert abs(caption.uniforms['test'] - 1.0) < 0.001, "Uniform should be set"
|
|
|
|
print(" PASS: Shader on Caption works")
|
|
|
|
|
|
def test_shader_on_grid():
|
|
"""Test shader assignment to Grid"""
|
|
print("Testing shader on Grid...")
|
|
|
|
shader = mcrfpy.Shader('''
|
|
uniform sampler2D texture;
|
|
void main() {
|
|
gl_FragColor = texture2D(texture, gl_TexCoord[0].xy);
|
|
}
|
|
''')
|
|
|
|
grid = mcrfpy.Grid(grid_size=(10, 10), pos=(0, 0), size=(200, 200))
|
|
assert grid.shader is None, "Shader should be None initially"
|
|
|
|
grid.shader = shader
|
|
assert grid.shader is not None, "Shader should be assigned"
|
|
|
|
grid.uniforms['test'] = 1.0
|
|
assert abs(grid.uniforms['test'] - 1.0) < 0.001, "Uniform should be set"
|
|
|
|
print(" PASS: Shader on Grid works")
|
|
|
|
|
|
def test_shader_on_entity():
|
|
"""Test shader assignment to Entity"""
|
|
print("Testing shader on Entity...")
|
|
|
|
shader = mcrfpy.Shader('''
|
|
uniform sampler2D texture;
|
|
void main() {
|
|
gl_FragColor = texture2D(texture, gl_TexCoord[0].xy);
|
|
}
|
|
''')
|
|
|
|
entity = mcrfpy.Entity()
|
|
assert entity.shader is None, "Shader should be None initially"
|
|
|
|
entity.shader = shader
|
|
assert entity.shader is not None, "Shader should be assigned"
|
|
|
|
entity.uniforms['test'] = 1.0
|
|
assert abs(entity.uniforms['test'] - 1.0) < 0.001, "Uniform should be set"
|
|
|
|
print(" PASS: Shader on Entity works")
|
|
|
|
|
|
def test_shared_shader():
|
|
"""Test that multiple drawables can share the same shader"""
|
|
print("Testing shared shader...")
|
|
|
|
shader = mcrfpy.Shader('''
|
|
uniform sampler2D texture;
|
|
uniform float intensity;
|
|
void main() {
|
|
vec4 color = texture2D(texture, gl_TexCoord[0].xy);
|
|
color.rgb *= intensity;
|
|
gl_FragColor = color;
|
|
}
|
|
''')
|
|
|
|
frame1 = mcrfpy.Frame(pos=(0, 0), size=(100, 100))
|
|
frame2 = mcrfpy.Frame(pos=(100, 0), size=(100, 100))
|
|
|
|
# Assign same shader to both
|
|
frame1.shader = shader
|
|
frame2.shader = shader
|
|
|
|
# But different uniform values
|
|
frame1.uniforms['intensity'] = 0.5
|
|
frame2.uniforms['intensity'] = 1.0
|
|
|
|
assert abs(frame1.uniforms['intensity'] - 0.5) < 0.001, "Frame1 intensity should be 0.5"
|
|
assert abs(frame2.uniforms['intensity'] - 1.0) < 0.001, "Frame2 intensity should be 1.0"
|
|
|
|
print(" PASS: Shared shader with different uniforms works")
|
|
|
|
|
|
def test_shader_animation_properties():
|
|
"""Test that shader uniforms can be animated via the animation system"""
|
|
print("Testing shader animation properties...")
|
|
|
|
frame = mcrfpy.Frame(pos=(0, 0), size=(100, 100))
|
|
|
|
# Set initial uniform value
|
|
frame.uniforms['intensity'] = 0.0
|
|
|
|
# Test animate() method with shader.X property syntax
|
|
# This uses hasProperty/setProperty internally
|
|
try:
|
|
frame.animate('shader.intensity', 1.0, 0.5, mcrfpy.Easing.LINEAR)
|
|
animation_works = True
|
|
except Exception as e:
|
|
animation_works = False
|
|
print(f" Animation error: {e}")
|
|
|
|
assert animation_works, "Animating shader uniforms should work"
|
|
|
|
# Test with different drawable types
|
|
sprite = mcrfpy.Sprite(pos=(0, 0))
|
|
sprite.uniforms['glow'] = 0.0
|
|
try:
|
|
sprite.animate('shader.glow', 2.0, 1.0, mcrfpy.Easing.EASE_IN)
|
|
sprite_animation_works = True
|
|
except Exception as e:
|
|
sprite_animation_works = False
|
|
print(f" Sprite animation error: {e}")
|
|
|
|
assert sprite_animation_works, "Animating Sprite shader uniforms should work"
|
|
|
|
# Test Caption
|
|
caption = mcrfpy.Caption(text="Test", pos=(0, 0))
|
|
caption.uniforms['alpha'] = 1.0
|
|
try:
|
|
caption.animate('shader.alpha', 0.0, 0.5, mcrfpy.Easing.EASE_OUT)
|
|
caption_animation_works = True
|
|
except Exception as e:
|
|
caption_animation_works = False
|
|
print(f" Caption animation error: {e}")
|
|
|
|
assert caption_animation_works, "Animating Caption shader uniforms should work"
|
|
|
|
# Test Grid
|
|
grid = mcrfpy.Grid(grid_size=(5, 5), pos=(0, 0), size=(100, 100))
|
|
grid.uniforms['zoom_effect'] = 1.0
|
|
try:
|
|
grid.animate('shader.zoom_effect', 2.0, 1.0, mcrfpy.Easing.LINEAR)
|
|
grid_animation_works = True
|
|
except Exception as e:
|
|
grid_animation_works = False
|
|
print(f" Grid animation error: {e}")
|
|
|
|
assert grid_animation_works, "Animating Grid shader uniforms should work"
|
|
|
|
print(" PASS: Shader animation properties work")
|
|
|
|
|
|
def run_all_tests():
|
|
"""Run all shader tests"""
|
|
print("=" * 50)
|
|
print("Shader System Unit Tests")
|
|
print("=" * 50)
|
|
print()
|
|
|
|
try:
|
|
test_shader_creation()
|
|
test_shader_source()
|
|
test_static_uniforms()
|
|
test_uniform_keys()
|
|
test_property_binding()
|
|
test_callable_binding()
|
|
test_shader_on_frame()
|
|
test_shader_on_sprite()
|
|
test_shader_on_caption()
|
|
test_shader_on_grid()
|
|
test_shader_on_entity()
|
|
test_shared_shader()
|
|
test_shader_animation_properties()
|
|
|
|
print()
|
|
print("=" * 50)
|
|
print("ALL TESTS PASSED")
|
|
print("=" * 50)
|
|
sys.exit(0)
|
|
|
|
except AssertionError as e:
|
|
print(f" FAIL: {e}")
|
|
sys.exit(1)
|
|
except Exception as e:
|
|
print(f" ERROR: {e}")
|
|
import traceback
|
|
traceback.print_exc()
|
|
sys.exit(1)
|
|
|
|
|
|
if __name__ == "__main__":
|
|
run_all_tests()
|