190 lines
14 KiB
Rust
190 lines
14 KiB
Rust
use makepad_model::*;
|
|
use makepad_render::{StaticModel,renderer::ModelInstance,asset_lights::parse_asset_lights};
|
|
|
|
fn apply(doc:&mut Document,id:&str,operations:Vec<Operation>){doc.apply(Transaction{request_id:id.into(),expected:doc.head(),operations},None).unwrap();}
|
|
fn parsed(doc:&Document,source:&str)->Vec<Operation>{parse_operations(&json::parse(source.as_bytes()).unwrap(),doc.limits()).unwrap()}
|
|
fn vehicle()->Document {
|
|
let mut d=Document::new(Limits::default()).unwrap();
|
|
let ops=parsed(&d,r#"[{"op":"cube","object":"body","size":[1.8,0.8,4]},
|
|
{"op":"object_node","object":"body","node":{"transform":{"translation":[4,1,-2]}}},
|
|
{"op":"texture_solid","material":0,"width":4,"height":4,"color":[100,40,20]},
|
|
{"op":"light","name":"headlight","attachment":{"object":"body"},"transform":{"translation":[0.6,0.1,2.01],"rotation":[0,1,0,0]},"kind":"spot","inner":0.1,"outer":0.4,"color":[1,0.9,0.7],"intensity":500,"range":30}]"#);
|
|
apply(&mut d,"body",ops);
|
|
for (i,connection) in VEHICLE_WHEEL_CONNECTIONS.iter().enumerate(){
|
|
let object=format!("tire_{i}");let x=if i%2==0{0.95}else{-0.95};let z=if i<2{1.3}else{-1.3};
|
|
// Preserve this historical source fixture's faceted cylinders even
|
|
// when the default for newly generated primitives changes.
|
|
let ops=parsed(&d,&format!(r#"[{{"op":"cylinder","object":"{object}","radius":0.35,"height":0.24,"segments":12,"smooth":false}}]"#));
|
|
apply(&mut d,&format!("wheel_geometry_{i}"),ops);
|
|
let vertices=d.object(&object).unwrap().vertices().iter().map(|v|v.id).collect();
|
|
let ops=vec![Operation::Transform{object:object.clone(),vertices,matrix:[[0.,-1.,0.,0.],[1.,0.,0.,0.],[0.,0.,1.,0.],[0.,0.,0.,1.]]},
|
|
Operation::Scene(SceneOperation::Node{object:object.clone(),node:SceneNode{parent:Some("body".into()),transform:Transform{translation:[x,-0.35,z],..Default::default()},..Default::default()}}),
|
|
Operation::Scene(SceneOperation::VehicleWheel{object,wheel:VehicleWheel{connection:(*connection).into(),pivot:[0.;3],radius:0.35,width:0.24,visual:None}})];
|
|
apply(&mut d,&format!("wheel_binding_{i}"),ops);
|
|
}
|
|
d
|
|
}
|
|
|
|
#[test]
|
|
fn textured_editable_vehicle_roundtrips_into_four_driven_wheels(){
|
|
let doc=vehicle();let source=doc.to_bytes(None).unwrap();
|
|
// Omitting visual-wheel metadata must preserve canonical source identity.
|
|
// Re-recorded when primitive generation stopped calling the platform
|
|
// libm (`primitives::turn`): the old value was the Mac's bits, and this
|
|
// same document hashed differently on Linux.
|
|
assert_eq!(doc.head().content,[210,237,161,242,12,222,100,145,162,109,242,111,24,84,212,235,232,225,143,156,132,161,139,214,2,207,19,180,9,190,120,112]);
|
|
let restored=Document::from_bytes(&source,Limits::default(),None).unwrap();
|
|
assert_eq!(restored.head(),doc.head());assert_eq!(restored.scene().wheels,doc.scene().wheels);
|
|
let product=restored.compile(None).unwrap();assert_eq!(product.glb,doc.compile(None).unwrap().glb);
|
|
let model=StaticModel::parse_glb(&product.glb).unwrap();
|
|
assert_eq!(model.driven_parts.len(),4);assert_eq!(model.indices.len(),36,"wheels must leave the rigid chassis stream");
|
|
assert_eq!(model.indices.len()+model.driven_parts.iter().map(|p|p.indices.len()).sum::<usize>(),product.triangles*3);
|
|
for (i,connection) in VEHICLE_WHEEL_CONNECTIONS.iter().enumerate(){
|
|
let wheel=model.driven_parts.iter().find(|p|&*p.connection==*connection).unwrap();
|
|
assert_eq!(wheel.indices.len(),132);assert!(!wheel.layers.is_empty());
|
|
let x=4.+if i%2==0{0.95}else{-0.95};let z=-2.+if i<2{1.3}else{-1.3};
|
|
assert!((wheel.anchor.x-x).abs()<1e-5&&(wheel.anchor.y-0.65).abs()<1e-5&&(wheel.anchor.z-z).abs()<1e-5);
|
|
assert!((wheel.radius-0.35).abs()<1e-6&&(wheel.width-0.24).abs()<1e-6);
|
|
assert!(wheel.visual.is_none());
|
|
let rest=wheel.rest_transform();assert!((rest.v[12]-wheel.anchor.x).abs()<1e-5&&(rest.v[14]-wheel.anchor.z).abs()<1e-5);
|
|
assert!((wheel.max.x-wheel.min.x-0.24).abs()<1e-5,"wheel axle geometry is X");
|
|
}
|
|
assert!(makepad_render::model::embedded_base_color_png(&product.glb).is_some());
|
|
}
|
|
|
|
#[test]
|
|
fn authored_headlight_tracks_the_car_body_and_faces_its_driving_direction(){
|
|
let product=vehicle().compile(None).unwrap();let glb=makepad_gltf::parse_glb_bytes(&product.glb).unwrap();
|
|
let model=StaticModel::parse_glb(&product.glb).unwrap();let lights=parse_asset_lights(&glb.document).unwrap();assert_eq!(lights.len(),1);
|
|
let (sin,cos)=0.7f32.sin_cos();let mut frame=model.driven_parts[0].parent;
|
|
frame.v=[cos,0.,-sin,0.,0.,1.,0.,0.,sin,0.,cos,0.,8.,2.,5.,1.];
|
|
let instance=ModelInstance::on_body("car".into(),(model.min,model.max),1.5,0.8,&frame);
|
|
let light=lights[0].placed(&instance.transform,None);
|
|
let m=instance.transform.v;let expected=[m[0]*4.6+m[4]*1.1+m[8]*0.01+m[12],m[1]*4.6+m[5]*1.1+m[9]*0.01+m[13],m[2]*4.6+m[6]*1.1+m[10]*0.01+m[14]];
|
|
assert!((light.pos.x-expected[0]).abs()<1e-5&&(light.pos.y-expected[1]).abs()<1e-5&&(light.pos.z-expected[2]).abs()<1e-5);
|
|
assert!((light.dir.x+frame.v[8]).abs()<1e-5&&(light.dir.y+frame.v[9]).abs()<1e-5&&(light.dir.z+frame.v[10]).abs()<1e-5,"headlight must aim along body -Z");
|
|
assert_eq!(light.radius,30.);assert_eq!(light.color.x,500.);
|
|
}
|
|
|
|
#[test]
|
|
fn invalid_or_incomplete_vehicle_bindings_refuse_without_mutating_source(){
|
|
let mut doc=vehicle();let original=doc.to_bytes(None).unwrap();
|
|
for source in [
|
|
r#"[{"op":"vehicle_wheel","object":"tire_0","connection":"wheel_rear_right","pivot":[0,0,0],"radius":0.35,"width":0.24}]"#,
|
|
// Any other connection name is a generic driven part (a flap, a
|
|
// gear leg); an unknown name in the `wheel_` family is a typo.
|
|
r#"[{"op":"vehicle_wheel","object":"tire_0","connection":"wheel_bogus","pivot":[0,0,0],"radius":0.35,"width":0.24}]"#,
|
|
r#"[{"op":"vehicle_wheel","object":"tire_0","connection":"wheel_front_left","pivot":[0,0,0],"radius":0,"width":0.24}]"#,
|
|
r#"[{"op":"vehicle_wheel","object":"tire_0","connection":"wheel_front_left","pivot":[0,0,0],"radius":1e-200,"width":0.24}]"#,
|
|
r#"[{"op":"object_node","object":"tire_0","node":{"parent":"body","transform":{"scale":[1,2,1]}}}]"#,
|
|
]{let operations=parsed(&doc,source);assert!(doc.apply(Transaction{request_id:"invalid".into(),expected:doc.head(),operations},None).is_err());assert_eq!(doc.to_bytes(None).unwrap(),original);}
|
|
let ops=parsed(&doc,r#"[{"op":"delete_vehicle_wheel","object":"tire_3"}]"#);apply(&mut doc,"incomplete",ops);
|
|
assert!(doc.compile(None).is_err());doc.undo(doc.head(),None).unwrap();assert!(doc.compile(None).is_ok());
|
|
let mut generic=Document::new(Limits::default()).unwrap();apply(&mut generic,"ordinary",vec![Operation::Cube{object:"ordinary".into(),size:[1.;3]}]);assert!(generic.compile(None).is_ok());
|
|
}
|
|
|
|
#[test]
|
|
fn changing_a_wheel_pivot_preserves_the_exported_anchor(){
|
|
let mut doc=vehicle();let old=StaticModel::parse_glb(&doc.compile(None).unwrap().glb).unwrap();
|
|
apply(&mut doc,"pivot",vec![Operation::Scene(SceneOperation::Pivot{object:"tire_0".into(),position:[0.1,0.2,0.3]})]);
|
|
let new=StaticModel::parse_glb(&doc.compile(None).unwrap().glb).unwrap();
|
|
let before=old.driven_parts.iter().find(|p|&*p.connection==VEHICLE_WHEEL_CONNECTIONS[0]).unwrap();
|
|
let after=new.driven_parts.iter().find(|p|&*p.connection==VEHICLE_WHEEL_CONNECTIONS[0]).unwrap();
|
|
assert!((before.anchor-after.anchor).length()<1e-5);assert!((after.pivot.x+0.1).abs()<1e-6);
|
|
}
|
|
|
|
#[test]
|
|
fn visual_wheel_limits_roundtrip_without_changing_physical_connections(){
|
|
let mut doc=vehicle();let legacy_head=doc.head();
|
|
let legacy=StaticModel::parse_glb(&doc.compile(None).unwrap().glb).unwrap();
|
|
let visual=VisualWheelMotion{steer_gain:0.55,steer_max:0.32,compression:0.08,droop:0.10};
|
|
let operations=VEHICLE_WHEEL_CONNECTIONS.iter().enumerate().map(|(i,connection)|{
|
|
let object=format!("tire_{i}");let mut wheel=doc.scene().wheels[&object].clone();
|
|
assert_eq!(&wheel.connection,connection);
|
|
wheel.visual=Some(VisualWheelMotion{steer_gain:if i<2{visual.steer_gain}else{0.},..visual});
|
|
Operation::Scene(SceneOperation::VehicleWheel{object,wheel})
|
|
}).collect();
|
|
apply(&mut doc,"visual_wheel_limits",operations);
|
|
assert_ne!(doc.head().content,legacy_head.content);
|
|
let source=doc.to_bytes(None).unwrap();
|
|
let restored=Document::from_bytes(&source,Limits::default(),None).unwrap();
|
|
assert_eq!(restored.head(),doc.head());assert_eq!(restored.scene().wheels,doc.scene().wheels);
|
|
let product=restored.compile(None).unwrap();
|
|
let model=StaticModel::parse_glb(&product.glb).unwrap();
|
|
for part in &model.driven_parts{
|
|
let before=legacy.driven_parts.iter().find(|p|p.connection==part.connection).unwrap();
|
|
let expected=restored.scene().wheels.values().find(|w|*w.connection==*part.connection).unwrap().visual.unwrap();
|
|
assert_eq!(part.visual,Some(expected));
|
|
assert_eq!(part.radius,before.radius);assert_eq!(part.width,before.width);
|
|
assert_eq!(part.anchor,before.anchor);assert_eq!(part.pivot,before.pivot);
|
|
assert_eq!(part.rest_transform().v,before.rest_transform().v);
|
|
// Packed color/UV lanes can have NaN bit patterns; compare the stream
|
|
// as stored bytes instead of floating-point numeric equality.
|
|
assert!(part.vertices.iter().map(|v|v.to_bits()).eq(before.vertices.iter().map(|v|v.to_bits())));
|
|
assert_eq!(part.indices,before.indices);
|
|
assert_eq!(expected.pose(1.,1.),(if part.connection.contains("front"){0.32}else{0.},0.08));
|
|
assert_eq!(expected.pose(-1.,-1.).1,-0.10);
|
|
}
|
|
// Rebinding without the optional field removes the display contract and
|
|
// restores the exact legacy content identity, not an emitted null/default.
|
|
let operations=doc.scene().wheels.iter().map(|(object,wheel)|{
|
|
let mut wheel=wheel.clone();wheel.visual=None;
|
|
Operation::Scene(SceneOperation::VehicleWheel{object:object.clone(),wheel})
|
|
}).collect();
|
|
apply(&mut doc,"restore_legacy_motion",operations);
|
|
assert_eq!(doc.head().content,legacy_head.content);
|
|
assert!(!doc.scene().value().to_json().contains("visual"));
|
|
}
|
|
|
|
#[test]
|
|
fn invalid_visual_wheel_limits_refuse_atomically(){
|
|
let mut doc=vehicle();let source=doc.to_bytes(None).unwrap();
|
|
for visual in [
|
|
"null", "{}",
|
|
r#"{"steer_gain":0.55,"steer_max":0.32,"compression":0.08}"#,
|
|
r#"{"steer_gain":1.01,"steer_max":0.32,"compression":0.08,"droop":0.10}"#,
|
|
r#"{"steer_gain":-0.01,"steer_max":0.32,"compression":0.08,"droop":0.10}"#,
|
|
r#"{"steer_gain":0.55,"steer_max":1.21,"compression":0.08,"droop":0.10}"#,
|
|
r#"{"steer_gain":0.55,"steer_max":-0.01,"compression":0.08,"droop":0.10}"#,
|
|
r#"{"steer_gain":0.55,"steer_max":0.32,"compression":-0.01,"droop":0.10}"#,
|
|
r#"{"steer_gain":0.55,"steer_max":0.32,"compression":5.01,"droop":0.10}"#,
|
|
r#"{"steer_gain":0.55,"steer_max":0.32,"compression":0.08,"droop":5.01}"#,
|
|
r#"{"steer_gain":0.55,"steer_max":0.32,"compression":0.08,"droop":0.10,"typo":1}"#,
|
|
]{
|
|
let request=format!(r#"[{{"op":"vehicle_wheel","object":"tire_0","connection":"wheel_front_left","pivot":[0,0,0],"radius":0.35,"width":0.24,"visual":{visual}}}]"#);
|
|
let result=parse_operations(&json::parse(request.as_bytes()).unwrap(),doc.limits())
|
|
.and_then(|operations|doc.apply(Transaction{request_id:"invalid_visual".into(),expected:doc.head(),operations},None).map(|_|()));
|
|
assert!(result.is_err(),"accepted {visual}");
|
|
assert_eq!(doc.to_bytes(None).unwrap(),source);
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn a_vehicle_laid_out_along_another_axis_with_its_sides_swapped_exports_facing_plus_z(){
|
|
// The wheels say the car faces -X, and every left binding sits on the
|
|
// car's right: the export turns it to +Z and names each corner by place.
|
|
let mut doc=vehicle();
|
|
for i in 0..4{
|
|
let (front,bound_left)=(i<2,i%2==0);
|
|
let (x,z)=(if front{-1.3}else{1.3},if bound_left{-0.95}else{0.95});
|
|
apply(&mut doc,&format!("turn_{i}"),vec![Operation::Scene(SceneOperation::Node{object:format!("tire_{i}"),node:SceneNode{parent:Some("body".into()),transform:Transform{translation:[x,-0.35,z],..Default::default()},..Default::default()}})]);
|
|
}
|
|
let product=doc.compile(None).unwrap();
|
|
let model=StaticModel::parse_glb(&product.glb).unwrap();
|
|
for i in 0..4usize{
|
|
let (front,bound_left)=(i<2,i%2==0);
|
|
let (x,z)=(if front{-1.3f32}else{1.3},if bound_left{-0.95f32}else{0.95});
|
|
let expected=format!("wheel_{}_{}",if front{"front"}else{"rear"},if bound_left{"right"}else{"left"});
|
|
let wheel=model.driven_parts.iter().find(|p|*p.connection==*expected).unwrap_or_else(||panic!("{expected} missing"));
|
|
let anchor=[-2.+z,0.65,-(4.+x)];
|
|
assert!((wheel.anchor.x-anchor[0]).abs()<1e-4&&(wheel.anchor.y-anchor[1]).abs()<1e-4&&(wheel.anchor.z-anchor[2]).abs()<1e-4,"{expected}: {:?}",wheel.anchor);
|
|
let rest=wheel.rest_transform();
|
|
assert!((rest.v[12]-wheel.anchor.x).abs()<1e-4&&(rest.v[14]-wheel.anchor.z).abs()<1e-4,"the drawn wheel stands at its anchor");
|
|
}
|
|
let fronts:Vec<_>=model.driven_parts.iter().filter(|p|p.connection.contains("front")).map(|p|p.anchor.z).collect();
|
|
assert!(fronts.iter().all(|z|*z>-3.),"front axle ahead (+Z)");
|
|
// Axles on top of each other still have no frame.
|
|
let mut flat=vehicle();
|
|
for i in 0..4{apply(&mut flat,&format!("flat_{i}"),vec![Operation::Scene(SceneOperation::Node{object:format!("tire_{i}"),node:SceneNode{parent:Some("body".into()),transform:Transform{translation:[if i%2==0{0.95}else{-0.95},-0.35,0.],..Default::default()},..Default::default()}})]);}
|
|
assert!(flat.compile(None).is_err());
|
|
}
|