590 lines
22 KiB
Rust
590 lines
22 KiB
Rust
#![cfg(feature = "live-grid")]
|
|
|
|
use libremetaverse_types::{
|
|
Vector3,
|
|
compat::{CancellationToken, CancellationTokenSource},
|
|
};
|
|
use metacrate_grid_agent::{
|
|
EndpointUrl, GridConnection, GridSession, GridSessionBackend, LibremetaverseClientOwner,
|
|
LibremetaverseSceneSource, SceneEntityKind, SceneSnapshot, SceneSource, SecretString,
|
|
SessionSignal, VisionFuture, VisionLimits, VisionService,
|
|
};
|
|
use std::{
|
|
collections::BTreeMap,
|
|
error::Error,
|
|
path::PathBuf,
|
|
sync::Arc,
|
|
time::{Duration, Instant},
|
|
};
|
|
|
|
#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
|
|
#[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 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 = "profiles primary login, renderer initialization, and first visible-scene warmup"]
|
|
async fn live_primary_startup_profile() -> Result<(), Box<dyn Error>> {
|
|
let total_started = Instant::now();
|
|
let environment = live_environment()?;
|
|
let owner_started = Instant::now();
|
|
let owner = LibremetaverseClientOwner::new()?;
|
|
let owner_initialization = owner_started.elapsed();
|
|
let gpu_task = tokio::task::spawn_blocking(|| {
|
|
let started = Instant::now();
|
|
(
|
|
metacrate_rendering_wgpu::Renderer::new_blocking(),
|
|
started.elapsed(),
|
|
)
|
|
});
|
|
let login_started = Instant::now();
|
|
let (mut session, cancellation) =
|
|
login(&owner, &environment, "GRID_USER", "GRID_PASSWORD").await?;
|
|
let login = login_started.elapsed();
|
|
let ready_started = Instant::now();
|
|
wait_ready("primary", &mut session, &cancellation).await?;
|
|
let readiness = ready_started.elapsed();
|
|
let settle_started = Instant::now();
|
|
wait_scene_settled(&owner).await?;
|
|
let scene_settle = settle_started.elapsed();
|
|
let limits = VisionLimits {
|
|
minimum_interval: Duration::ZERO,
|
|
..VisionLimits::default()
|
|
};
|
|
let source = LibremetaverseSceneSource::new(&owner, limits);
|
|
let warmup_started = Instant::now();
|
|
let scene = source.capture_scene(0, cancellation.token()).await?;
|
|
let scene_warmup = warmup_started.elapsed();
|
|
let (renderer, gpu_initialization) = gpu_task.await?;
|
|
renderer?;
|
|
println!(
|
|
"LIVE_STARTUP_PROFILE=owner_initialization_ms:{},grid_login_ms:{},grid_readiness_ms:{},scene_settle_ms:{},gpu_initialization_parallel_ms:{},first_scene_warmup_ms:{},first_scene:{:?},total_ms:{}",
|
|
owner_initialization.as_millis(),
|
|
login.as_millis(),
|
|
readiness.as_millis(),
|
|
scene_settle.as_millis(),
|
|
gpu_initialization.as_millis(),
|
|
scene_warmup.as_millis(),
|
|
scene.timings,
|
|
total_started.elapsed().as_millis(),
|
|
);
|
|
let _ = session.logout(cancellation.token()).await;
|
|
Ok(())
|
|
}
|
|
|
|
#[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 limits = VisionLimits {
|
|
minimum_interval: Duration::ZERO,
|
|
..VisionLimits::default()
|
|
};
|
|
let scene_source = Arc::new(LibremetaverseSceneSource::new(&renderer_owner, limits));
|
|
let prefetch_started = Instant::now();
|
|
scene_source.start_prefetch();
|
|
|
|
let result = async {
|
|
wait_ready("renderer", &mut renderer_session, &renderer_cancel).await?;
|
|
let renderer_simulator = renderer_owner
|
|
.client()
|
|
.network()
|
|
.current_sim()
|
|
.ok_or("renderer simulator unavailable")?;
|
|
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 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())?;
|
|
|
|
tokio::time::timeout(Duration::from_mins(10), async {
|
|
while scene_source.prefetch_passes() == 0 {
|
|
tokio::time::sleep(Duration::from_millis(250)).await;
|
|
}
|
|
})
|
|
.await
|
|
.map_err(|_| "background scene prefetch did not complete")?;
|
|
println!(
|
|
"LIVE_RENDER_PREFETCH_MILLISECONDS={}",
|
|
prefetch_started.elapsed().as_millis()
|
|
);
|
|
scene_source.stop_prefetch().await;
|
|
|
|
println!(
|
|
"LIVE_RENDER_SCOPE=max_distance_meters:{}",
|
|
limits.max_distance_meters
|
|
);
|
|
let vision = VisionService::new(
|
|
Arc::new(DiagnosticSceneSource {
|
|
inner: Arc::clone(&scene_source),
|
|
material_override: std::env::var("METACRATE_LIVE_RENDER_MATERIAL_OVERRIDE").ok(),
|
|
}),
|
|
limits,
|
|
)?
|
|
.prefer_gpu();
|
|
let initialization_started = Instant::now();
|
|
if !vision.initialize_renderer().await {
|
|
return Err("live wgpu renderer initialization failed".into());
|
|
}
|
|
println!(
|
|
"LIVE_RENDER_INITIALIZATION_MILLISECONDS={}",
|
|
initialization_started.elapsed().as_millis()
|
|
);
|
|
vision.set_generation(1);
|
|
let mut capture = None;
|
|
let output = std::env::var_os("METACRATE_LIVE_RENDER_OUTPUT").map_or_else(
|
|
|| std::env::temp_dir().join("metacrate-live-render.jpg"),
|
|
PathBuf::from,
|
|
);
|
|
let frames = std::env::var("METACRATE_LIVE_RENDER_FRAMES")
|
|
.ok()
|
|
.and_then(|value| value.parse::<u32>().ok())
|
|
.unwrap_or(12)
|
|
.clamp(1, 24);
|
|
let mut previous_missing = u32::MAX;
|
|
let mut stable_missing = 0_u32;
|
|
for frame in 1..=frames {
|
|
let frame_started = Instant::now();
|
|
let next = vision
|
|
.capture(
|
|
&format!("live-renderer-evidence-{frame}"),
|
|
1,
|
|
renderer_cancel.token(),
|
|
)
|
|
.await?;
|
|
println!(
|
|
"LIVE_RENDER_FRAME_{frame}_MILLISECONDS={}",
|
|
frame_started.elapsed().as_millis()
|
|
);
|
|
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")?;
|
|
profile_warm_capture(&scene_source, limits, renderer_cancel.token()).await?;
|
|
println!("LIVE_RENDER_OUTPUT={}", output.display());
|
|
println!("LIVE_RENDER_SHA256={}", capture.image_sha256);
|
|
Ok::<(), Box<dyn Error>>(())
|
|
}
|
|
.await;
|
|
|
|
scene_source.stop_prefetch().await;
|
|
let _ = renderer_session.logout(renderer_cancel.token()).await;
|
|
result
|
|
}
|
|
|
|
async fn profile_warm_capture(
|
|
source: &LibremetaverseSceneSource,
|
|
limits: VisionLimits,
|
|
cancellation: CancellationToken,
|
|
) -> Result<(), Box<dyn Error>> {
|
|
let total_started = Instant::now();
|
|
let scene_started = Instant::now();
|
|
let scene = source.capture_scene(1, cancellation).await?;
|
|
let scene_total = scene_started.elapsed();
|
|
let preparation_started = Instant::now();
|
|
let mut renderables = scene
|
|
.entities
|
|
.iter()
|
|
.flat_map(|entity| {
|
|
entity
|
|
.renderables
|
|
.iter()
|
|
.cloned()
|
|
.map(move |renderable| (entity.id.to_string(), renderable))
|
|
})
|
|
.collect::<Vec<_>>();
|
|
renderables.sort_by(|left, right| left.0.cmp(&right.0));
|
|
let renderables = renderables
|
|
.into_iter()
|
|
.map(|(_, renderable)| renderable)
|
|
.collect::<Vec<_>>();
|
|
let preparation = preparation_started.elapsed();
|
|
let renderer_started = Instant::now();
|
|
let renderer = metacrate_rendering_wgpu::Renderer::new_blocking()?;
|
|
let renderer_initialization = renderer_started.elapsed();
|
|
let render_limits = metacrate_rendering_wgpu::RenderLimits {
|
|
width: limits.width,
|
|
height: limits.height,
|
|
max_triangles: limits.max_triangles,
|
|
max_texture_bytes: limits.max_texture_bytes,
|
|
max_texture_pixels: limits.max_decode_pixels,
|
|
far_distance: 512,
|
|
};
|
|
let first = renderer.render_profiled(
|
|
scene.camera,
|
|
&renderables,
|
|
&scene.textures,
|
|
[125, 149, 173, 255],
|
|
render_limits,
|
|
)?;
|
|
let warm_started = Instant::now();
|
|
let warm = renderer.render_profiled(
|
|
scene.camera,
|
|
&renderables,
|
|
&scene.textures,
|
|
[125, 149, 173, 255],
|
|
render_limits,
|
|
)?;
|
|
let warm_render_total = warm_started.elapsed();
|
|
let jpeg_started = Instant::now();
|
|
let rgb = warm
|
|
.rgba
|
|
.chunks_exact(4)
|
|
.flat_map(|pixel| pixel[..3].iter().copied())
|
|
.collect::<Vec<_>>();
|
|
let mut jpeg = Vec::new();
|
|
jpeg_encoder::Encoder::new(&mut jpeg, 92).encode(
|
|
&rgb,
|
|
u16::try_from(limits.width)?,
|
|
u16::try_from(limits.height)?,
|
|
jpeg_encoder::ColorType::Rgb,
|
|
)?;
|
|
let jpeg_encode = jpeg_started.elapsed();
|
|
println!(
|
|
"LIVE_RENDER_PROFILE=scene_total_ms:{},terrain_wait_ms:{},object_snapshot_and_asset_discovery_ms:{},material_fetch_ms:{},asset_fetch_ms:{},decode_and_geometry_ms:{},renderable_collection_and_sort_ms:{},renderer_initialization_ms:{},first_render_total_ms:{},first_render:{:?},warm_render_total_ms:{},warm_render:{:?},jpeg_encode_ms:{},profile_total_ms:{}",
|
|
scene_total.as_millis(),
|
|
scene.timings.terrain_wait.as_millis(),
|
|
scene
|
|
.timings
|
|
.object_snapshot_and_asset_discovery
|
|
.as_millis(),
|
|
scene.timings.material_fetch.as_millis(),
|
|
scene.timings.asset_fetch.as_millis(),
|
|
scene.timings.decode_and_geometry.as_millis(),
|
|
preparation.as_millis(),
|
|
renderer_initialization.as_millis(),
|
|
render_total(&first.timings).as_millis(),
|
|
first.timings,
|
|
warm_render_total.as_millis(),
|
|
warm.timings,
|
|
jpeg_encode.as_millis(),
|
|
total_started.elapsed().as_millis(),
|
|
);
|
|
Ok(())
|
|
}
|
|
|
|
fn render_total(timings: &metacrate_rendering_wgpu::RenderTimings) -> Duration {
|
|
timings.validation
|
|
+ timings.command_copy
|
|
+ timings.clear_previous_frame
|
|
+ timings.texture_cache_sync
|
|
+ timings.mesh_cache_sync
|
|
+ timings.scene_setup
|
|
+ timings.capture
|
|
}
|
|
|
|
struct DiagnosticSceneSource {
|
|
inner: Arc<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>,
|
|
user: &'static str,
|
|
password: &'static str,
|
|
) -> Result<(Box<dyn GridSession>, CancellationTokenSource), Box<dyn Error>> {
|
|
let cancellation = CancellationTokenSource::new();
|
|
let backend = owner.session_backend(GridConnection {
|
|
login_url: EndpointUrl::parse("grid.login_url", &required(environment, "GRID_LOGIN_URL")?)?,
|
|
avatar_name: required(environment, user)?,
|
|
password: SecretString::new("grid.password", required(environment, password)?)?,
|
|
})?;
|
|
let session = backend.login(1, cancellation.token()).await?;
|
|
Ok((session, cancellation))
|
|
}
|
|
|
|
async fn wait_ready(
|
|
account: &str,
|
|
session: &mut Box<dyn GridSession>,
|
|
cancellation: &CancellationTokenSource,
|
|
) -> Result<(), Box<dyn Error>> {
|
|
let signal = tokio::time::timeout(
|
|
Duration::from_secs(30),
|
|
session.next_signal(cancellation.token()),
|
|
)
|
|
.await
|
|
.map_err(|_| format!("timed out waiting for {account} session readiness"))?;
|
|
match signal {
|
|
SessionSignal::Ready => Ok(()),
|
|
signal => Err(format!("unexpected {account} session signal: {signal:?}").into()),
|
|
}
|
|
}
|
|
|
|
async fn wait_scene_settled(owner: &LibremetaverseClientOwner) -> Result<(), Box<dyn Error>> {
|
|
let deadline = Instant::now() + Duration::from_secs(30);
|
|
let minimum = Instant::now() + Duration::from_secs(10);
|
|
let mut previous = 0;
|
|
let mut stable = 0;
|
|
loop {
|
|
tokio::time::sleep(Duration::from_secs(1)).await;
|
|
let simulator = owner
|
|
.client()
|
|
.network()
|
|
.current_sim()
|
|
.ok_or("simulator unavailable while settling scene")?;
|
|
let count = simulator
|
|
.objects_primitives
|
|
.read()
|
|
.unwrap_or_else(std::sync::PoisonError::into_inner)
|
|
.len();
|
|
if count == previous && count != 0 {
|
|
stable += 1;
|
|
} else {
|
|
stable = 0;
|
|
previous = count;
|
|
}
|
|
if (Instant::now() >= minimum && stable >= 3) || Instant::now() >= deadline {
|
|
return Ok(());
|
|
}
|
|
}
|
|
}
|
|
|
|
fn live_environment() -> Result<BTreeMap<String, String>, Box<dyn Error>> {
|
|
let mut values = std::env::vars().collect::<BTreeMap<_, _>>();
|
|
let path = PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("../../.env");
|
|
for line in std::fs::read_to_string(path)?.lines() {
|
|
let line = line.trim();
|
|
if line.is_empty() || line.starts_with('#') {
|
|
continue;
|
|
}
|
|
let Some((key, value)) = line.split_once('=') else {
|
|
continue;
|
|
};
|
|
values.entry(key.trim().to_owned()).or_insert_with(|| {
|
|
value
|
|
.trim()
|
|
.trim_matches(|character| character == '\'' || character == '"')
|
|
.to_owned()
|
|
});
|
|
}
|
|
Ok(values)
|
|
}
|
|
|
|
fn required(
|
|
environment: &BTreeMap<String, String>,
|
|
key: &'static str,
|
|
) -> Result<String, Box<dyn Error>> {
|
|
environment
|
|
.get(key)
|
|
.filter(|value| !value.is_empty())
|
|
.cloned()
|
|
.ok_or_else(|| format!("missing live test setting {key}").into())
|
|
}
|
|
|
|
#[allow(
|
|
clippy::cast_possible_truncation,
|
|
clippy::cast_possible_wrap,
|
|
clippy::cast_sign_loss
|
|
)] // Coordinates are already clamped inside the non-negative simulator extent.
|
|
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("avatar facing direction unavailable".into());
|
|
}
|
|
let position = Vector3 {
|
|
x: avatar.x,
|
|
y: avatar.y,
|
|
z: avatar.z + 1.6,
|
|
};
|
|
Ok((
|
|
position,
|
|
Vector3 {
|
|
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
|
|
}
|
|
);
|
|
}
|