Conversation
|
Review changes with |
github-actions
bot
force-pushed
the
release-plz-2025-11-07T02-01-46Z
branch
2 times, most recently
from
baf8741 to
3c29ca7
Compare
github-actions
bot
force-pushed
the
release-plz-2025-11-07T02-01-46Z
branch
from
3c29ca7 to
c0fa413
Compare
github-actions
bot
force-pushed
the
release-plz-2025-11-07T02-01-46Z
branch
from
c0fa413 to
defb6ba
Compare
Contributor
Author
|
Bencher Report| Branch | release-plz-2025-11-07T02-01-46Z |
| Testbed | linux-gha |
Click to view all benchmark results
| Benchmark | Latency | Benchmark Result nanoseconds (ns) (Result Δ%) | Upper Boundary nanoseconds (ns) (Limit %) |
|---|---|---|---|
| component/access Lua | 📈 view plot 🚷 view threshold | 6,176.50 ns(+21.50%)Baseline: 5,083.55 ns | 7,112.24 ns (86.84%) |
| component/access Rhai | 📈 view plot 🚷 view threshold | 9,149.90 ns(+25.19%)Baseline: 7,309.07 ns | 11,445.65 ns (79.94%) |
| component/get Lua | 📈 view plot 🚷 view threshold | 3,140.40 ns(+6.01%)Baseline: 2,962.46 ns | 3,305.37 ns (95.01%) |
| component/get Rhai | 📈 view plot 🚷 view threshold | 7,737.70 ns(+31.10%)Baseline: 5,901.92 ns | 10,294.04 ns (75.17%) |
| conversions/Mut::from | 📈 view plot 🚷 view threshold | 82.67 ns(-15.69%)Baseline: 98.06 ns | 126.32 ns (65.45%) |
| conversions/Ref::from | 📈 view plot 🚷 view threshold | 80.09 ns(-15.87%)Baseline: 95.19 ns | 121.36 ns (65.99%) |
| conversions/ScriptValue::List | 📈 view plot 🚷 view threshold | 382.82 ns(-3.94%)Baseline: 398.53 ns | 470.91 ns (81.29%) |
| conversions/ScriptValue::Map | 📈 view plot 🚷 view threshold | 1,054.00 ns(-9.27%)Baseline: 1,161.66 ns | 1,379.71 ns (76.39%) |
| conversions/ScriptValue::Reference::from_into | 📈 view plot 🚷 view threshold | 24.95 ns(-10.32%)Baseline: 27.82 ns | 33.79 ns (73.84%) |
| conversions/Val::from_into | 📈 view plot 🚷 view threshold | 248.64 ns(-18.50%)Baseline: 305.08 ns | 415.39 ns (59.86%) |
| function/call 4 args Lua | 📈 view plot 🚷 view threshold | 1,901.50 ns(-9.10%)Baseline: 2,091.85 ns | 2,505.52 ns (75.89%) |
| function/call 4 args Rhai | 📈 view plot 🚷 view threshold | 1,463.50 ns(-4.70%)Baseline: 1,535.66 ns | 1,739.54 ns (84.13%) |
| function/call Lua | 📈 view plot 🚷 view threshold | 383.06 ns(-8.41%)Baseline: 418.24 ns | 502.87 ns (76.17%) |
| function/call Rhai | 📈 view plot 🚷 view threshold | 474.98 ns(-2.77%)Baseline: 488.51 ns | 535.84 ns (88.64%) |
| loading/empty Lua | 📈 view plot 🚷 view threshold | 1,071,400.00 ns(-4.53%)Baseline: 1,122,226.00 ns | 1,714,802.36 ns (62.48%) |
| loading/empty Rhai | 📈 view plot 🚷 view threshold | 1,206,200.00 ns(-12.28%)Baseline: 1,375,044.00 ns | 2,269,152.24 ns (53.16%) |
| math/vec mat ops Lua | 📈 view plot 🚷 view threshold | 9,505.00 ns(+5.43%)Baseline: 9,015.41 ns | 11,171.53 ns (85.08%) |
| math/vec mat ops Rhai | 📈 view plot 🚷 view threshold | 9,072.40 ns(+10.33%)Baseline: 8,223.15 ns | 11,028.92 ns (82.26%) |
| query/10 entities Lua | 📈 view plot 🚷 view threshold | 23,559.00 ns(-4.12%)Baseline: 24,572.30 ns | 28,228.46 ns (83.46%) |
| query/10 entities Rhai | 📈 view plot 🚷 view threshold | 29,582.00 ns(+18.26%)Baseline: 25,014.30 ns | 34,450.87 ns (85.87%) |
| query/100 entities Lua | 📈 view plot 🚷 view threshold | 41,802.00 ns(-9.57%)Baseline: 46,226.10 ns | 53,568.76 ns (78.03%) |
| query/100 entities Rhai | 📈 view plot 🚷 view threshold | 42,466.00 ns(+8.27%)Baseline: 39,221.00 ns | 47,984.39 ns (88.50%) |
| query/1000 entities Lua | 📈 view plot 🚷 view threshold | 252,800.00 ns(-14.72%)Baseline: 296,424.00 ns | 382,660.05 ns (66.06%) |
| query/1000 entities Rhai | 📈 view plot 🚷 view threshold | 172,650.00 ns(-8.69%)Baseline: 189,072.00 ns | 226,281.34 ns (76.30%) |
| reflection/10 Lua | 📈 view plot 🚷 view threshold | 5,476.90 ns(-8.33%)Baseline: 5,974.66 ns | 7,092.79 ns (77.22%) |
| reflection/10 Rhai | 📈 view plot 🚷 view threshold | 14,876.00 ns(-4.82%)Baseline: 15,629.40 ns | 17,468.98 ns (85.16%) |
| reflection/100 Lua | 📈 view plot 🚷 view threshold | 46,605.00 ns(-8.13%)Baseline: 50,730.20 ns | 60,859.62 ns (76.58%) |
| reflection/100 Rhai | 📈 view plot 🚷 view threshold | 643,430.00 ns(-12.80%)Baseline: 737,841.00 ns | 1,003,429.26 ns (64.12%) |
| resource/access Lua | 📈 view plot 🚷 view threshold | 3,938.20 ns(-2.94%)Baseline: 4,057.54 ns | 4,337.17 ns (90.80%) |
| resource/access Rhai | 📈 view plot 🚷 view threshold | 8,582.90 ns(+27.50%)Baseline: 6,731.66 ns | 10,752.44 ns (79.82%) |
| resource/get Lua | 📈 view plot 🚷 view threshold | 2,584.20 ns(+1.23%)Baseline: 2,552.81 ns | 2,896.56 ns (89.22%) |
| resource/get Rhai | 📈 view plot 🚷 view threshold | 7,209.20 ns(+33.70%)Baseline: 5,392.00 ns | 9,651.82 ns (74.69%) |
Contributor
Author
🔍 Binding Differences Detected
b/crates/bindings/bevy_reflect_bms_bindings/src/lib.rsindex 14955f8..84311bf 100644
--- a/crates/bindings/bevy_reflect_bms_bindings/src/lib.rs
+++ b/crates/bindings/bevy_reflect_bms_bindings/src/lib.rs
@@ -3160,6 +3160,23 @@ pub(crate) fn register_vec_3_functions(world: &mut World) {
" Returns a vector containing `e^self` (the exponential function) for each element of\n `self`.",
&["_self"],
)
+ .register_documented(
+ "exp2",
+ |_self: Val<::glam::Vec3>| {
+ let output: Val<::glam::Vec3> = {
+ {
+ let output: Val<::glam::Vec3> = ::glam::Vec3::exp2(
+ _self.into_inner(),
+ )
+ .into();
+ output
+ }
+ };
+ output
+ },
+ " Returns a vector containing `2^self` for each element of `self`.",
+ &["_self"],
+ )
.register_documented(
"extend",
|_self: Val<::glam::Vec3>, w: f32| {
@@ -3244,6 +3261,23 @@ pub(crate) fn register_vec_3_functions(world: &mut World) {
" Creates a new vector from an array.",
&["a"],
)
+ .register_documented(
+ "from_homogeneous",
+ |v: Val<::glam::Vec4>| {
+ let output: Val<::glam::Vec3> = {
+ {
+ let output: Val<::glam::Vec3> = ::glam::Vec3::from_homogeneous(
+ v.into_inner(),
+ )
+ .into();
+ output
+ }
+ };
+ output
+ },
+ " Projects a homogeneous coordinate to 3D space by performing perspective divide.\n # Panics\n Will panic if `v.w` is `0` when `glam_assert` is enabled.",
+ &["v"],
+ )
.register_documented(
"is_finite",
|_self: Val<::glam::Vec3>| {
@@ -3408,6 +3442,40 @@ pub(crate) fn register_vec_3_functions(world: &mut World) {
" Performs a linear interpolation between `self` and `rhs` based on the value `s`.\n When `s` is `0.0`, the result will be equal to `self`. When `s` is `1.0`, the result\n will be equal to `rhs`. When `s` is outside of range `[0, 1]`, the result is linearly\n extrapolated.",
&["_self", "rhs", "s"],
)
+ .register_documented(
+ "ln",
+ |_self: Val<::glam::Vec3>| {
+ let output: Val<::glam::Vec3> = {
+ {
+ let output: Val<::glam::Vec3> = ::glam::Vec3::ln(
+ _self.into_inner(),
+ )
+ .into();
+ output
+ }
+ };
+ output
+ },
+ " Returns a vector containing the natural logarithm for each element of `self`.\n This returns NaN when the element is negative and negative infinity when the element is zero.",
+ &["_self"],
+ )
+ .register_documented(
+ "log2",
+ |_self: Val<::glam::Vec3>| {
+ let output: Val<::glam::Vec3> = {
+ {
+ let output: Val<::glam::Vec3> = ::glam::Vec3::log2(
+ _self.into_inner(),
+ )
+ .into();
+ output
+ }
+ };
+ output
+ },
+ " Returns a vector containing the base 2 logarithm for each element of `self`.\n This returns NaN when the element is negative and negative infinity when the element is zero.",
+ &["_self"],
+ )
.register_documented(
"max",
|_self: Val<::glam::Vec3>, rhs: Val<::glam::Vec3>| {
@@ -4159,6 +4227,23 @@ pub(crate) fn register_vec_3_functions(world: &mut World) {
" Converts `self` to `[x, y, z]`",
&["_self"],
)
+ .register_documented(
+ "to_homogeneous",
+ |_self: Val<::glam::Vec3>| {
+ let output: Val<::glam::Vec4> = {
+ {
+ let output: Val<::glam::Vec4> = ::glam::Vec3::to_homogeneous(
+ _self.into_inner(),
+ )
+ .into();
+ output
+ }
+ };
+ output
+ },
+ " Creates a homogeneous coordinate from `self`, equivalent to `self.extend(1.0)`.",
+ &["_self"],
+ )
.register_documented(
"to_vec3a",
|_self: Val<::glam::Vec3>| {
@@ -35692,6 +35777,23 @@ pub(crate) fn register_vec_2_functions(world: &mut World) {
" Returns a vector containing `e^self` (the exponential function) for each element of\n `self`.",
&["_self"],
)
+ .register_documented(
+ "exp2",
+ |_self: Val<::glam::Vec2>| {
+ let output: Val<::glam::Vec2> = {
+ {
+ let output: Val<::glam::Vec2> = ::glam::Vec2::exp2(
+ _self.into_inner(),
+ )
+ .into();
+ output
+ }
+ };
+ output
+ },
+ " Returns a vector containing `2^self` for each element of `self`.",
+ &["_self"],
+ )
.register_documented(
"extend",
|_self: Val<::glam::Vec2>, z: f32| {
@@ -35955,6 +36057,40 @@ pub(crate) fn register_vec_2_functions(world: &mut World) {
" Performs a linear interpolation between `self` and `rhs` based on the value `s`.\n When `s` is `0.0`, the result will be equal to `self`. When `s` is `1.0`, the result\n will be equal to `rhs`. When `s` is outside of range `[0, 1]`, the result is linearly\n extrapolated.",
&["_self", "rhs", "s"],
)
+ .register_documented(
+ "ln",
+ |_self: Val<::glam::Vec2>| {
+ let output: Val<::glam::Vec2> = {
+ {
+ let output: Val<::glam::Vec2> = ::glam::Vec2::ln(
+ _self.into_inner(),
+ )
+ .into();
+ output
+ }
+ };
+ output
+ },
+ " Returns a vector containing the natural logarithm for each element of `self`.\n This returns NaN when the element is negative and negative infinity when the element is zero.",
+ &["_self"],
+ )
+ .register_documented(
+ "log2",
+ |_self: Val<::glam::Vec2>| {
+ let output: Val<::glam::Vec2> = {
+ {
+ let output: Val<::glam::Vec2> = ::glam::Vec2::log2(
+ _self.into_inner(),
+ )
+ .into();
+ output
+ }
+ };
+ output
+ },
+ " Returns a vector containing the base 2 logarithm for each element of `self`.\n This returns NaN when the element is negative and negative infinity when the element is zero.",
+ &["_self"],
+ )
.register_documented(
"max",
|_self: Val<::glam::Vec2>, rhs: Val<::glam::Vec2>| {
@@ -37491,6 +37627,23 @@ pub(crate) fn register_vec_3_a_functions(world: &mut World) {
" Returns a vector containing `e^self` (the exponential function) for each element of\n `self`.",
&["_self"],
)
+ .register_documented(
+ "exp2",
+ |_self: Val<::glam::Vec3A>| {
+ let output: Val<::glam::Vec3A> = {
+ {
+ let output: Val<::glam::Vec3A> = ::glam::Vec3A::exp2(
+ _self.into_inner(),
+ )
+ .into();
+ output
+ }
+ };
+ output
+ },
+ " Returns a vector containing `2^self` for each element of `self`.",
+ &["_self"],
+ )
.register_documented(
"extend",
|_self: Val<::glam::Vec3A>, w: f32| {
@@ -37575,6 +37728,23 @@ pub(crate) fn register_vec_3_a_functions(world: &mut World) {
" Creates a new vector from an array.",
&["a"],
)
+ .register_documented(
+ "from_homogeneous",
+ |v: Val<::glam::Vec4>| {
+ let output: Val<::glam::Vec3A> = {
+ {
+ let output: Val<::glam::Vec3A> = ::glam::Vec3A::from_homogeneous(
+ v.into_inner(),
+ )
+ .into();
+ output
+ }
+ };
+ output
+ },
+ " Projects a homogeneous coordinate to 3D space by performing perspective divide.\n # Panics\n Will panic if `v.w` is `0` when `glam_assert` is enabled.",
+ &["v"],
+ )
.register_documented(
"from_vec4",
|v: Val<::glam::Vec4>| {
@@ -37756,6 +37926,40 @@ pub(crate) fn register_vec_3_a_functions(world: &mut World) {
" Performs a linear interpolation between `self` and `rhs` based on the value `s`.\n When `s` is `0.0`, the result will be equal to `self`. When `s` is `1.0`, the result\n will be equal to `rhs`. When `s` is outside of range `[0, 1]`, the result is linearly\n extrapolated.",
&["_self", "rhs", "s"],
)
+ .register_documented(
+ "ln",
+ |_self: Val<::glam::Vec3A>| {
+ let output: Val<::glam::Vec3A> = {
+ {
+ let output: Val<::glam::Vec3A> = ::glam::Vec3A::ln(
+ _self.into_inner(),
+ )
+ .into();
+ output
+ }
+ };
+ output
+ },
+ " Returns a vector containing the natural logarithm for each element of `self`.\n This returns NaN when the element is negative and negative infinity when the element is zero.",
+ &["_self"],
+ )
+ .register_documented(
+ "log2",
+ |_self: Val<::glam::Vec3A>| {
+ let output: Val<::glam::Vec3A> = {
+ {
+ let output: Val<::glam::Vec3A> = ::glam::Vec3A::log2(
+ _self.into_inner(),
+ )
+ .into();
+ output
+ }
+ };
+ output
+ },
+ " Returns a vector containing the base 2 logarithm for each element of `self`.\n This returns NaN when the element is negative and negative infinity when the element is zero.",
+ &["_self"],
+ )
.register_documented(
"max",
|_self: Val<::glam::Vec3A>, rhs: Val<::glam::Vec3A>| {
@@ -38507,6 +38711,23 @@ pub(crate) fn register_vec_3_a_functions(world: &mut World) {
" Converts `self` to `[x, y, z]`",
&["_self"],
)
+ .register_documented(
+ "to_homogeneous",
+ |_self: Val<::glam::Vec3A>| {
+ let output: Val<::glam::Vec4> = {
+ {
+ let output: Val<::glam::Vec4> = ::glam::Vec3A::to_homogeneous(
+ _self.into_inner(),
+ )
+ .into();
+ output
+ }
+ };
+ output
+ },
+ " Creates a homogeneous coordinate from `self`, equivalent to `self.extend(1.0)`.",
+ &["_self"],
+ )
.register_documented(
"to_vec3",
|_self: Val<::glam::Vec3A>| {
@@ -39291,6 +39512,23 @@ pub(crate) fn register_vec_4_functions(world: &mut World) {
" Returns a vector containing `e^self` (the exponential function) for each element of\n `self`.",
&["_self"],
)
+ .register_documented(
+ "exp2",
+ |_self: Val<::glam::Vec4>| {
+ let output: Val<::glam::Vec4> = {
+ {
+ let output: Val<::glam::Vec4> = ::glam::Vec4::exp2(
+ _self.into_inner(),
+ )
+ .into();
+ output
+ }
+ };
+ output
+ },
+ " Returns a vector containing `2^self` for each element of `self`.",
+ &["_self"],
+ )
.register_documented(
"floor",
|_self: Val<::glam::Vec4>| {
@@ -39521,6 +39759,40 @@ pub(crate) fn register_vec_4_functions(world: &mut World) {
" Performs a linear interpolation between `self` and `rhs` based on the value `s`.\n When `s` is `0.0`, the result will be equal to `self`. When `s` is `1.0`, the result\n will be equal to `rhs`. When `s` is outside of range `[0, 1]`, the result is linearly\n extrapolated.",
&["_self", "rhs", "s"],
)
+ .register_documented(
+ "ln",
+ |_self: Val<::glam::Vec4>| {
+ let output: Val<::glam::Vec4> = {
+ {
+ let output: Val<::glam::Vec4> = ::glam::Vec4::ln(
+ _self.into_inner(),
+ )
+ .into();
+ output
+ }
+ };
+ output
+ },
+ " Returns a vector containing the natural logarithm for each element of `self`.\n This returns NaN when the element is negative and negative infinity when the element is zero.",
+ &["_self"],
+ )
+ .register_documented(
+ "log2",
+ |_self: Val<::glam::Vec4>| {
+ let output: Val<::glam::Vec4> = {
+ {
+ let output: Val<::glam::Vec4> = ::glam::Vec4::log2(
+ _self.into_inner(),
+ )
+ .into();
+ output
+ }
+ };
+ output
+ },
+ " Returns a vector containing the base 2 logarithm for each element of `self`.\n This returns NaN when the element is negative and negative infinity when the element is zero.",
+ &["_self"],
+ )
.register_documented(
"max",
|_self: Val<::glam::Vec4>, rhs: Val<::glam::Vec4>| {
@@ -39830,6 +40102,23 @@ pub(crate) fn register_vec_4_functions(world: &mut World) {
" Returns a vector containing each element of `self` raised to the power of `n`.",
&["_self", "n"],
)
+ .register_documented(
+ "project",
+ |_self: Val<::glam::Vec4>| {
+ let output: Val<::glam::Vec3> = {
+ {
+ let output: Val<::glam::Vec3> = ::glam::Vec4::project(
+ _self.into_inner(),
+ )
+ .into();
+ output
+ }
+ };
+ output
+ },
+ " Projects a homogeneous coordinate to 3D space by performing perspective divide.\n To project to [`Vec3A`] use [`Vec3A::from_homogeneous()`].\n # Panics\n Will panic if `self.w` is `0` when `glam_assert` is enabled.",
+ &["_self"],
+ )
.register_documented(
"project_onto",
|_self: Val<::glam::Vec4>, rhs: Val<::glam::Vec4>| {
@@ -41514,6 +41803,23 @@ pub(crate) fn register_d_vec_2_functions(world: &mut World) {
" Returns a vector containing `e^self` (the exponential function) for each element of\n `self`.",
&["_self"],
)
+ .register_documented(
+ "exp2",
+ |_self: Val<::glam::DVec2>| {
+ let output: Val<::glam::DVec2> = {
+ {
+ let output: Val<::glam::DVec2> = ::glam::DVec2::exp2(
+ _self.into_inner(),
+ )
+ .into();
+ output
+ }
+ };
+ output
+ },
+ " Returns a vector containing `2^self` for each element of `self`.",
+ &["_self"],
+ )
.register_documented(
"extend",
|_self: Val<::glam::DVec2>, z: f64| {
@@ -41777,6 +42083,40 @@ pub(crate) fn register_d_vec_2_functions(world: &mut World) {
" Performs a linear interpolation between `self` and `rhs` based on the value `s`.\n When `s` is `0.0`, the result will be equal to `self`. When `s` is `1.0`, the result\n will be equal to `rhs`. When `s` is outside of range `[0, 1]`, the result is linearly\n extrapolated.",
&["_self", "rhs", "s"],
)
+ .register_documented(
+ "ln",
+ |_self: Val<::glam::DVec2>| {
+ let output: Val<::glam::DVec2> = {
+ {
+ let output: Val<::glam::DVec2> = ::glam::DVec2::ln(
+ _self.into_inner(),
+ )
+ .into();
+ output
+ }
+ };
+ output
+ },
+ " Returns a vector containing the natural logarithm for each element of `self`.\n This returns NaN when the element is negative and negative infinity when the element is zero.",
+ &["_self"],
+ )
+ .register_documented(
+ "log2",
+ |_self: Val<::glam::DVec2>| {
+ let output: Val<::glam::DVec2> = {
+ {
+ let output: Val<::glam::DVec2> = ::glam::DVec2::log2(
+ _self.into_inner(),
+ )
+ .into();
+ output
+ }
+ };
+ output
+ },
+ " Returns a vector containing the base 2 logarithm for each element of `self`.\n This returns NaN when the element is negative and negative infinity when the element is zero.",
+ &["_self"],
+ )
.register_documented(
"max",
|_self: Val<::glam::DVec2>, rhs: Val<::glam::DVec2>| {
@@ -43328,6 +43668,23 @@ pub(crate) fn register_d_vec_3_functions(world: &mut World) {
" Returns a vector containing `e^self` (the exponential function) for each element of\n `self`.",
&["_self"],
)
+ .register_documented(
+ "exp2",
+ |_self: Val<::glam::DVec3>| {
+ let output: Val<::glam::DVec3> = {
+ {
+ let output: Val<::glam::DVec3> = ::glam::DVec3::exp2(
+ _self.into_inner(),
+ )
+ .into();
+ output
+ }
+ };
+ output
+ },
+ " Returns a vector containing `2^self` for each element of `self`.",
+ &["_self"],
+ )
.register_documented(
"extend",
|_self: Val<::glam::DVec3>, w: f64| {
@@ -43412,6 +43769,23 @@ pub(crate) fn register_d_vec_3_functions(world: &mut World) {
" Creates a new vector from an array.",
&["a"],
)
+ .register_documented(
+ "from_homogeneous",
+ |v: Val<::glam::DVec4>| {
+ let output: Val<::glam::DVec3> = {
+ {
+ let output: Val<::glam::DVec3> = ::glam::DVec3::from_homogeneous(
+ v.into_inner(),
+ )
+ .into();
+ output
+ }
+ };
+ output
+ },
+ " Projects a homogeneous coordinate to 3D space by performing perspective divide.\n # Panics\n Will panic if `v.w` is `0` when `glam_assert` is enabled.",
+ &["v"],
+ )
.register_documented(
"is_finite",
|_self: Val<::glam::DVec3>| {
@@ -43576,6 +43950,40 @@ pub(crate) fn register_d_vec_3_functions(world: &mut World) {
" Performs a linear interpolation between `self` and `rhs` based on the value `s`.\n When `s` is `0.0`, the result will be equal to `self`. When `s` is `1.0`, the result\n will be equal to `rhs`. When `s` is outside of range `[0, 1]`, the result is linearly\n extrapolated.",
&["_self", "rhs", "s"],
)
+ .register_documented(
+ "ln",
+ |_self: Val<::glam::DVec3>| {
+ let output: Val<::glam::DVec3> = {
+ {
+ let output: Val<::glam::DVec3> = ::glam::DVec3::ln(
+ _self.into_inner(),
+ )
+ .into();
+ output
+ }
+ };
+ output
+ },
+ " Returns a vector containing the natural logarithm for each element of `self`.\n This returns NaN when the element is negative and negative infinity when the element is zero.",
+ &["_self"],
+ )
+ .register_documented(
+ "log2",
+ |_self: Val<::glam::DVec3>| {
+ let output: Val<::glam::DVec3> = {
+ {
+ let output: Val<::glam::DVec3> = ::glam::DVec3::log2(
+ _self.into_inner(),
+ )
+ .into();
+ output
+ }
+ };
+ output
+ },
+ " Returns a vector containing the base 2 logarithm for each element of `self`.\n This returns NaN when the element is negative and negative infinity when the element is zero.",
+ &["_self"],
+ )
.register_documented(
"max",
|_self: Val<::glam::DVec3>, rhs: Val<::glam::DVec3>| {
@@ -44327,6 +44735,23 @@ pub(crate) fn register_d_vec_3_functions(world: &mut World) {
" Converts `self` to `[x, y, z]`",
&["_self"],
)
+ .register_documented(
+ "to_homogeneous",
+ |_self: Val<::glam::DVec3>| {
+ let output: Val<::glam::DVec4> = {
+ {
+ let output: Val<::glam::DVec4> = ::glam::DVec3::to_homogeneous(
+ _self.into_inner(),
+ )
+ .into();
+ output
+ }
+ };
+ output
+ },
+ " Creates a homogeneous coordinate from `self`, equivalent to `self.extend(1.0)`.",
+ &["_self"],
+ )
.register_documented(
"trunc",
|_self: Val<::glam::DVec3>| {
@@ -45102,6 +45527,23 @@ pub(crate) fn register_d_vec_4_functions(world: &mut World) {
" Returns a vector containing `e^self` (the exponential function) for each element of\n `self`.",
&["_self"],
)
+ .register_documented(
+ "exp2",
+ |_self: Val<::glam::DVec4>| {
+ let output: Val<::glam::DVec4> = {
+ {
+ let output: Val<::glam::DVec4> = ::glam::DVec4::exp2(
+ _self.into_inner(),
+ )
+ .into();
+ output
+ }
+ };
+ output
+ },
+ " Returns a vector containing `2^self` for each element of `self`.",
+ &["_self"],
+ )
.register_documented(
"floor",
|_self: Val<::glam::DVec4>| {
@@ -45332,6 +45774,40 @@ pub(crate) fn register_d_vec_4_functions(world: &mut World) {
" Performs a linear interpolation between `self` and `rhs` based on the value `s`.\n When `s` is `0.0`, the result will be equal to `self`. When `s` is `1.0`, the result\n will be equal to `rhs`. When `s` is outside of range `[0, 1]`, the result is linearly\n extrapolated.",
&["_self", "rhs", "s"],
)
+ .register_documented(
+ "ln",
+ |_self: Val<::glam::DVec4>| {
+ let output: Val<::glam::DVec4> = {
+ {
+ let output: Val<::glam::DVec4> = ::glam::DVec4::ln(
+ _self.into_inner(),
+ )
+ .into();
+ output
+ }
+ };
+ output
+ },
+ " Returns a vector containing the natural logarithm for each element of `self`.\n This returns NaN when the element is negative and negative infinity when the element is zero.",
+ &["_self"],
+ )
+ .register_documented(
+ "log2",
+ |_self: Val<::glam::DVec4>| {
+ let output: Val<::glam::DVec4> = {
+ {
+ let output: Val<::glam::DVec4> = ::glam::DVec4::log2(
+ _self.into_inner(),
+ )
+ .into();
+ output
+ }
+ };
+ output
+ },
+ " Returns a vector containing the base 2 logarithm for each element of `self`.\n This returns NaN when the element is negative and negative infinity when the element is zero.",
+ &["_self"],
+ )
.register_documented(
"max",
|_self: Val<::glam::DVec4>, rhs: Val<::glam::DVec4>| {
@@ -45641,6 +46117,23 @@ pub(crate) fn register_d_vec_4_functions(world: &mut World) {
" Returns a vector containing each element of `self` raised to the power of `n`.",
&["_self", "n"],
)
+ .register_documented(
+ "project",
+ |_self: Val<::glam::DVec4>| {
+ let output: Val<::glam::DVec3> = {
+ {
+ let output: Val<::glam::DVec3> = ::glam::DVec4::project(
+ _self.into_inner(),
+ )
+ .into();
+ output
+ }
+ };
+ output
+ },
+ " Projects a homogeneous coordinate to 3D space by performing perspective divide.\n # Panics\n Will panic if `self.w` is `0` when `glam_assert` is enabled.",
+ &["_self"],
+ )
.register_documented(
"project_onto",
|_self: Val<::glam::DVec4>, rhs: Val<::glam::DVec4>| {
@@ -56557,7 +57050,7 @@ pub(crate) fn register_uuid_functions(world: &mut World) {
};
output
},
- " Creates a UUID using the supplied bytes in little endian order.\n The individual fields encoded in the buffer will be flipped.\n # Examples\n Basic usage:\n ```\n # fn main() -> Result<(), uuid::Error> {\n # use uuid::Uuid;\n let bytes = [\n 0xa1, 0xa2, 0xa3, 0xa4,\n 0xb1, 0xb2,\n 0xc1, 0xc2,\n 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8,\n ];\n let uuid = Uuid::from_bytes_le(bytes);\n assert_eq!(\n \"a4a3a2a1-b2b1-c2c1-d1d2-d3d4d5d6d7d8\",\n uuid.hyphenated().to_string(),\n );\n # Ok(())\n # }\n ```",
+ " Creates a UUID using the supplied bytes in little endian order.\n Note that ordering is applied to each _field_, rather than to the bytes as a whole.\n This ordering is compatible with Microsoft's mixed endian GUID format.\n # Examples\n Basic usage:\n ```\n # fn main() -> Result<(), uuid::Error> {\n # use uuid::Uuid;\n let bytes = [\n 0xa1, 0xa2, 0xa3, 0xa4,\n 0xb1, 0xb2,\n 0xc1, 0xc2,\n 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8,\n ];\n let uuid = Uuid::from_bytes_le(bytes);\n assert_eq!(\n \"a4a3a2a1-b2b1-c2c1-d1d2-d3d4d5d6d7d8\",\n uuid.hyphenated().to_string(),\n );\n # Ok(())\n # }\n ```",
&["b"],
)
.register_documented(
@@ -56737,7 +57230,7 @@ pub(crate) fn register_uuid_functions(world: &mut World) {
};
output
},
- " Returns the bytes of the UUID in little-endian order.\n The bytes will be flipped to convert into little-endian order. This is\n based on the endianness of the UUID, rather than the target environment\n so bytes will be flipped on both big and little endian machines.\n # Examples\n ```\n use uuid::Uuid;\n # fn main() -> Result<(), uuid::Error> {\n let uuid = Uuid::parse_str(\"a1a2a3a4-b1b2-c1c2-d1d2-d3d4d5d6d7d8\")?;\n assert_eq!(\n uuid.to_bytes_le(),\n ([\n 0xa4, 0xa3, 0xa2, 0xa1, 0xb2, 0xb1, 0xc2, 0xc1, 0xd1, 0xd2,\n 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8\n ])\n );\n # Ok(())\n # }\n ```",
+ " Returns the bytes of the UUID in little-endian order.\n The bytes for each field will be flipped to convert into little-endian order.\n This is based on the endianness of the UUID, rather than the target environment\n so bytes will be flipped on both big and little endian machines.\n Note that ordering is applied to each _field_, rather than to the bytes as a whole.\n This ordering is compatible with Microsoft's mixed endian GUID format.\n # Examples\n ```\n use uuid::Uuid;\n # fn main() -> Result<(), uuid::Error> {\n let uuid = Uuid::parse_str(\"a1a2a3a4-b1b2-c1c2-d1d2-d3d4d5d6d7d8\")?;\n assert_eq!(\n uuid.to_bytes_le(),\n ([\n 0xa4, 0xa3, 0xa2, 0xa1, 0xb2, 0xb1, 0xc2, 0xc1, 0xd1, 0xd2,\n 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8\n ])\n );\n # Ok(())\n # }\n ```",
&["_self"],
)
.register_documented(
|
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
1 participant
Add this suggestion to a batch that can be applied as a single commit.This suggestion is invalid because no changes were made to the code.Suggestions cannot be applied while the pull request is closed.Suggestions cannot be applied while viewing a subset of changes.Only one suggestion per line can be applied in a batch.Add this suggestion to a batch that can be applied as a single commit.Applying suggestions on deleted lines is not supported.You must change the existing code in this line in order to create a valid suggestion.Outdated suggestions cannot be applied.This suggestion has been applied or marked resolved.Suggestions cannot be applied from pending reviews.Suggestions cannot be applied on multi-line comments.Suggestions cannot be applied while the pull request is queued to merge.Suggestion cannot be applied right now. Please check back later.
🤖 New release
bevy_mod_scripting_derive: 0.17.0 -> 0.18.0bevy_mod_scripting_display: 0.17.0 -> 0.18.0 (✓ API compatible changes)bevy_mod_scripting_asset: 0.17.0 -> 0.18.0 (✓ API compatible changes)bevy_mod_scripting_bindings_domain: 0.17.0 -> 0.18.0bevy_mod_scripting_script: 0.17.0 -> 0.18.0 (⚠ API breaking changes)bevy_system_reflection: 0.17.0 -> 0.18.0 (✓ API compatible changes)bevy_mod_scripting_bindings: 0.17.0 -> 0.18.0 (✓ API compatible changes)bevy_mod_scripting_core: 0.17.0 -> 0.18.0 (⚠ API breaking changes)bevy_mod_scripting_lua: 0.17.0 -> 0.18.0 (✓ API compatible changes)bevy_mod_scripting_rhai: 0.17.0 -> 0.18.0 (✓ API compatible changes)bevy_a11y_bms_bindings: 0.17.0 -> 0.18.0 (✓ API compatible changes)bevy_animation_bms_bindings: 0.17.0 -> 0.18.0 (✓ API compatible changes)bevy_asset_bms_bindings: 0.17.0 -> 0.18.0 (✓ API compatible changes)bevy_camera_bms_bindings: 0.17.0 -> 0.18.0bevy_color_bms_bindings: 0.17.0 -> 0.18.0 (✓ API compatible changes)bevy_core_pipeline_bms_bindings: 0.17.0 -> 0.18.0 (✓ API compatible changes)bevy_ecs_bms_bindings: 0.17.0 -> 0.18.0 (✓ API compatible changes)bevy_gizmos_bms_bindings: 0.17.0 -> 0.18.0 (✓ API compatible changes)bevy_gltf_bms_bindings: 0.17.0 -> 0.18.0 (✓ API compatible changes)bevy_image_bms_bindings: 0.17.0 -> 0.18.0 (✓ API compatible changes)bevy_input_bms_bindings: 0.17.0 -> 0.18.0 (✓ API compatible changes)bevy_input_focus_bms_bindings: 0.17.0 -> 0.18.0 (✓ API compatible changes)bevy_light_bms_bindings: 0.17.0 -> 0.18.0bevy_math_bms_bindings: 0.17.0 -> 0.18.0 (✓ API compatible changes)bevy_mesh_bms_bindings: 0.17.0 -> 0.18.0 (✓ API compatible changes)bevy_pbr_bms_bindings: 0.17.0 -> 0.18.0 (✓ API compatible changes)bevy_picking_bms_bindings: 0.17.0 -> 0.18.0 (✓ API compatible changes)bevy_post_process_bms_bindings: 0.17.0 -> 0.18.0bevy_reflect_bms_bindings: 0.17.0 -> 0.18.0 (✓ API compatible changes)bevy_render_bms_bindings: 0.17.0 -> 0.18.0 (✓ API compatible changes)bevy_scene_bms_bindings: 0.17.0 -> 0.18.0 (✓ API compatible changes)bevy_sprite_bms_bindings: 0.17.0 -> 0.18.0 (✓ API compatible changes)bevy_sprite_render_bms_bindings: 0.17.0 -> 0.18.0bevy_text_bms_bindings: 0.17.0 -> 0.18.0 (✓ API compatible changes)bevy_time_bms_bindings: 0.17.0 -> 0.18.0 (✓ API compatible changes)bevy_transform_bms_bindings: 0.17.0 -> 0.18.0 (✓ API compatible changes)bevy_ui_bms_bindings: 0.17.0 -> 0.18.0bevy_ui_render_bms_bindings: 0.17.0 -> 0.18.0bevy_mod_scripting_functions: 0.17.0 -> 0.18.0 (✓ API compatible changes)ladfile: 0.17.0 -> 0.18.0lua_language_server_lad_backend: 0.17.0 -> 0.18.0mdbook_lad_preprocessor: 0.17.0 -> 0.18.0 (✓ API compatible changes)ladfile_builder: 0.17.0 -> 0.18.0 (✓ API compatible changes)bevy_mod_scripting: 0.17.0 -> 0.18.0 (✓ API compatible changes)⚠
bevy_mod_scripting_scriptbreaking changes⚠
bevy_mod_scripting_corebreaking changesChangelog
bevy_mod_scripting_derivebevy_mod_scripting_displaybevy_mod_scripting_assetbevy_mod_scripting_bindings_domainbevy_mod_scripting_scriptbevy_system_reflectionbevy_mod_scripting_bindingsbevy_mod_scripting_corebevy_mod_scripting_luabevy_mod_scripting_rhaibevy_a11y_bms_bindingsbevy_animation_bms_bindingsbevy_asset_bms_bindingsbevy_camera_bms_bindingsbevy_color_bms_bindingsbevy_core_pipeline_bms_bindingsbevy_ecs_bms_bindingsbevy_gizmos_bms_bindingsbevy_gltf_bms_bindingsbevy_image_bms_bindingsbevy_input_bms_bindingsbevy_input_focus_bms_bindingsbevy_light_bms_bindingsbevy_math_bms_bindingsbevy_mesh_bms_bindingsbevy_pbr_bms_bindingsbevy_picking_bms_bindingsbevy_post_process_bms_bindingsbevy_reflect_bms_bindingsbevy_render_bms_bindingsbevy_scene_bms_bindingsbevy_sprite_bms_bindingsbevy_sprite_render_bms_bindingsbevy_text_bms_bindingsbevy_time_bms_bindingsbevy_transform_bms_bindingsbevy_ui_bms_bindingsbevy_ui_render_bms_bindingsbevy_mod_scripting_functionsladfilelua_language_server_lad_backendmdbook_lad_preprocessorladfile_builderbevy_mod_scriptingThis PR was generated with release-plz.