CocosPlugin/esengine
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

chore: 添加第三方依赖库

Browse Source
This commit is contained in:
yhh
2025-12-03 16:24:08 +08:00
parent cb1b171216
commit 83aee02540
172 changed files with 27480 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

196
thirdparty/rapier.js/src/dynamics/multibody_joint.rs vendored Normal file
View File

@@ -0,0 +1,196 @@
use crate::dynamics::{RawJointAxis, RawJointType, RawMultibodyJointSet};
use crate::math::{RawRotation, RawVector};
use crate::utils::FlatHandle;
use rapier::dynamics::JointAxis;
use wasm_bindgen::prelude::*;
#[wasm_bindgen]
impl RawMultibodyJointSet {
/// The type of this joint.
pub fn jointType(&self, handle: FlatHandle) -> RawJointType {
self.map(handle, |j| j.data.locked_axes.into())
}
// /// The unique integer identifier of the first rigid-body this joint it attached to.
// pub fn jointBodyHandle1(&self, handle: FlatHandle) -> u32 {
// self.map(handle, |j| j.body1.into_raw_parts().0)
// }
//
// /// The unique integer identifier of the second rigid-body this joint is attached to.
// pub fn jointBodyHandle2(&self, handle: FlatHandle) -> u32 {
// self.map(handle, |j| j.body2.into_raw_parts().0)
// }
/// The angular part of the joint’s local frame relative to the first rigid-body it is attached to.
pub fn jointFrameX1(&self, handle: FlatHandle) -> RawRotation {
self.map(handle, |j| j.data.local_frame1.rotation.into())
}
/// The angular part of the joint’s local frame relative to the second rigid-body it is attached to.
pub fn jointFrameX2(&self, handle: FlatHandle) -> RawRotation {
self.map(handle, |j| j.data.local_frame2.rotation.into())
}
/// The position of the first anchor of this joint.
///
/// The first anchor gives the position of the points application point on the
/// local frame of the first rigid-body it is attached to.
pub fn jointAnchor1(&self, handle: FlatHandle) -> RawVector {
self.map(handle, |j| j.data.local_frame1.translation.vector.into())
}
/// The position of the second anchor of this joint.
///
/// The second anchor gives the position of the points application point on the
/// local frame of the second rigid-body it is attached to.
pub fn jointAnchor2(&self, handle: FlatHandle) -> RawVector {
self.map(handle, |j| j.data.local_frame2.translation.vector.into())
}
/// Are contacts between the rigid-bodies attached by this joint enabled?
pub fn jointContactsEnabled(&self, handle: FlatHandle) -> bool {
self.map(handle, |j| j.data.contacts_enabled)
}
/// Sets whether contacts are enabled between the rigid-bodies attached by this joint.
pub fn jointSetContactsEnabled(&mut self, handle: FlatHandle, enabled: bool) {
self.map_mut(handle, |j| {
j.data.contacts_enabled = enabled;
});
}
/// Are the limits for this joint enabled?
pub fn jointLimitsEnabled(&self, handle: FlatHandle, axis: RawJointAxis) -> bool {
self.map(handle, |j| {
j.data.limit_axes.contains(JointAxis::from(axis).into())
})
}
/// Return the lower limit along the given joint axis.
pub fn jointLimitsMin(&self, handle: FlatHandle, axis: RawJointAxis) -> f32 {
self.map(handle, |j| j.data.limits[axis as usize].min)
}
/// If this is a prismatic joint, returns its upper limit.
pub fn jointLimitsMax(&self, handle: FlatHandle, axis: RawJointAxis) -> f32 {
self.map(handle, |j| j.data.limits[axis as usize].max)
}
// pub fn jointConfigureMotorModel(
// &mut self,
// handle: FlatHandle,
// axis: RawJointAxis,
// model: RawMotorModel,
// ) {
// self.map_mut(handle, |j| {
// j.data.motors[axis as usize].model = model.into()
// })
// }
/*
#[cfg(feature = "dim3")]
pub fn jointConfigureBallMotorVelocity(
&mut self,
handle: FlatHandle,
vx: f32,
vy: f32,
vz: f32,
factor: f32,
) {
let targetVel = Vector3::new(vx, vy, vz);
self.map_mut(handle, |j| match &mut j.params {
JointData::SphericalJoint(j) => j.configure_motor_velocity(targetVel, factor),
_ => {}
})
}
#[cfg(feature = "dim3")]
pub fn jointConfigureBallMotorPosition(
&mut self,
handle: FlatHandle,
qw: f32,
qx: f32,
qy: f32,
qz: f32,
stiffness: f32,
damping: f32,
) {
let quat = Quaternion::new(qw, qx, qy, qz);
self.map_mut(handle, |j| match &mut j.params {
JointData::SphericalJoint(j) => {
if let Some(unit_quat) = UnitQuaternion::try_new(quat, 1.0e-5) {
j.configure_motor_position(unit_quat, stiffness, damping)
}
}
_ => {}
})
}
#[cfg(feature = "dim3")]
pub fn jointConfigureBallMotor(
&mut self,
handle: FlatHandle,
qw: f32,
qx: f32,
qy: f32,
qz: f32,
vx: f32,
vy: f32,
vz: f32,
stiffness: f32,
damping: f32,
) {
let quat = Quaternion::new(qw, qx, qy, qz);
let vel = Vector3::new(vx, vy, vz);
self.map_mut(handle, |j| match &mut j.params {
JointData::SphericalJoint(j) => {
if let Some(unit_quat) = UnitQuaternion::try_new(quat, 1.0e-5) {
j.configure_motor(unit_quat, vel, stiffness, damping)
}
}
_ => {}
})
}
*/
// pub fn jointConfigureMotorVelocity(
// &mut self,
// handle: FlatHandle,
// axis: RawJointAxis,
// targetVel: f32,
// factor: f32,
// ) {
// self.jointConfigureMotor(handle, axis, 0.0, targetVel, 0.0, factor)
// }
//
// pub fn jointConfigureMotorPosition(
// &mut self,
// handle: FlatHandle,
// axis: RawJointAxis,
// targetPos: f32,
// stiffness: f32,
// damping: f32,
// ) {
// self.jointConfigureMotor(handle, axis, targetPos, 0.0, stiffness, damping)
// }
// pub fn jointConfigureMotor(
// &mut self,
// handle: FlatHandle,
// axis: RawJointAxis,
// targetPos: f32,
// targetVel: f32,
// stiffness: f32,
// damping: f32,
// ) {
// self.map_mut(handle, |j| {
// j.data.motors[axis as usize].target_pos = targetPos;
// j.data.motors[axis as usize].target_vel = targetVel;
// j.data.motors[axis as usize].stiffness = stiffness;
// j.data.motors[axis as usize].damping = damping;
// })
// }
}