use super::*;
use crate::identity::{ApplicationId, WorldGeneration};
use bevy_ecs::entity::Entity;
use sim_engine::{Color, SurfaceStyle3d};
fn source(generation: u64, row: u32) -> LogicEntity {
let application = ApplicationId::from_raw(7);
LogicEntity::new(
application,
WorldGeneration::new(application, generation),
Entity::from_raw_u32(row).unwrap(),
)
}
fn state(source: LogicEntity) -> AppliedState {
AppliedState {
source,
transform: Transform3d::IDENTITY,
style: MeshStyle3d::surface(SurfaceStyle3d::opaque(Color::WHITE).unwrap()),
visible: true,
}
}
#[test]
fn same_geometry_refreshes_source_after_reorder_and_world_replacement() {
let mut applied = state(source(1, 2));
for current in [source(1, 3), source(2, 3), source(3, 0)] {
applied
.update(state(current), |_| -> Result<(), ()> {
panic!("identity-only changes must not call Engine setters")
})
.unwrap();
assert_eq!(applied.source, current);
assert!(applied.visible);
}
}
#[test]
fn source_lookup_uses_complete_identity_and_ignores_hidden_slots() {
let slots = [
((1, 7), source(1, 0), true),
((2, 7), source(2, 0), true),
((2, 8), source(2, 1), false),
];
assert_eq!(find_object_source((1, 7), slots), Some(source(1, 0)));
assert_eq!(find_object_source((2, 7), slots), Some(source(2, 0)));
assert_eq!(find_object_source((2, 8), slots), None);
assert_eq!(find_object_source((3, 7), slots), None);
}
#[test]
fn scene_wide_failures_preserve_the_engine_category_without_attribution() {
for error in [
Mesh3dRenderError::RendererMismatch,
Mesh3dRenderError::InvalidGeometryTransform,
Mesh3dRenderError::UnportableSurfaceTopology,
Mesh3dRenderError::InstanceCapacityTooLarge,
Mesh3dRenderError::CameraTargetAspectMismatch,
Mesh3dRenderError::InvalidEdgeProjection,
Mesh3dRenderError::GeneratedGeometryCapacityTooLarge,
] {
assert!(matches!(
map_render_error(error, &[]),
DesktopThreeDError::Render(preserved) if preserved == error
));
}
}
#[test]
fn engine_scene_budget_uses_logic_objects_and_finite_untextured_memory_caps() {
let defaults = Scene3dBudget::default();
let budget = engine_scene_budget(ThreeDRenderLimits::new(123, 1476, 640 * 360)).unwrap();
assert_eq!(budget.max_objects(), 123);
assert_eq!(budget.max_storage_bytes(), defaults.max_storage_bytes());
assert_eq!(budget.max_mesh_cpu_bytes(), defaults.max_mesh_cpu_bytes());
assert_eq!(budget.max_mesh_gpu_bytes(), defaults.max_mesh_gpu_bytes());
assert_eq!(budget.max_texture_cpu_bytes(), 0);
assert_eq!(budget.max_texture_gpu_bytes(), 0);
let scene = Scene3d::with_budget(Color::BLACK, budget).unwrap();
assert_eq!(scene.budget(), budget);
assert_eq!(scene.statistics().object_count(), 0);
}
#[test]
fn background_only_engine_minimum_does_not_enable_logic_objects() {
let limits = ThreeDRenderLimits::new(0, 0, 640 * 360);
assert_eq!(engine_scene_budget(limits).unwrap().max_objects(), 1);
assert!(check_limits(0, 640, 360, limits).is_ok());
assert!(matches!(
check_limits(1, 640, 360, limits),
Err(DesktopThreeDError::LimitExceeded {
resource: ThreeDLimitResource::Cuboids,
requested: 1,
limit: 0,
})
));
let budget = engine_render_budget(0, limits);
assert_eq!(budget.max_generated_vertices(), 0);
assert_eq!(budget.max_generated_triangles(), 0);
}
#[test]
fn exact_total_cap_replaces_the_old_retained_cube_reservation() {
for count in 1..=32 {
for spare in [0, 1, 12, 84, 4096] {
let limit = count * 12 + spare;
let budget = engine_render_budget(count, ThreeDRenderLimits::new(count, limit, 1));
assert_eq!(budget.max_surface_triangles(), limit);
assert_eq!(budget.max_generated_triangles(), limit);
assert_eq!(budget.max_generated_vertices(), 3 * limit);
assert_eq!(
budget.surface_policy(),
SurfaceRasterization3d::StrictPortable
);
}
}
}
#[test]
fn generated_budget_arithmetic_stays_bounded_at_extreme_author_limits() {
let limits = ThreeDRenderLimits::new(usize::MAX, usize::MAX, u64::MAX);
let defaults = Mesh3dRenderBudget::default();
for count in [0, 1, 2, usize::MAX / 12, usize::MAX] {
let budget = engine_render_budget(count, limits);
assert!(budget.max_generated_vertices() <= defaults.max_generated_vertices());
assert!(budget.max_generated_triangles() <= defaults.max_generated_triangles());
assert!(budget.max_generated_upload_bytes() <= defaults.max_generated_upload_bytes());
}
assert!(check_limits(usize::MAX, 1, 1, limits).is_err());
}
#[test]
fn texture_allowance_includes_engine_mip_recovery_and_transparent_backgrounds() {
let limits = ThreeDRenderLimits::new(0, 1, 1).with_texture_limits(1024, 2048);
let budget = engine_scene_budget(limits).unwrap();
assert_eq!(budget.max_texture_cpu_bytes(), 2048);
assert_eq!(budget.max_texture_gpu_bytes(), 2048);
let scene = Scene3d::with_alpha_background_and_budget(Color::TRANSPARENT, budget).unwrap();
assert_eq!(scene.background(), Color::TRANSPARENT);
}
#[test]
fn engine_background_mutation_preserves_environment_budget_and_rejected_color() {
let budget = engine_scene_budget(ThreeDRenderLimits::new(12, 144, 640 * 360)).unwrap();
let mut scene = Scene3d::with_budget(Color::BLACK, budget).unwrap();
let lighting =
sim_engine::Lighting3d::new(sim_engine::AmbientLight3d::new(Color::WHITE, 0.6).unwrap());
let fog = Some(sim_engine::Fog3d::new(Color::WHITE, 1.0, 0.1).unwrap());
scene.set_lighting(lighting);
scene.set_fog(fog);
let before = scene.statistics();
for background in [Color::TRANSPARENT, Color::rgba(0.2, 0.3, 0.4, 0.5)] {
scene.set_background(background).unwrap();
assert_eq!(scene.background(), background);
assert_eq!(scene.statistics(), before);
assert_eq!(scene.budget(), budget);
assert_eq!(scene.lighting(), lighting);
assert_eq!(scene.fog(), fog);
assert_eq!(
scene.set_background(Color::rgba(0.2, 0.3, 0.4, 1.1)),
Err(Scene3dError::InvalidBackground)
);
assert_eq!(scene.background(), background);
}
}
#[test]
fn target_replacement_policy_preserves_steady_state_and_invalidates_failures() {
let descriptor = TargetDescriptor {
width: 640,
height: 360,
viewport: LogicalViewport::new(640.0, 360.0).unwrap(),
};
let changed = TargetDescriptor {
viewport: LogicalViewport::new(320.0, 180.0).unwrap(),
..descriptor
};
let mut cache = TargetCache::new();
assert!(!cache.matches(descriptor));
cache.ensure(descriptor, || Ok::<_, ()>(1)).unwrap();
assert!(cache.matches(descriptor));
assert!(!cache.matches(changed));
assert_eq!(
cache.ensure(changed, || Err::<i32, _>("allocation")),
Err("allocation")
);
assert!(!cache.matches(descriptor));
assert!(!cache.matches(changed));
cache.ensure(changed, || Ok::<_, ()>(2)).unwrap();
assert!(cache.matches(changed));
cache.clear();
assert!(!cache.matches(changed));
}