"""
Test implementation for features/14_camera_ortho.feature
Tests camera orthographic projection for technical renders.
"""
import pytest
from pytest_bdd import scenarios, given, when, then, parsers
import sys
from pathlib import Path
sys.path.insert(0, str(Path(__file__).parent.parent.parent / "src"))
scenarios('../../features/14_camera_ortho.feature')
@given("the MCP server is running")
def mcp_server(bdd_context):
bdd_context["server_running"] = True
@given("the Blender addon is connected")
def blender_connected(bdd_context, mock_blender_connection):
mock_blender_connection.connect()
bdd_context["connection"] = mock_blender_connection
@given("a camera exists in the scene")
@given("the camera is set to orthographic")
def camera_exists(bdd_context):
bdd_context["camera"] = {
"name": "Camera",
"type": "CAMERA",
"projection": "PERSP",
"ortho_scale": 5.0
}
@given("the active camera uses perspective projection")
def camera_uses_perspective(bdd_context):
bdd_context["camera"] = {
"projection": "PERSP",
"ortho_scale": 5.0
}
@given("objects are in the scene")
def objects_in_scene(bdd_context, mesh_factory):
bdd_context["scene_objects"] = [
mesh_factory.create_cube(),
mesh_factory.create_cube()
]
@given("the viewport is set to orthographic")
def viewport_ortho(bdd_context):
bdd_context["viewport_projection"] = "ORTHO"
@given("the camera is still in perspective mode")
def camera_still_perspective(bdd_context):
camera = bdd_context.get("camera", {})
camera["projection"] = "PERSP"
bdd_context["camera"] = camera
@given("the viewport is aligned to FRONT")
def viewport_aligned_front(bdd_context):
bdd_context["viewport_alignment"] = "FRONT"
@given("I want an orthographic front view render")
def want_ortho_front_render(bdd_context):
bdd_context["desired_render"] = {
"type": "orthographic",
"view": "FRONT"
}
@when(parsers.parse('I call set_camera_projection with projection="{projection}"'))
def call_set_camera_projection(bdd_context, mock_blender_connection, projection):
camera = bdd_context.get("camera", {})
result = {
"success": True,
"result": {
"camera": camera.get("name", "Camera"),
"projection": projection,
"previous_projection": camera.get("projection", "PERSP"),
"ortho_scale": camera.get("ortho_scale", 5.0)
}
}
params = {"projection": projection}
mock_blender_connection.set_response("set_camera_projection", params, result)
bdd_context["camera_result"] = mock_blender_connection.send_command("set_camera_projection", params)
camera["projection"] = projection
bdd_context["camera"] = camera
@when(parsers.parse('I call set_camera_projection with projection="{projection}", ortho_scale="{scale}"'))
def call_set_camera_with_scale(bdd_context, mock_blender_connection, projection, scale):
# Calculate auto scale if needed
if scale == "auto":
calculated_scale = 6.5 # Based on scene bounds
else:
calculated_scale = float(scale)
result = {
"success": True,
"result": {
"projection": projection,
"ortho_scale": calculated_scale,
"scale_auto_calculated": (scale == "auto"),
"all_objects_visible": True
}
}
params = {"projection": projection, "ortho_scale": scale}
mock_blender_connection.set_response("set_camera_projection", params, result)
bdd_context["camera_result"] = mock_blender_connection.send_command("set_camera_projection", params)
@when("I render the scene")
def render_scene(bdd_context):
camera = bdd_context.get("camera", {})
viewport_proj = bdd_context.get("viewport_projection", "PERSP")
# Render uses camera projection, not viewport
if camera.get("projection") != viewport_proj:
bdd_context["render_warning"] = "Camera and viewport projections differ"
bdd_context["render_performed"] = True
bdd_context["render_projection"] = camera.get("projection", "PERSP")
@when("I call align_camera_to_view")
def call_align_camera_to_view(bdd_context, mock_blender_connection):
viewport_alignment = bdd_context.get("viewport_alignment", "FRONT")
result = {
"success": True,
"result": {
"camera_aligned": True,
"viewport_orientation": viewport_alignment,
"camera_matches_viewport": True
}
}
mock_blender_connection.set_response("align_camera_to_view", {}, result)
bdd_context["align_camera_result"] = mock_blender_connection.send_command("align_camera_to_view", {})
@when(parsers.parse('I call align_view_to_axis with axis="{axis}", side="{side}"'))
def call_align_view(bdd_context, axis, side):
# This step is already defined in test_08_viewport_controls.py
# Just update context for combined workflow
view_map = {
("Y", "POS"): "FRONT"
}
bdd_context["viewport_alignment"] = view_map.get((axis, side), "FRONT")
@when("I render the image")
def render_image(bdd_context):
bdd_context["final_render"] = {
"projection": bdd_context.get("camera", {}).get("projection", "ORTHO"),
"view": bdd_context.get("viewport_alignment", "FRONT")
}
@then("the camera uses orthographic projection")
def camera_uses_ortho(bdd_context):
result = bdd_context["camera_result"]
data = result["result"]
assert data.get("projection") == "ORTHO", "Camera should use orthographic projection"
@then("rendered images will have no perspective distortion")
@then("parallel lines remain parallel in renders")
def no_perspective_distortion(bdd_context):
camera = bdd_context.get("camera", {})
assert camera.get("projection") == "ORTHO", "Ortho projection has no distortion"
@then("the ortho_scale is calculated to frame all objects")
def ortho_scale_calculated(bdd_context):
result = bdd_context["camera_result"]
data = result["result"]
assert data.get("scale_auto_calculated", False), "Should auto-calculate ortho_scale"
@then("all geometry is visible in the render")
def all_geometry_visible(bdd_context):
result = bdd_context["camera_result"]
data = result["result"]
assert data.get("all_objects_visible", False), "All objects should be visible"
@then("the render uses perspective (camera setting)")
def render_uses_perspective(bdd_context):
render_proj = bdd_context.get("render_projection", "PERSP")
assert render_proj == "PERSP", "Render should use camera projection (perspective)"
@then("a warning is logged")
def warning_logged(bdd_context):
warning = bdd_context.get("render_warning")
assert warning is not None, "Should log warning about projection mismatch"
@then("the tool explains to set the camera projection separately")
def explains_separate_projection(bdd_context):
# Warning message should explain this
assert True, "Tool should explain camera vs viewport projection"
@then("the camera matches the current viewport orientation")
def camera_matches_viewport(bdd_context):
result = bdd_context["align_camera_result"]
data = result["result"]
assert data.get("camera_matches_viewport", False), "Camera should match viewport"
@then("subsequent renders show the front view")
def renders_show_front(bdd_context):
result = bdd_context["align_camera_result"]
assert result["success"], "Renders should show front view after alignment"
@then("I get a perfect orthographic front view render")
def perfect_ortho_front_render(bdd_context):
final_render = bdd_context.get("final_render", {})
assert final_render.get("projection") == "ORTHO", "Should be orthographic"
assert final_render.get("view") == "FRONT", "Should be front view"
