hugo/MetaCrate
1
0
Fork 0
Code Issues 2 Pull Requests Actions Packages Projects Releases Wiki Activity

Fix varregion scene capture and legacy rendering
Some checks failed
CI / rust-skia (Rust only) (push) Has been cancelled
Details
CI / required (push) Has been cancelled
Details

Browse Source
This commit is contained in:
Chili Palmer
2026-08-23 10:18:19 +02:00
parent 19ebee129b
commit d85f7d22f2
23 changed files with 1313 additions and 516 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
crates/metacrate-grid-agent/Cargo.toml
View File

@@ -12,6 +12,7 @@ publish = false
async-trait = "0.1.89"
base64 = "0.22"
crossterm = "0.29"
directories = { version = "6.0.0", optional = true }
libremetaverse = { version = "0.0.1", path = "../libremetaverse", default-features = false, optional = true }
libremetaverse-imaging = { version = "0.0.1", path = "../libremetaverse-imaging", default-features = false, features = ["rust-j2k"], optional = true }
libremetaverse-rendering-simple = { version = "0.0.1", path = "../libremetaverse-rendering-simple", optional = true }
@@ -39,7 +40,7 @@ tokio = { version = "1.53.1", features = ["io-util", "net", "rt-multi-thread", "
[features]
default = []
live-grid = ["dep:libremetaverse", "dep:libremetaverse-imaging", "dep:libremetaverse-rendering-simple", "metacrate-rendering-wgpu/wgpu"]
live-grid = ["dep:directories", "dep:libremetaverse", "dep:libremetaverse-imaging", "dep:libremetaverse-rendering-simple", "metacrate-rendering-wgpu/wgpu"]
[lints]
workspace = true

53
crates/metacrate-grid-agent/src/backend.rs
View File

@@ -94,6 +94,7 @@ impl OfflineGridBackend {
#[cfg(feature = "live-grid")]
pub struct LibremetaverseClientOwner {
client: libremetaverse::GridClient,
grid: libremetaverse::GridManager,
network: libremetaverse::NetworkManager,
agent: Arc<libremetaverse::AgentManager>,
delivery_generation: Arc<std::sync::RwLock<Option<u64>>>,
@@ -131,6 +132,7 @@ impl fmt::Debug for LibremetaverseClientOwner {
#[cfg(feature = "live-grid")]
#[derive(Clone)]
pub struct LibremetaverseSessionBackend {
grid: libremetaverse::GridManager,
network: libremetaverse::NetworkManager,
agent: Arc<libremetaverse::AgentManager>,
throttle: libremetaverse::AgentThrottle,
@@ -165,7 +167,10 @@ impl LibremetaverseClientOwner {
///
/// Returns a backend configuration error if the shared client defaults are invalid.
pub fn new() -> Result<Self, BackendError> {
let mut settings = libremetaverse::Settings::default();
settings.asset_cache_mut().dir = metacrate_cache_dir()?.to_string_lossy().into_owned();
let client = libremetaverse::GridClientBuilder::default()
.with_settings(settings)
.build()
.map_err(|_| BackendError::Configuration {
component: "libremetaverse client defaults",
@@ -173,7 +178,7 @@ impl LibremetaverseClientOwner {
// The compatibility client caches its network manager weakly. Retain the
// composition root before managers register packet subscriptions on it.
let network = client.network();
let _grid = client.grid();
let grid = client.grid();
let _terrain = client.terrain();
let _objects = client.objects();
let agent = Arc::new(
@@ -185,6 +190,7 @@ impl LibremetaverseClientOwner {
);
Ok(Self {
client,
grid,
network,
agent,
delivery_generation: Arc::new(std::sync::RwLock::new(None)),
@@ -281,6 +287,7 @@ impl LibremetaverseClientOwner {
});
}
Ok(LibremetaverseSessionBackend {
grid: self.grid.clone(),
network: self.network.clone(),
agent: Arc::clone(&self.agent),
throttle: libremetaverse::AgentThrottle::new_with_grid_client(self.client.clone())
@@ -324,6 +331,15 @@ impl LibremetaverseClientOwner {
}
}
#[cfg(feature = "live-grid")]
fn metacrate_cache_dir() -> Result<std::path::PathBuf, BackendError> {
directories::ProjectDirs::from("", "", "metacrate")
.map(|directories| directories.cache_dir().to_owned())
.ok_or(BackendError::Configuration {
component: "platform cache directory",
})
}
#[cfg(feature = "live-grid")]
impl LibremetaverseWorldSnapshotSource {
#[must_use]
@@ -668,15 +684,15 @@ impl crate::behavior::EmbodimentSink for LibremetaverseEmbodimentSink {
.network()
.native_current_sim()
.ok_or(crate::behavior::BehaviorError::NotReady)?;
let (region_size_x, region_size_y) = simulator.region_size();
let current_position = self.agent.sim_position();
let reported_bounds_contain_agent = f64::from(current_position.x)
<= f64::from(simulator.size_x)
&& f64::from(current_position.y) <= f64::from(simulator.size_y);
<= f64::from(region_size_x)
&& f64::from(current_position.y) <= f64::from(region_size_y);
if point.x < 0.0
|| point.y < 0.0
|| (reported_bounds_contain_agent
&& (point.x > f64::from(simulator.size_x)
|| point.y > f64::from(simulator.size_y)))
&& (point.x > f64::from(region_size_x) || point.y > f64::from(region_size_y)))
{
return Err(crate::behavior::BehaviorError::RegionBoundary);
}
@@ -1108,12 +1124,25 @@ impl crate::session::GridSessionBackend for LibremetaverseSessionBackend {
)
})?;
self.throttle
.set_with_simulator(Some(simulator))
.set_with_simulator(Some(simulator.clone()))
.map_err(|_| {
crate::session::SessionFailure::new(
crate::session::SessionFailureKind::TransientTransport,
)
})?;
let readiness_simulator = simulator.clone();
let _ = tokio::task::spawn_blocking(move || {
readiness_simulator.native_is_event_queue_running(Some(true))
})
.await;
let _ = self
.grid
.get_grid_region_with_string_grid_layer_type_cancellation_token(
simulator.name.clone(),
libremetaverse::GridLayerType::Objects,
Some(cancellation.clone()),
)
.await;
native_reset_camera(&self.agent).map_err(|_| {
crate::session::SessionFailure::new(
crate::session::SessionFailureKind::TransientTransport,
@@ -1519,4 +1548,16 @@ mod tests {
crate::session::SessionFailureKind::InvalidCredentials,
);
}
#[cfg(feature = "live-grid")]
#[test]
fn asset_cache_is_platform_scoped_to_metacrate() {
let cache = metacrate_cache_dir().expect("platform cache directory");
assert!(cache.is_absolute());
assert!(
cache
.components()
.any(|part| part.as_os_str() == "metacrate")
);
}
}

5
crates/metacrate-grid-agent/src/build.rs
View File

@@ -1157,8 +1157,9 @@ impl BuildGrid for LibremetaverseBuildGrid {
return Err(BuildError::OutOfRegion);
}
let base = self.agent.sim_position();
let (region_size_x, region_size_y) = simulator.region_size();
let reported_bounds_contain_agent =
base.x <= simulator.size_x as f32 && base.y <= simulator.size_y as f32;
base.x <= region_size_x as f32 && base.y <= region_size_y as f32;
for offset in positions {
let point = libremetaverse_types::Vector3 {
x: base.x + offset[0] as f32 / 1000.0,
@@ -1168,7 +1169,7 @@ impl BuildGrid for LibremetaverseBuildGrid {
if point.x < 0.0
|| point.y < 0.0
|| (reported_bounds_contain_agent
&& (point.x > simulator.size_x as f32 || point.y > simulator.size_y as f32))
&& (point.x > region_size_x as f32 || point.y > region_size_y as f32))
{
return Err(BuildError::OutOfRegion);
}

496
crates/metacrate-grid-agent/src/vision.rs
View File

@@ -95,36 +95,36 @@ pub struct VisionLimits {
impl Default for VisionLimits {
fn default() -> Self {
Self {
width: 640,
height: 360,
width: 1920,
height: 1080,
max_distance_meters: 64,
max_entities: 512,
max_triangles: 131_072,
max_entities: 2_048,
max_triangles: 1_048_576,
max_texture_fetches: 1_024,
max_texture_bytes: 512 * 1024 * 1024,
max_decode_pixels: 134_217_728,
max_jpeg_bytes: 512 * 1024,
max_decode_pixels: 268_435_456,
max_jpeg_bytes: 2 * 1024 * 1024,
max_concurrent_captures: 1,
capture_timeout: Duration::from_mins(2),
capture_timeout: Duration::from_mins(8),
minimum_interval: Duration::from_secs(5),
}
}
}
impl VisionLimits {
pub(crate) fn valid(self) -> bool {
(64..=640).contains(&self.width)
&& (64..=480).contains(&self.height)
&& self.width as usize * self.height as usize <= 307_200
(64..=1_920).contains(&self.width)
&& (64..=1_080).contains(&self.height)
&& self.width as usize * self.height as usize <= 2_073_600
&& (1..=1_024).contains(&self.max_distance_meters)
&& (1..=1_024).contains(&self.max_entities)
&& (1..=262_144).contains(&self.max_triangles)
&& (1..=4_096).contains(&self.max_entities)
&& (1..=1_048_576).contains(&self.max_triangles)
&& self.max_texture_fetches <= 1_024
&& self.max_texture_bytes <= 512 * 1024 * 1024
&& self.max_decode_pixels <= 134_217_728
&& (4_096..=1024 * 1024).contains(&self.max_jpeg_bytes)
&& self.max_decode_pixels <= 536_870_912
&& (4_096..=4 * 1024 * 1024).contains(&self.max_jpeg_bytes)
&& (1..=4).contains(&self.max_concurrent_captures)
&& !self.capture_timeout.is_zero()
&& self.capture_timeout <= Duration::from_mins(5)
&& self.capture_timeout <= Duration::from_mins(10)
&& self.minimum_interval <= Duration::from_mins(10)
}
}
@@ -867,8 +867,8 @@ fn environment_color(scene: &SceneSnapshot) -> [u8; 4] {
let phase = (scene.observed_unix_millis / 1000 % 86_400) as f32 / 86_400.0;
let light = (phase * std::f32::consts::TAU)
.sin()
.mul_add(24.0, 72.0)
.clamp(32.0, 112.0) as u8;
.mul_add(20.0, 125.0)
.clamp(96.0, 160.0) as u8;
[
light,
light.saturating_add(24),
@@ -888,7 +888,7 @@ fn encode_jpeg(
.flat_map(|pixel| pixel[..3].iter().copied())
.collect::<Vec<_>>();
let mut output = Vec::new();
jpeg_encoder::Encoder::new(&mut output, 82)
jpeg_encoder::Encoder::new(&mut output, 92)
.encode(
&rgb,
width as u16,
@@ -1000,15 +1000,27 @@ async fn request_asset_bytes(
asset_type: libremetaverse_types::AssetType,
cancellation: CancellationToken,
) -> Option<Vec<u8>> {
tokio::time::timeout(
Duration::from_secs(15),
assets.request_asset_with_uuid_asset_type_boolean_cancellation_token(
id,
asset_type,
false,
Some(cancellation),
),
)
tokio::time::timeout(Duration::from_secs(8), async {
match asset_type {
libremetaverse_types::AssetType::Texture => {
let _ = assets
.request_image(id, None, Some(cancellation.clone()))
.await;
}
libremetaverse_types::AssetType::Mesh => {
let _ = assets.request_mesh(id, Some(cancellation.clone())).await;
}
_ => {}
}
assets
.request_asset_with_uuid_asset_type_boolean_cancellation_token(
id,
asset_type,
false,
Some(cancellation),
)
.await
})
.await
.ok()
.and_then(Result::ok)
@@ -1128,8 +1140,26 @@ impl SceneSource for LibremetaverseSceneSource {
(world, attachments)
};
world.sort_by(|left, right| {
scene_distance_squared(left.position, camera_position)
.total_cmp(&scene_distance_squared(right.position, camera_position))
let left_visible = scene_center_visible(
left.position,
camera_position,
camera_forward,
camera.vertical_fov_angle(),
self.limits.width as f32 / self.limits.height as f32,
maximum_distance,
);
let right_visible = scene_center_visible(
right.position,
camera_position,
camera_forward,
camera.vertical_fov_angle(),
self.limits.width as f32 / self.limits.height as f32,
maximum_distance,
);
right_visible.cmp(&left_visible).then_with(|| {
scene_distance_squared(left.position, camera_position)
.total_cmp(&scene_distance_squared(right.position, camera_position))
})
});
attachments.sort_by(|left, right| {
scene_distance_squared(left.position, camera_position)
@@ -1149,21 +1179,47 @@ impl SceneSource for LibremetaverseSceneSource {
avatars.truncate(avatar_limit);
let region_id = simulator.region_id;
let region_name = simulator.name.clone();
{
let mut cache = lock(&self.cache);
if cache.region_id != Some(region_id) {
cache.region_id = Some(region_id);
cache.textures.clear();
cache.texture_pixels = 0;
cache.geometry.clear();
cache.access = 0;
}
}
let water = simulator.water_height;
let region_size = (simulator.size_x as f32, simulator.size_y as f32);
let (region_size_x, region_size_y) = simulator.region_size();
let region_size = (region_size_x as f32, region_size_y as f32);
let terrain = simulator
.terrain
.read()
.unwrap_or_else(std::sync::PoisonError::into_inner)
.clone();
let terrain_available = terrain.iter().any(|patch| patch.data.len() == 256);
let terrain_texture_ids = [
simulator.terrain_detail0,
simulator.terrain_detail1,
simulator.terrain_detail2,
simulator.terrain_detail3,
];
let mut texture_ids = terrain_texture_ids
let terrain_materials = TerrainMaterials {
texture_ids: [
simulator.terrain_detail0,
simulator.terrain_detail1,
simulator.terrain_detail2,
simulator.terrain_detail3,
],
start_heights: [
simulator.terrain_start_height00,
simulator.terrain_start_height01,
simulator.terrain_start_height10,
simulator.terrain_start_height11,
],
height_ranges: [
simulator.terrain_height_range00,
simulator.terrain_height_range01,
simulator.terrain_height_range10,
simulator.terrain_height_range11,
],
};
let mut texture_ids = terrain_materials
.texture_ids
.into_iter()
.filter(|id| *id != UUID::zero())
.collect::<Vec<_>>();
@@ -1200,12 +1256,21 @@ impl SceneSource for LibremetaverseSceneSource {
}
let mesh_ids = prims
.iter()
.filter(|prim| {
let signature = geometry_signature(prim, camera_position);
!lock(&self.cache)
.geometry
.get(&prim.id)
.is_some_and(|cached| cached.signature == signature)
})
.filter_map(|prim| prim.sculpt.as_ref())
.filter(|sculpt| sculpt.type_() == libremetaverse_types::SculptType::Mesh)
.map(|sculpt| sculpt.sculpt_texture)
.filter(|id| *id != UUID::zero())
.fold(Vec::new(), |mut ids, id| {
if !ids.contains(&id) && ids.len() < self.limits.max_texture_fetches / 2 {
// ponytail: stage 256 new meshes per frame; switch to an adaptive
// scheduler if live convergence proves this ceiling too slow.
if !ids.contains(&id) && ids.len() < 256 {
ids.push(id);
}
ids
@@ -1216,19 +1281,14 @@ impl SceneSource for LibremetaverseSceneSource {
let legacy_materials = if legacy_material_ids.is_empty() {
Vec::new()
} else {
tokio::time::timeout(
Duration::from_secs(5),
self.client
.objects()
.request_materials_with_simulator_cancellation_token(
simulator.clone(),
Some(cancellation.clone()),
),
)
.await
.ok()
.and_then(Result::ok)
.map_or_else(Vec::new, Iterator::collect)
self.client
.objects()
.request_materials_with_simulator_cancellation_token(
simulator.clone(),
Some(cancellation.clone()),
)
.await
.map_or_else(|_| Vec::new(), Iterator::collect)
};
for material in &legacy_materials {
for id in [material.normal_map(), material.specular_map()] {
@@ -1300,23 +1360,19 @@ impl SceneSource for LibremetaverseSceneSource {
texture_ids.retain(|id| *id != UUID::zero());
let scene_texture_ids = texture_ids.clone();
{
let mut cache = lock(&self.cache);
if cache.region_id != Some(region_id) {
cache.region_id = Some(region_id);
cache.textures.clear();
cache.texture_pixels = 0;
cache.geometry.clear();
cache.access = 0;
}
let cache = lock(&self.cache);
texture_ids.retain(|id| !cache.textures.contains_key(id));
}
texture_ids.truncate(
self.limits.max_texture_fetches.saturating_sub(
mesh_ids
.len()
.saturating_add(pbr_material_ids.len())
.saturating_add(legacy_material_fetches),
),
self.limits
.max_texture_fetches
.saturating_sub(
mesh_ids
.len()
.saturating_add(pbr_material_ids.len())
.saturating_add(legacy_material_fetches),
)
.min(256),
);
let texture_fetches = texture_ids
.len()
@@ -1395,7 +1451,7 @@ impl SceneSource for LibremetaverseSceneSource {
let decode_bytes = self.limits.max_texture_bytes;
let max_cached_geometry = self.limits.max_entities;
let cache = Arc::clone(&self.cache);
let (entities, textures, decoded_texture_pixels) =
let (entities, textures, decoded_texture_pixels, geometry_truncated) =
tokio::task::spawn_blocking(move || {
native_entities(
prims,
@@ -1403,7 +1459,7 @@ impl SceneSource for LibremetaverseSceneSource {
water,
region_size,
&terrain,
terrain_texture_ids,
terrain_materials,
maximum,
encoded_textures,
encoded_meshes,
@@ -1414,6 +1470,7 @@ impl SceneSource for LibremetaverseSceneSource {
&scene_texture_ids,
max_cached_geometry,
camera_position,
maximum_distance,
)
})
.await
@@ -1447,7 +1504,7 @@ impl SceneSource for LibremetaverseSceneSource {
entities,
textures,
completeness: SnapshotCompleteness {
objects_truncated,
objects_truncated: objects_truncated || geometry_truncated,
avatars_truncated,
textures_missing,
terrain_available,
@@ -1580,6 +1637,14 @@ fn world_primitive(
None
}
#[cfg(feature = "live-grid")]
#[derive(Clone, Copy)]
pub(crate) struct TerrainMaterials {
pub(crate) texture_ids: [UUID; 4],
pub(crate) start_heights: [f32; 4],
pub(crate) height_ranges: [f32; 4],
}
#[cfg(feature = "live-grid")]
#[allow(clippy::too_many_arguments, clippy::too_many_lines)] // Single blocking scene-conversion boundary.
fn native_entities(
@@ -1588,7 +1653,7 @@ fn native_entities(
water: f32,
region_size: (f32, f32),
terrain: &[libremetaverse::TerrainPatch],
terrain_texture_ids: [UUID; 4],
terrain_materials: TerrainMaterials,
maximum: usize,
encoded_textures: Vec<(UUID, Vec<u8>)>,
encoded_meshes: Vec<(UUID, Vec<u8>)>,
@@ -1599,7 +1664,8 @@ fn native_entities(
scene_texture_ids: &[UUID],
max_cached_geometry: usize,
camera_position: [f32; 3],
) -> Result<(Vec<SceneEntity>, Vec<SceneTexture>, usize), VisionError> {
maximum_distance: f32,
) -> Result<(Vec<SceneEntity>, Vec<SceneTexture>, usize, bool), VisionError> {
let (textures, pixels_consumed) = cached_textures(
cache,
scene_texture_ids,
@@ -1627,10 +1693,16 @@ fn native_entities(
let mut entities = Vec::new();
let mut triangles = 0usize;
let mut gpu_triangles = 0usize;
let mut geometry_truncated = false;
let avatar_triangle_reserve = avatars.len().saturating_mul(2).min(maximum / 4);
let terrain_triangle_reserve = ((maximum_distance.ceil() as usize).saturating_mul(2))
.saturating_pow(2)
.saturating_mul(2)
.min(maximum / 2);
let object_triangle_limit = maximum
.saturating_div(2)
.saturating_sub(avatar_triangle_reserve);
.saturating_sub(terrain_triangle_reserve)
.saturating_sub(avatar_triangle_reserve)
.saturating_sub(2);
for prim in prims {
if triangles >= object_triangle_limit || gpu_triangles >= object_triangle_limit {
break;
@@ -1640,16 +1712,7 @@ fn native_entities(
|properties| properties.name.clone(),
);
let detail = scene_detail_level(&prim, camera_position);
let signature = GeometrySignature {
construction: prim.prim_data.clone(),
sculpt: prim.sculpt.clone(),
textures: prim
.textures
.as_ref()
.and_then(|textures| textures.get_bytes().ok())
.unwrap_or_default(),
detail,
};
let signature = geometry_signature(&prim, camera_position);
let mesh = cached_geometry(cache, prim.id, &signature).or_else(|| {
let generated = if let Some(sculpt) = &prim.sculpt {
if sculpt.type_() == libremetaverse_types::SculptType::Mesh {
@@ -1687,6 +1750,24 @@ fn native_entities(
))
});
let Some(mesh) = mesh else { continue };
let object_triangles = mesh
.faces
.iter()
.map(|face| {
face.indices
.chunks_exact(3)
.filter(|indices| {
indices
.iter()
.all(|index| usize::from(*index) < face.vertices.len())
})
.count()
})
.sum::<usize>();
if gpu_triangles.saturating_add(object_triangles) > object_triangle_limit {
geometry_truncated = true;
continue;
}
let mut output = Vec::new();
let mut renderables = Vec::new();
let mut texture_complete = true;
@@ -1701,7 +1782,6 @@ fn native_entities(
let texture = textures.get(&face.texture_face.texture_id());
if face.texture_face.texture_id() != UUID::zero() && texture.is_none() {
texture_complete = false;
continue;
}
let gpu_vertices = face
.vertices
@@ -1716,7 +1796,6 @@ fn native_entities(
.iter()
.all(|index| usize::from(*index) < gpu_vertices.len())
})
.take(object_triangle_limit.saturating_sub(gpu_triangles))
.flatten()
.map(|index| u32::from(*index))
.collect::<Vec<_>>();
@@ -1767,9 +1846,6 @@ fn native_entities(
}
let shade = triangle_shade(vertices);
colors = colors.map(|color| shade_color(color, shade));
if triangles >= object_triangle_limit {
break;
}
triangles += 1;
output.push(SceneTriangle {
vertices,
@@ -1834,7 +1910,9 @@ fn native_entities(
region_size,
water,
&textures,
terrain_texture_ids,
terrain_materials,
camera_position,
maximum_distance,
maximum.saturating_sub(triangles).saturating_sub(2),
);
if !terrain_triangles.is_empty() {
@@ -1847,7 +1925,8 @@ fn native_entities(
display_name: "simulator terrain".into(),
triangles: terrain_triangles,
renderables,
texture_available: terrain_texture_ids
texture_available: terrain_materials
.texture_ids
.iter()
.any(|id| textures.contains_key(id)),
});
@@ -1884,7 +1963,7 @@ fn native_entities(
.values()
.map(|texture| texture.scene_texture())
.collect();
Ok((entities, gpu_textures, pixels_consumed))
Ok((entities, gpu_textures, pixels_consumed, geometry_truncated))
}
#[cfg(feature = "live-grid")]
@@ -1938,16 +2017,30 @@ fn store_geometry(
}
#[cfg(feature = "live-grid")]
fn scene_detail_level(
fn geometry_signature(prim: &libremetaverse::Primitive, camera: [f32; 3]) -> GeometrySignature {
GeometrySignature {
construction: prim.prim_data.clone(),
sculpt: prim.sculpt.clone(),
textures: prim
.textures
.as_ref()
.and_then(|textures| textures.get_bytes().ok())
.unwrap_or_default(),
detail: scene_detail_level(prim, camera),
}
}
#[cfg(feature = "live-grid")]
pub(crate) fn scene_detail_level(
prim: &libremetaverse::Primitive,
camera: [f32; 3],
) -> libremetaverse::rendering::DetailLevel {
let distance = scene_distance_squared(prim.position, camera).sqrt();
let extent = prim.scale.x.max(prim.scale.y).max(prim.scale.z);
if distance < 12.0 && extent < 16.0 {
libremetaverse::rendering::DetailLevel::High
if distance < 32.0 || extent >= 16.0 {
libremetaverse::rendering::DetailLevel::Highest
} else {
libremetaverse::rendering::DetailLevel::Medium
libremetaverse::rendering::DetailLevel::High
}
}
@@ -1989,7 +2082,7 @@ fn native_gpu_vertex(
#[cfg(feature = "live-grid")]
#[allow(clippy::too_many_lines)] // Direct mapping of the two supported material models.
fn face_material(
pub(crate) fn face_material(
face: &libremetaverse::PrimitiveTextureEntryFace,
textures: &std::collections::BTreeMap<UUID, usize>,
legacy_materials: &std::collections::BTreeMap<UUID, libremetaverse::materials::LegacyMaterial>,
@@ -2037,6 +2130,7 @@ fn face_material(
],
double_sided: material.double_sided(),
alpha_mode: match material.alpha_mode() {
libremetaverse::assets::GltfAlphaMode::Opaque if tint.a < 0.999 => AlphaMode::Blend,
libremetaverse::assets::GltfAlphaMode::Opaque => AlphaMode::Opaque,
libremetaverse::assets::GltfAlphaMode::Blend => AlphaMode::Blend,
libremetaverse::assets::GltfAlphaMode::Mask => AlphaMode::Mask {
@@ -2046,6 +2140,15 @@ fn face_material(
});
}
let rgba = face.rgba();
let automatic_alpha = || {
if rgba.a < 0.999 {
AlphaMode::Blend
} else if texture_has_alpha {
AlphaMode::Mask { cutoff: 0.5 }
} else {
AlphaMode::Opaque
}
};
let legacy = legacy_materials.get(&face.material_id());
let shininess = match face.shiny() {
libremetaverse::Shininess::None => 1.0,
@@ -2096,10 +2199,16 @@ fn face_material(
rotation_radians: material.specular_map_rotation() as f32,
},
}),
specular_color_srgb: legacy.map_or([255; 3], |material| {
let color = material.specular_color();
[unit_byte(color.r), unit_byte(color.g), unit_byte(color.b)]
}),
specular_color_srgb: legacy.map_or_else(
|| match face.shiny() {
libremetaverse::Shininess::None => [0; 3],
_ => [255; 3],
},
|material| {
let color = material.specular_color();
[unit_byte(color.r), unit_byte(color.g), unit_byte(color.b)]
},
),
shininess: legacy.map_or(shininess, |material| {
f32::from(material.specular_exponent()).max(1.0)
}),
@@ -2111,28 +2220,33 @@ fn face_material(
material.diffuse_alpha_mode()
== libremetaverse::materials::LegacyMaterialAlphaMode::Emissive
}),
alpha_mode: legacy.map_or_else(
|| {
if rgba.a < 0.999 || texture_has_alpha {
AlphaMode::Blend
} else {
AlphaMode::Opaque
}
},
|material| match material.diffuse_alpha_mode() {
libremetaverse::materials::LegacyMaterialAlphaMode::Blend
| libremetaverse::materials::LegacyMaterialAlphaMode::Emissive => AlphaMode::Blend,
libremetaverse::materials::LegacyMaterialAlphaMode::Mask => AlphaMode::Mask {
cutoff: f32::from(material.alpha_mask_cutoff()) / 255.0,
},
libremetaverse::materials::LegacyMaterialAlphaMode::Default => {
if rgba.a < 0.999 || texture_has_alpha {
alpha_mode: legacy.map_or_else(automatic_alpha, |material| {
if rgba.a < 0.999 {
AlphaMode::Blend
} else {
match material.diffuse_alpha_mode() {
libremetaverse::materials::LegacyMaterialAlphaMode::Blend
| libremetaverse::materials::LegacyMaterialAlphaMode::Emissive => {
AlphaMode::Blend
} else {
AlphaMode::Opaque
}
libremetaverse::materials::LegacyMaterialAlphaMode::Mask => AlphaMode::Mask {
cutoff: f32::from(material.alpha_mask_cutoff()) / 255.0,
},
libremetaverse::materials::LegacyMaterialAlphaMode::Default
| libremetaverse::materials::LegacyMaterialAlphaMode::None => automatic_alpha(),
}
}
}),
alpha_cutoff: legacy.map_or_else(
|| texture_has_alpha.then_some(0.5),
|material| {
if material.diffuse_alpha_mode()
== libremetaverse::materials::LegacyMaterialAlphaMode::Mask
{
Some(f32::from(material.alpha_mask_cutoff()) / 255.0)
} else {
texture_has_alpha.then_some(0.5)
}
libremetaverse::materials::LegacyMaterialAlphaMode::None => AlphaMode::Opaque,
},
),
..Default::default()
@@ -2185,7 +2299,7 @@ pub(crate) fn scene_renderable_from_triangles(
}
#[cfg(feature = "live-grid")]
struct DecodedTexture {
pub(crate) struct DecodedTexture {
width: usize,
height: usize,
red: Vec<u8>,
@@ -2268,7 +2382,7 @@ fn cached_textures(
max_bytes: usize,
max_cached_pixels: usize,
) -> (std::collections::BTreeMap<UUID, Arc<DecodedTexture>>, usize) {
const MAX_PIXELS_PER_CAPTURE: usize = 16_777_216;
const MAX_PIXELS_PER_CAPTURE: usize = 67_108_864;
let (decoded, _) = decode_textures(
encoded,
max_bytes,
@@ -2389,11 +2503,17 @@ fn decode_textures(
break;
}
let options = libremetaverse_imaging::J2kDecodeOptions::default()
.with_discard_levels(1)
.with_limits(max_bytes.min(bytes.len().max(1)), remaining_pixels);
let Ok(image) = libremetaverse_imaging::RustJ2kCodec::decode_bytes(&bytes, options) else {
.with_limits(max_bytes.min(bytes.len().max(1)), 33_554_432);
let Ok(mut image) = libremetaverse_imaging::RustJ2kCodec::decode_bytes(&bytes, options)
else {
continue;
};
// A 512px source still exceeds the screen footprint of almost every
// face in an agent snapshot, while letting dense UGC scenes converge
// without retaining gigabytes of decoded 1024px textures.
if fit_texture_for_view(&mut image, 512).is_err() {
continue;
}
let Ok(width) = usize::try_from(image.width) else {
continue;
};
@@ -2422,6 +2542,44 @@ fn decode_textures(
(output, max_pixels - remaining_pixels)
}
#[cfg(feature = "live-grid")]
pub(crate) fn fit_texture_for_view(
image: &mut libremetaverse_imaging::ManagedImage,
maximum_edge: i32,
) -> Result<(), libremetaverse_types::Error> {
let largest = image.width.max(image.height);
if largest <= maximum_edge {
return Ok(());
}
let width = (i64::from(image.width) * i64::from(maximum_edge) / i64::from(largest))
.max(1)
.try_into()
.map_err(|_| libremetaverse_types::Error::Argument)?;
let height = (i64::from(image.height) * i64::from(maximum_edge) / i64::from(largest))
.max(1)
.try_into()
.map_err(|_| libremetaverse_types::Error::Argument)?;
if !image.alpha.is_empty() {
for color in [&mut image.red, &mut image.green, &mut image.blue] {
for (sample, alpha) in color.iter_mut().zip(&image.alpha) {
*sample = u8::try_from(u16::from(*sample) * u16::from(*alpha) / 255)
.expect("premultiplied color fits in a byte");
}
}
}
image.resize_bilinear(width, height)?;
if !image.alpha.is_empty() {
for color in [&mut image.red, &mut image.green, &mut image.blue] {
for (sample, alpha) in color.iter_mut().zip(&image.alpha) {
if *alpha != 0 {
*sample = (u16::from(*sample) * 255 / u16::from(*alpha)).min(255) as u8;
}
}
}
}
Ok(())
}
#[cfg(feature = "live-grid")]
fn multiply_color(tint: [u8; 4], texture: [u8; 4]) -> [u8; 4] {
std::array::from_fn(|channel| {
@@ -2441,50 +2599,67 @@ pub(crate) fn terrain_height(
}
#[cfg(feature = "live-grid")]
fn terrain_triangles(
#[allow(clippy::too_many_arguments)]
pub(crate) fn terrain_triangles(
terrain: &[libremetaverse::TerrainPatch],
region_size: (f32, f32),
water: f32,
textures: &std::collections::BTreeMap<UUID, Arc<DecodedTexture>>,
texture_ids: [UUID; 4],
materials: TerrainMaterials,
camera_position: [f32; 3],
maximum_distance: f32,
maximum: usize,
) -> Vec<SceneTriangle> {
let (width, height, patch_width) = terrain_layout(terrain, region_size);
if maximum < 2 || width < 2 || height < 2 {
return Vec::new();
}
let heights = terrain
.iter()
.flat_map(|patch| patch.data.iter().copied())
.filter(|value| value.is_finite())
.collect::<Vec<_>>();
let Some((&minimum, &maximum_height)) = heights
.iter()
.min_by(|a, b| a.total_cmp(b))
.zip(heights.iter().max_by(|a, b| a.total_cmp(b)))
else {
return Vec::new();
};
let mut step = 4usize;
while width.div_ceil(step) * height.div_ceil(step) * 2 > maximum {
let radius = maximum_distance.ceil();
let minimum_x = (camera_position[0] - radius).floor().max(0.0) as usize;
let minimum_y = (camera_position[1] - radius).floor().max(0.0) as usize;
let maximum_x = (camera_position[0] + radius).ceil().max(0.0) as usize;
let maximum_y = (camera_position[1] + radius).ceil().max(0.0) as usize;
let minimum_x = minimum_x.min(width - 1);
let minimum_y = minimum_y.min(height - 1);
let maximum_x = maximum_x.min(width - 1);
let maximum_y = maximum_y.min(height - 1);
let mut step = 1usize;
while (maximum_x - minimum_x).div_ceil(step) * (maximum_y - minimum_y).div_ceil(step) * 2
> maximum
{
step *= 2;
}
let color = |x: usize, y: usize, z: f32| {
let range = (maximum_height - minimum).max(1.0);
let level = ((z - minimum) / range).clamp(0.0, 0.999);
let texture = textures.get(&texture_ids[(level * 4.0) as usize]);
if let Some(texture) = texture {
texture.sample(x as f32 / 128.0, y as f32 / 128.0)
} else if z <= water {
[45, 90, 125, 255]
} else {
let light = unit_byte(0.65 + level * 0.3);
[light / 2, light, light / 3, 255]
}
let east = x as f32 / region_size.0.max(1.0);
let north = y as f32 / region_size.1.max(1.0);
let start = bilinear_corners(materials.start_heights, east, north);
let range = bilinear_corners(materials.height_ranges, east, north).max(1.0);
let layer = ((z - start) / range * 3.0).clamp(0.0, 3.0);
let lower = layer.floor() as usize;
let upper = layer.ceil() as usize;
let blend = layer.fract() * layer.fract() * (3.0 - 2.0 * layer.fract());
let sample = |index: usize| {
textures.get(&materials.texture_ids[index]).map_or_else(
|| {
if z <= water {
[45, 90, 125, 255]
} else {
[
[80, 105, 55, 255],
[105, 100, 65, 255],
[90, 95, 80, 255],
[125, 125, 115, 255],
][index]
}
},
|texture| texture.sample(x as f32 / 12.5, y as f32 / 12.5),
)
};
blend_color(sample(lower), sample(upper), blend)
};
let mut output = Vec::new();
for y in (0..height.saturating_sub(1)).step_by(step) {
for x in (0..width.saturating_sub(1)).step_by(step) {
for y in (minimum_y..maximum_y).step_by(step) {
for x in (minimum_x..maximum_x).step_by(step) {
if output.len().saturating_add(2) > maximum {
return output;
}
@@ -2523,6 +2698,23 @@ fn terrain_triangles(
output
}
#[cfg(feature = "live-grid")]
pub(crate) fn bilinear_corners(values: [f32; 4], east: f32, north: f32) -> f32 {
let east = east.clamp(0.0, 1.0);
let north = north.clamp(0.0, 1.0);
let south = values[0] * (1.0 - east) + values[2] * east;
let north_edge = values[1] * (1.0 - east) + values[3] * east;
south * (1.0 - north) + north_edge * north
}
#[cfg(feature = "live-grid")]
pub(crate) fn blend_color(lower: [u8; 4], upper: [u8; 4], amount: f32) -> [u8; 4] {
std::array::from_fn(|channel| {
(f32::from(lower[channel]) * (1.0 - amount) + f32::from(upper[channel]) * amount).round()
as u8
})
}
#[cfg(feature = "live-grid")]
pub(crate) fn triangle_shade(vertices: [[f32; 3]; 3]) -> f32 {
let edge_a = std::array::from_fn(|axis| vertices[1][axis] - vertices[0][axis]);

196
crates/metacrate-grid-agent/src/vision_tests.rs
View File

@@ -59,6 +59,102 @@ fn extended_terrain_layout_uses_received_patch_coordinates() {
assert_eq!(terrain_height(&terrain, 256, 675, 538), Some(20.0));
}
#[cfg(feature = "live-grid")]
#[test]
fn terrain_uses_corner_bands_and_only_builds_the_camera_neighborhood() {
assert!((bilinear_corners([0.0, 10.0, 20.0, 30.0], 0.5, 0.5) - 15.0).abs() < f32::EPSILON);
assert_eq!(
blend_color([0, 20, 40, 255], [100, 120, 140, 255], 0.5),
[50, 70, 90, 255]
);
let terrain = (0..16)
.flat_map(|y| {
(0..16).map(move |x| libremetaverse::TerrainPatch {
data: vec![20.0; 256],
x,
y,
})
})
.collect::<Vec<_>>();
let triangles = terrain_triangles(
&terrain,
(256.0, 256.0),
19.0,
&std::collections::BTreeMap::new(),
TerrainMaterials {
texture_ids: [UUID::zero(); 4],
start_heights: [0.0; 4],
height_ranges: [30.0; 4],
},
[128.0, 128.0, 22.0],
8.0,
10_000,
);
assert_eq!(triangles.len(), 512);
assert!(
triangles.iter().all(|triangle| triangle
.vertices
.iter()
.all(|vertex| (120.0..=136.0).contains(&vertex[0])
&& (120.0..=136.0).contains(&vertex[1])))
);
}
#[cfg(feature = "live-grid")]
#[test]
fn scene_meshes_use_visual_lods_at_the_default_view_distance() {
let mut prim = libremetaverse::Primitive::new_with_constructor().unwrap();
prim.position = libremetaverse_types::Vector3 {
x: 31.0,
y: 0.0,
z: 0.0,
};
assert_eq!(
scene_detail_level(&prim, [0.0; 3]),
libremetaverse::rendering::DetailLevel::Highest
);
prim.position.x = 64.0;
assert_eq!(
scene_detail_level(&prim, [0.0; 3]),
libremetaverse::rendering::DetailLevel::High
);
}
#[cfg(feature = "live-grid")]
#[test]
fn oversized_scene_textures_are_mip_sized_without_distortion() {
let mut image = libremetaverse_imaging::ManagedImage::new(
4,
2,
libremetaverse_imaging::ManagedImageImageChannels::COLOR,
)
.unwrap();
fit_texture_for_view(&mut image, 2).unwrap();
assert_eq!((image.width, image.height), (2, 1));
assert_eq!(image.red.len(), 2);
let mut cutout = libremetaverse_imaging::ManagedImage::new(
4,
2,
libremetaverse_imaging::ManagedImageImageChannels::COLOR
| libremetaverse_imaging::ManagedImageImageChannels::ALPHA,
)
.unwrap();
cutout
.red
.copy_from_slice(&[255, 255, 0, 0, 255, 255, 0, 0]);
cutout
.green
.copy_from_slice(&[220, 220, 0, 0, 220, 220, 0, 0]);
cutout
.alpha
.copy_from_slice(&[255, 255, 0, 0, 255, 255, 0, 0]);
fit_texture_for_view(&mut cutout, 3).unwrap();
assert_eq!((cutout.width, cutout.height), (3, 1));
assert_eq!((cutout.red[1], cutout.green[1]), (255, 219));
assert_eq!(cutout.alpha[1], 128);
}
#[cfg(feature = "live-grid")]
#[test]
fn renderer_uses_the_camera_axis_that_points_at_the_requested_target() {
@@ -84,6 +180,104 @@ fn scene_faces_are_shaded_without_changing_alpha() {
assert_eq!(color[3], 77);
}
#[cfg(feature = "live-grid")]
#[test]
fn legacy_faces_preserve_face_alpha_without_inventing_specular_light() {
let mut face = libremetaverse::PrimitiveTextureEntryFace::default();
face.set_rgba(libremetaverse_types::Color4 {
r: 0.25,
g: 0.5,
b: 0.75,
a: 0.0,
});
let material = face_material(
&face,
&std::collections::BTreeMap::new(),
&std::collections::BTreeMap::new(),
&std::collections::BTreeMap::new(),
true,
);
let metacrate_rendering_wgpu::Material::BlinnPhong(material) = material else {
panic!("legacy face did not produce a Blinn-Phong material");
};
assert_eq!(material.diffuse_color_srgb, [64, 128, 191, 0]);
assert_eq!(material.specular_color_srgb, [0; 3]);
assert_eq!(
material.alpha_mode,
metacrate_rendering_wgpu::AlphaMode::Blend
);
assert_eq!(material.alpha_cutoff, Some(0.5));
}
#[cfg(feature = "live-grid")]
#[test]
fn face_alpha_overrides_an_opaque_material_mode() {
let mut face = libremetaverse::PrimitiveTextureEntryFace::default();
face.set_rgba(libremetaverse_types::Color4 {
r: 1.0,
g: 1.0,
b: 1.0,
a: 0.0,
});
let mut legacy = libremetaverse::materials::LegacyMaterial::new_with_constructor().unwrap();
legacy.set_id(face.material_id());
legacy.set_diffuse_alpha_mode(libremetaverse::materials::LegacyMaterialAlphaMode::None);
let legacy = [(legacy.id(), legacy)].into_iter().collect();
let material = face_material(
&face,
&std::collections::BTreeMap::new(),
&legacy,
&std::collections::BTreeMap::new(),
false,
);
assert_eq!(
material.alpha_mode(),
metacrate_rendering_wgpu::AlphaMode::Blend
);
face.set_rgba(libremetaverse_types::Color4::white());
let material = face_material(
&face,
&std::collections::BTreeMap::new(),
&legacy,
&std::collections::BTreeMap::new(),
true,
);
assert_eq!(
material.alpha_mode(),
metacrate_rendering_wgpu::AlphaMode::Mask { cutoff: 0.5 }
);
let metacrate_rendering_wgpu::Material::BlinnPhong(material) = material else {
panic!("legacy face did not produce a Blinn-Phong material");
};
assert_eq!(material.alpha_cutoff, Some(0.5));
face.set_rgba(libremetaverse_types::Color4 {
a: 0.5,
..libremetaverse_types::Color4::white()
});
let mut mask = libremetaverse::materials::LegacyMaterial::new_with_constructor().unwrap();
mask.set_id(face.material_id());
mask.set_diffuse_alpha_mode(libremetaverse::materials::LegacyMaterialAlphaMode::Mask);
mask.set_alpha_mask_cutoff(128);
let masks = [(mask.id(), mask)].into_iter().collect();
let material = face_material(
&face,
&std::collections::BTreeMap::new(),
&masks,
&std::collections::BTreeMap::new(),
true,
);
let metacrate_rendering_wgpu::Material::BlinnPhong(material) = material else {
panic!("legacy face did not produce a Blinn-Phong material");
};
assert_eq!(
material.alpha_mode,
metacrate_rendering_wgpu::AlphaMode::Blend
);
assert_eq!(material.alpha_cutoff, Some(128.0 / 255.0));
}
#[cfg(feature = "live-grid")]
#[test]
fn scene_visibility_uses_configured_distance_and_avatar_view() {
@@ -221,7 +415,7 @@ async fn golden_scene_is_deterministic_depth_ordered_and_privacy_marked() {
assert_eq!(first.image_sha256, second.image_sha256);
assert_eq!(
first.image_sha256,
"b53d23f57ba0d6fb79856afde111ad6dc25559e810dcc028a5f107090914821d"
"63a9e3502b7ca43ac8b3560f516fcf1fbed96f74f86e9818d7d88db2cc39555b"
);
assert!(first.summary.contains("privacy-marked residents"));
assert!(!first.summary.contains("Private Resident"));

3
crates/metacrate-grid-agent/tests/dependency_policy.rs
View File

@@ -2,10 +2,11 @@ use std::collections::BTreeSet;
use std::fs;
use std::path::{Path, PathBuf};
const ALLOWED_DEPENDENCIES: [&str; 20] = [
const ALLOWED_DEPENDENCIES: [&str; 21] = [
"async-trait",
"base64",
"crossterm",
"directories",
"libremetaverse",
"libremetaverse-imaging",
"libremetaverse-rendering-simple",

11
crates/metacrate-grid-agent/tests/live_llm_vision.rs
View File

@@ -45,7 +45,7 @@ async fn luna_describes_live_renderer_evidence() -> Result<(), Box<dyn Error>> {
let response = agent
.send(vec![
ContentBlock::text(
"Describe this rendered virtual-world scene. State whether it contains recognizable textured terrain and mesh scenery, and identify any obvious rendering corruption.",
"Describe this rendered virtual-world scene. State whether it contains recognizable detailed textured terrain and mesh scenery, and identify any obvious rendering corruption. End with `QUALITY: PASS` only if the scene is clearly recognizable and has no substantial rendering corruption; otherwise end with `QUALITY: FAIL`.",
),
ContentBlock::image_url(image),
])
@@ -61,10 +61,17 @@ async fn luna_describes_live_renderer_evidence() -> Result<(), Box<dyn Error>> {
if descriptions.is_empty() {
return Err("Luna returned no snapshot description".into());
}
let passed = descriptions
.iter()
.any(|description| description.contains("QUALITY: PASS"));
for description in descriptions {
println!("LIVE_LLM_VISION={description}");
}
Ok(())
if passed {
Ok(())
} else {
Err("Luna rejected the rendered scene quality".into())
}
}
fn live_environment() -> Result<BTreeMap<String, String>, Box<dyn Error>> {

486
crates/metacrate-grid-agent/tests/live_renderer.rs
View File

@@ -1,9 +1,13 @@
#![cfg(feature = "live-grid")]
use libremetaverse_types::{Vector3, compat::CancellationTokenSource};
use libremetaverse_types::{
Vector3,
compat::{CancellationToken, CancellationTokenSource},
};
use metacrate_grid_agent::{
EndpointUrl, GridConnection, GridSession, GridSessionBackend, LibremetaverseClientOwner,
LibremetaverseSceneSource, SecretString, SessionSignal, VisionLimits, VisionService,
LibremetaverseSceneSource, SceneEntityKind, SceneSnapshot, SceneSource, SecretString,
SessionSignal, VisionFuture, VisionLimits, VisionService,
};
use std::{
collections::BTreeMap,
@@ -14,196 +18,144 @@ use std::{
};
#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
#[ignore = "logs two dedicated accounts into the configured live grid and writes a JPEG"]
#[allow(clippy::too_many_lines)] // The one end-to-end live workflow stays readable in execution order.
async fn live_bevy_capture_renders_the_target_accounts_scene() -> Result<(), Box<dyn Error>> {
#[ignore = "logs the primary agent into the configured live varregion"]
async fn live_primary_login_resolves_varregion_dimensions() -> Result<(), Box<dyn Error>> {
let environment = live_environment()?;
let target_owner = LibremetaverseClientOwner::new()?;
let renderer_owner = LibremetaverseClientOwner::new()?;
let (mut target_session, target_cancel) = login(
&target_owner,
&environment,
"GRID_TEST_UNPRIVILEGED_USER",
"GRID_TEST_UNPRIVILEGED_PASSWORD",
)
.await?;
let (mut renderer_session, renderer_cancel) = match login(
&renderer_owner,
&environment,
"GRID_TEST_AUTHORIZED_USER",
"GRID_TEST_AUTHORIZED_PASSWORD",
)
.await
{
Ok(login) => login,
Err(error) => {
let _ = target_session.logout(target_cancel.token()).await;
return Err(error);
let owner = LibremetaverseClientOwner::new()?;
let (mut session, cancellation) =
login(&owner, &environment, "GRID_USER", "GRID_PASSWORD").await?;
let result = async {
wait_ready("primary", &mut session, &cancellation).await?;
let simulator = owner
.client()
.network()
.current_sim()
.ok_or("primary simulator unavailable")?;
let size = simulator.region_size();
println!(
"LIVE_PRIMARY_REGION=region:{:?},handle:{},size:{}x{},position:{:?}",
simulator.name,
simulator.handle,
size.0,
size.1,
owner.agent().sim_position()
);
if size != (1024, 1024) {
return Err(format!("expected 1024x1024 varregion, got {}x{}", size.0, size.1).into());
}
};
Ok(())
}
.await;
let _ = session.logout(cancellation.token()).await;
result
}
#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
#[ignore = "records the primary region's asynchronous map-name reply"]
async fn live_primary_map_name_reports_varregion_dimensions() -> Result<(), Box<dyn Error>> {
let environment = live_environment()?;
let owner = LibremetaverseClientOwner::new()?;
let (mut session, cancellation) =
login(&owner, &environment, "GRID_USER", "GRID_PASSWORD").await?;
let result = async {
wait_ready("primary", &mut session, &cancellation).await?;
let simulator = owner
.client()
.network()
.current_sim()
.ok_or("primary simulator unavailable")?;
let name = simulator.name.clone();
let handle = simulator.handle;
let (sender, mut receiver) = tokio::sync::mpsc::unbounded_channel();
let _subscription = owner
.client()
.grid()
.subscribe_grid_region(Arc::new(move |event| {
let _ = sender.send(event.region());
}));
let started = Instant::now();
owner
.client()
.grid()
.request_map_region(name.clone(), libremetaverse::GridLayerType::Objects)?;
let deadline = started + Duration::from_secs(15);
while Instant::now() < deadline {
let remaining = deadline.saturating_duration_since(Instant::now());
let Ok(Some(region)) = tokio::time::timeout(remaining, receiver.recv()).await else {
break;
};
println!(
"LIVE_MAP_NAME_EVENT=elapsed_ms:{},name:{:?},handle:{},size:{}x{}",
started.elapsed().as_millis(),
region.name,
region.region_handle,
region.size_x,
region.size_y
);
if region.region_handle == handle && (region.size_x, region.size_y) == (1024, 1024) {
return Ok::<(), Box<dyn Error>>(());
}
}
Err(format!("no explicit 1024x1024 map-name reply for {name:?}").into())
}
.await;
let _ = session.logout(cancellation.token()).await;
result
}
#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
#[ignore = "logs the primary agent into the configured live grid and writes a JPEG"]
#[allow(clippy::too_many_lines)] // The one end-to-end live workflow stays readable in execution order.
async fn live_bevy_capture_renders_in_front_of_avatar() -> Result<(), Box<dyn Error>> {
let environment = live_environment()?;
let renderer_owner = LibremetaverseClientOwner::new()?;
let (mut renderer_session, renderer_cancel) =
login(&renderer_owner, &environment, "GRID_USER", "GRID_PASSWORD").await?;
let result = async {
wait_ready("target", &mut target_session, &target_cancel).await?;
wait_ready("renderer", &mut renderer_session, &renderer_cancel).await?;
let renderer_start_simulator = renderer_owner
.client()
.network()
.current_sim()
.ok_or("renderer start simulator unavailable")?;
let renderer_start_handle = renderer_start_simulator.handle;
let renderer_start_position = conventional_start(&renderer_start_simulator);
let target_simulator = target_owner
.client()
.network()
.current_sim()
.ok_or("target simulator unavailable")?;
let target_position = target_owner.agent().sim_position();
let arrival = Vector3 {
x: target_position.x - 10.0,
y: target_position.y - 10.0,
z: target_position.z + 2.0,
};
if !renderer_owner
.agent()
.teleport_with_u_int64_vector3_vector3_cancellation_token(
target_simulator.handle,
arrival,
target_position,
Some(renderer_cancel.token()),
)
.await?
{
return Err("teleport did not complete".into());
}
tokio::time::sleep(Duration::from_secs(5)).await;
if !renderer_owner
.agent()
.teleport_with_u_int64_vector3_vector3_cancellation_token(
renderer_start_handle,
renderer_start_position,
Vector3 {
x: renderer_start_position.x + 10.0,
y: renderer_start_position.y,
z: renderer_start_position.z,
},
Some(renderer_cancel.token()),
)
.await?
{
return Err("return teleport did not complete".into());
}
tokio::time::sleep(Duration::from_secs(5)).await;
let mut renderer_simulator = renderer_owner
let renderer_simulator = renderer_owner
.client()
.network()
.current_sim()
.ok_or("renderer simulator unavailable")?;
let mut settled_position = renderer_owner.agent().sim_position();
if let Some(ground) = terrain_ground(
&renderer_simulator,
renderer_start_position.x,
renderer_start_position.y,
) {
let destination = Vector3 {
x: renderer_start_position.x,
y: renderer_start_position.y,
z: ground + 2.0,
};
if (settled_position.z - destination.z).abs() > 1.0 {
if !renderer_owner
.agent()
.teleport_with_u_int64_vector3_vector3_cancellation_token(
renderer_start_handle,
destination,
Vector3 {
x: destination.x + 10.0,
..destination
},
Some(renderer_cancel.token()),
)
.await?
{
return Err("ground-settle teleport did not complete".into());
}
tokio::time::sleep(Duration::from_secs(5)).await;
renderer_simulator = renderer_owner
.client()
.network()
.current_sim()
.ok_or("settled renderer simulator unavailable")?;
settled_position = renderer_owner.agent().sim_position();
}
}
let settled_position = renderer_owner.agent().sim_position();
let region_size = renderer_simulator.region_size();
println!(
"LIVE_RENDER_LOCATION=region:{:?},size:{}x{},position:{settled_position:?}",
renderer_simulator.name, region_size.0, region_size.1
);
wait_scene_settled(&renderer_owner).await?;
let mut view_forward = Vector3::unit_x();
if let Some((destination, forward)) = scenic_location(&renderer_simulator) {
if !renderer_owner
.agent()
.teleport_with_u_int64_vector3_vector3_cancellation_token(
renderer_start_handle,
destination,
Vector3 {
x: destination.x + forward.x,
y: destination.y + forward.y,
z: destination.z + forward.z,
},
Some(renderer_cancel.token()),
)
.await?
{
return Err("scenic teleport did not complete".into());
}
wait_scene_settled(&renderer_owner).await?;
renderer_simulator = renderer_owner
.client()
.network()
.current_sim()
.ok_or("scenic renderer simulator unavailable")?;
settled_position = renderer_owner.agent().sim_position();
view_forward = forward;
}
{
let prims = renderer_simulator
.objects_primitives
.read()
.unwrap_or_else(std::sync::PoisonError::into_inner);
let largest_scale = prims.values().fold(0.0_f32, |largest, prim| {
largest.max(prim.scale.x.max(prim.scale.y).max(prim.scale.z))
});
println!(
"LIVE_SCENE_CACHE=prims:{} roots:{} children:{} attachments:{} sculpted:{} largest_scale:{largest_scale:.2}",
prims.len(),
prims.values().filter(|prim| prim.parent_id == 0).count(),
prims.values().filter(|prim| prim.parent_id != 0).count(),
prims.values().filter(|prim| prim.is_attachment).count(),
prims.values().filter(|prim| prim.sculpt.is_some()).count(),
);
println!(
"LIVE_SCENE_GEOMETRY=mesh:{} sculpt:{} legacy:{}",
prims
.values()
.filter(|prim| prim.sculpt.as_ref().is_some_and(|sculpt| sculpt.type_() == libremetaverse_types::SculptType::Mesh))
.count(),
prims
.values()
.filter(|prim| prim.sculpt.as_ref().is_some_and(|sculpt| sculpt.type_() != libremetaverse_types::SculptType::Mesh))
.count(),
prims.values().filter(|prim| prim.sculpt.is_none()).count(),
);
}
let (camera_position, camera_target) = avatar_camera(settled_position, view_forward)?;
let view_forward = Vector3::mul_with_vector3_quaternion(
Vector3::unit_x(),
renderer_owner.agent().sim_rotation(),
);
let (camera_position, camera_target) =
avatar_forward_camera(settled_position, view_forward)?;
renderer_owner
.agent()
.movement
.camera
.look_at_with_vector3_vector3(camera_position, camera_target)?;
renderer_owner
.agent()
.movement
.camera
.set_vertical_fov_angle(65_f32.to_radians())?;
let limits = VisionLimits {
minimum_interval: Duration::ZERO,
..VisionLimits::default()
};
println!(
"LIVE_RENDER_SCOPE=max_distance_meters:{}",
limits.max_distance_meters
);
let vision = VisionService::new(
Arc::new(LibremetaverseSceneSource::new(&renderer_owner, limits)),
Arc::new(DiagnosticSceneSource {
inner: LibremetaverseSceneSource::new(&renderer_owner, limits),
material_override: std::env::var("METACRATE_LIVE_RENDER_MATERIAL_OVERRIDE").ok(),
}),
limits,
)?
.prefer_gpu();
@@ -216,8 +168,10 @@ async fn live_bevy_capture_renders_the_target_accounts_scene() -> Result<(), Box
let frames = std::env::var("METACRATE_LIVE_RENDER_FRAMES")
.ok()
.and_then(|value| value.parse::<u32>().ok())
.unwrap_or(8)
.clamp(1, 16);
.unwrap_or(12)
.clamp(1, 24);
let mut previous_missing = u32::MAX;
let mut stable_missing = 0_u32;
for frame in 1..=frames {
let next = vision
.capture(
@@ -228,7 +182,16 @@ async fn live_bevy_capture_renders_the_target_accounts_scene() -> Result<(), Box
.await?;
println!("LIVE_RENDER_FRAME_{frame}_SUMMARY={}", next.summary);
std::fs::write(&output, &next.jpeg)?;
if next.completeness.textures_missing == previous_missing {
stable_missing += 1;
} else {
previous_missing = next.completeness.textures_missing;
stable_missing = 0;
}
capture = Some(next);
if previous_missing == 0 || (frame >= 8 && stable_missing >= 3) {
break;
}
}
let capture = capture.ok_or("live renderer produced no frame")?;
println!("LIVE_RENDER_OUTPUT={}", output.display());
@@ -238,10 +201,63 @@ async fn live_bevy_capture_renders_the_target_accounts_scene() -> Result<(), Box
.await;
let _ = renderer_session.logout(renderer_cancel.token()).await;
let _ = target_session.logout(target_cancel.token()).await;
result
}
struct DiagnosticSceneSource {
inner: LibremetaverseSceneSource,
material_override: Option<String>,
}
impl SceneSource for DiagnosticSceneSource {
fn capture_scene(
&self,
generation: u64,
cancellation: CancellationToken,
) -> VisionFuture<'_, SceneSnapshot> {
Box::pin(async move {
let mut scene = self.inner.capture_scene(generation, cancellation).await?;
if let Some(material_override) = &self.material_override {
for renderable in scene
.entities
.iter_mut()
.filter(|entity| entity.kind == SceneEntityKind::Object)
.flat_map(|entity| &mut entity.renderables)
{
match &mut renderable.material {
metacrate_rendering_wgpu::Material::BlinnPhong(material) => {
if material_override == "solid" {
*material = metacrate_rendering_wgpu::BlinnPhongMaterial {
diffuse_color_srgb: [255, 0, 255, 255],
fullbright: true,
double_sided: true,
..Default::default()
};
} else if material_override == "unlit-white" {
material.diffuse_color_srgb = [255; 4];
material.fullbright = true;
}
}
metacrate_rendering_wgpu::Material::Pbr(material) => {
if material_override == "solid" {
*material = metacrate_rendering_wgpu::PbrMaterial {
base_color_srgb: [0, 255, 255, 255],
emissive_factor_srgb: [0, 255, 255],
metallic_factor: 0.0,
roughness_factor: 1.0,
double_sided: true,
..Default::default()
};
}
}
}
}
}
Ok(scene)
})
}
}
async fn login(
owner: &LibremetaverseClientOwner,
environment: &BTreeMap<String, String>,
@@ -336,108 +352,56 @@ fn required(
.ok_or_else(|| format!("missing live test setting {key}").into())
}
#[allow(clippy::cast_precision_loss)] // Simulator dimensions are small region coordinates.
fn conventional_start(simulator: &libremetaverse::Simulator) -> Vector3 {
let x = 128.0_f32.min(simulator.size_x as f32 - 2.0);
let y = 128.0_f32.min(simulator.size_y as f32 - 2.0);
Vector3 { x, y, z: 50.0 }
}
#[allow(
clippy::cast_possible_truncation,
clippy::cast_possible_wrap,
clippy::cast_sign_loss
)] // Coordinates are already clamped inside the non-negative simulator extent.
fn terrain_ground(simulator: &libremetaverse::Simulator, x: f32, y: f32) -> Option<f32> {
let patches = simulator
.terrain
.read()
.unwrap_or_else(std::sync::PoisonError::into_inner);
let patch_x = (x as usize / 16) as i32;
let patch_y = (y as usize / 16) as i32;
let local_x = x as usize % 16;
let local_y = y as usize % 16;
patches
.iter()
.find(|patch| patch.x == patch_x && patch.y == patch_y)
.and_then(|patch| patch.data.get(local_y * 16 + local_x))
.copied()
}
#[allow(clippy::cast_precision_loss)] // Terrain patch indexes are small region coordinates.
fn scenic_location(simulator: &libremetaverse::Simulator) -> Option<(Vector3, Vector3)> {
let roots = simulator
.objects_primitives
.read()
.unwrap_or_else(std::sync::PoisonError::into_inner)
.values()
.filter(|prim| prim.parent_id == 0)
.cloned()
.collect::<Vec<_>>();
let patches = simulator
.terrain
.read()
.unwrap_or_else(std::sync::PoisonError::into_inner);
patches
.iter()
.filter(|patch| patch.data.len() == 256)
.filter_map(|patch| {
let position = Vector3 {
x: patch.x as f32 * 16.0 + 8.0,
y: patch.y as f32 * 16.0 + 8.0,
z: patch.data[8 * 16 + 8] + 2.0,
};
if roots.iter().any(|prim| {
let extent = prim.scale.x.max(prim.scale.y).max(prim.scale.z);
let dx = prim.position.x - position.x;
let dy = prim.position.y - position.y;
let dz = prim.position.z - position.z;
(dx * dx + dy * dy + dz * dz).sqrt() < extent * 0.5 + 3.0
}) {
return None;
}
let mut score = 0.0_f32;
let mut forward = Vector3::zero();
for prim in &roots {
let dx = prim.position.x - position.x;
let dy = prim.position.y - position.y;
let horizontal = (dx * dx + dy * dy).sqrt();
let dz = prim.position.z - position.z;
let extent = prim.scale.x.max(prim.scale.y).max(prim.scale.z);
if !(10.0..=64.0).contains(&horizontal)
|| dz.abs() > 20.0
|| !(2.0..=32.0).contains(&extent)
{
continue;
}
let weight = extent.min(10.0) / horizontal;
score += extent.min(10.0);
forward.x += dx * weight;
forward.y += dy * weight;
forward.z += dz.clamp(-horizontal * 0.35, horizontal * 0.35) * weight;
}
(score > 0.0).then_some((score, position, forward))
})
.max_by(|left, right| left.0.total_cmp(&right.0))
.map(|(_, position, forward)| (position, forward))
}
fn avatar_camera(avatar: Vector3, forward: Vector3) -> Result<(Vector3, Vector3), Box<dyn Error>> {
fn avatar_forward_camera(
avatar: Vector3,
forward: Vector3,
) -> Result<(Vector3, Vector3), Box<dyn Error>> {
let length = (forward.x * forward.x + forward.y * forward.y + forward.z * forward.z).sqrt();
if !length.is_finite() || length < f32::EPSILON {
return Err("renderer start direction unavailable".into());
return Err("avatar facing direction unavailable".into());
}
let position = Vector3 {
x: avatar.x,
y: avatar.y,
z: avatar.z + 2.0,
z: avatar.z + 1.6,
};
Ok((
position,
Vector3 {
x: position.x + forward.x / length * 30.0,
y: position.y + forward.y / length * 30.0,
z: position.z + forward.z / length * 30.0,
x: position.x + forward.x / length * 24.0,
y: position.y + forward.y / length * 24.0,
z: position.z + forward.z / length * 24.0,
},
))
}
#[test]
fn evidence_camera_uses_avatar_eye_position_and_facing() {
let avatar = Vector3 {
x: 10.0,
y: 20.0,
z: 30.0,
};
let (position, target) = avatar_forward_camera(avatar, Vector3::unit_y()).unwrap();
assert_eq!(
position,
Vector3 {
x: 10.0,
y: 20.0,
z: 31.6
}
);
assert_eq!(
target,
Vector3 {
x: 10.0,
y: 44.0,
z: 31.6
}
);
}