Compare commits
No commits in common. "8302a8c074990726804175d757d7d99bb7212601" and "577babdd916b78f6589e79e4937f8f182d68f77b" have entirely different histories.
8302a8c074
...
577babdd91
|
|
@ -16,6 +16,3 @@ glam = "0.27.0"
|
|||
flo_draw = "0.3.1"
|
||||
flo_canvas = "0.3.1"
|
||||
itertools-num = "0.1.3"
|
||||
|
||||
[dev-dependencies]
|
||||
approx = "0.5.1"
|
||||
|
|
|
|||
293
src/bin/flat.rs
293
src/bin/flat.rs
|
|
@ -5,12 +5,6 @@ use glam::*;
|
|||
use riemann::{Decomp2, Metric, trace_iter};
|
||||
use crate::boundary::Loop;
|
||||
|
||||
#[cfg(test)]
|
||||
use approx::assert_abs_diff_eq;
|
||||
|
||||
const RAYS_IN_FAN: usize = 101;
|
||||
const DT: f32 = 0.1;
|
||||
|
||||
pub fn main() {
|
||||
let space = Coil {
|
||||
scale: 3.0,
|
||||
|
|
@ -19,26 +13,15 @@ pub fn main() {
|
|||
m: 10.0,
|
||||
};
|
||||
let space = Rect {
|
||||
inner_radius: 30.0,
|
||||
outer_radius: 50.0,
|
||||
internal_halflength: 100.0,
|
||||
external_halflength: 300.0,
|
||||
scale: 3.0,
|
||||
r: vec2(30.0, 300.0),
|
||||
m: vec2(20.0, 50.0),
|
||||
};
|
||||
with_2d_graphics(move || {
|
||||
let canvas = create_drawing_window("Refraction");
|
||||
canvas.draw(|gc| {
|
||||
gc.canvas_height(1000.0);
|
||||
gc.line_width(0.5);
|
||||
|
||||
// gc.canvas_height(100.0);
|
||||
// gc.center_region(-100.0, -200.0, 100.0, 0.0);
|
||||
// gc.line_width(0.1);
|
||||
|
||||
space.draw_background(gc);
|
||||
|
||||
// gc.stroke_color(Color::Rgba(0.5, 1.0, 0.0, 1.0));
|
||||
// space.draw_fan(gc, vec2(0.0, -0.5 * space.external_halflength), vec2(1.0, 1.0), 1.0);
|
||||
space.draw_rays(gc, &space);
|
||||
space.render(gc);
|
||||
|
||||
let space = Rc::new(space);
|
||||
let parts: Vec<Box<dyn SpacePart>> = vec![
|
||||
|
|
@ -46,16 +29,40 @@ pub fn main() {
|
|||
Box::new(Wall { space: space.clone() }),
|
||||
Box::new(Inside { space: space.clone() }),
|
||||
];
|
||||
space.draw_rays(gc, parts.as_slice());
|
||||
// gc.stroke_color(Color::Rgba(1.0, 0.0, 1.0, 1.0));
|
||||
// parts.draw_fan(gc, vec2(0.0, space.u(-0.5 * space.external_halflength)), vec2(1.0, 1.0), 1.0);
|
||||
});
|
||||
});
|
||||
}
|
||||
|
||||
trait Interesting {
|
||||
fn draw_background(&self, gc: &mut Vec<Draw>);
|
||||
fn draw_rays(&self, gc: &mut Vec<Draw>, tracer: &(impl Rayable + ?Sized));
|
||||
gc.new_path();
|
||||
let dt = 1.0;
|
||||
let mut s = boundary::Id(0);
|
||||
let mut p = vec2(-500.0, 0.0);
|
||||
let mut v = vec2(3.0, 1.0).normalize();
|
||||
let part = &*parts[s.0 as usize];
|
||||
gc.stroke_color(part.color());
|
||||
gc.move_to(p.x, p.y);
|
||||
for _ in 0..10000 {
|
||||
let part = &*parts[s.0 as usize];
|
||||
let a: Vec2 = -riemann::convolute(riemann::krist(part, p), v);
|
||||
v = v + a * dt;
|
||||
if let Some((id, base, dir)) = part.next(p, v, dt) {
|
||||
gc.stroke();
|
||||
gc.new_path();
|
||||
let pt = part.globalize_loc(p);
|
||||
gc.move_to(pt.x, pt.y);
|
||||
s = id;
|
||||
p = base;
|
||||
v = dir;
|
||||
let part = &*parts[s.0 as usize];
|
||||
let pt = part.globalize_loc(p);
|
||||
gc.stroke_color(part.color());
|
||||
gc.line_to(pt.x, pt.y);
|
||||
} else {
|
||||
p = p + v * dt;
|
||||
let pt = part.globalize_loc(p);
|
||||
gc.line_to(pt.x, pt.y);
|
||||
}
|
||||
}
|
||||
gc.stroke();
|
||||
});
|
||||
});
|
||||
}
|
||||
|
||||
trait SpacePart: boundary::Boundary + Metric + SpaceVisual {}
|
||||
|
|
@ -93,75 +100,37 @@ impl SpaceVisual for Inside {
|
|||
}
|
||||
|
||||
fn globalize_loc(&self, pos: Vec2) -> Vec2 {
|
||||
vec2(pos.x, self.space.x(pos.y))
|
||||
vec2(pos.x, pos.y * self.space.scale)
|
||||
}
|
||||
}
|
||||
|
||||
impl Rayable for [Box<dyn SpacePart>] {
|
||||
fn draw_ray(&self, gc: &mut Vec<Draw>, base: Vec2, dir: Vec2) {
|
||||
gc.new_path();
|
||||
let dt = DT;
|
||||
let mut s = boundary::Id(0);
|
||||
let mut p = base;
|
||||
let mut v = dir.normalize();
|
||||
let part = &*self[s.0 as usize];
|
||||
gc.stroke_color(part.color());
|
||||
gc.move_to(p.x, p.y);
|
||||
for _ in 0..10000 {
|
||||
let part = &*self[s.0 as usize];
|
||||
let a: Vec2 = -riemann::convolute(riemann::krist(part, p), v);
|
||||
v = v + a * dt;
|
||||
if let Some((id, base, dir)) = part.next(p, v, dt) {
|
||||
gc.stroke();
|
||||
gc.new_path();
|
||||
let pt = part.globalize_loc(p);
|
||||
gc.move_to(pt.x, pt.y);
|
||||
s = id;
|
||||
p = base;
|
||||
v = dir;
|
||||
let part = &*self[s.0 as usize];
|
||||
let pt = part.globalize_loc(p);
|
||||
gc.stroke_color(part.color());
|
||||
gc.line_to(pt.x, pt.y);
|
||||
} else {
|
||||
p = p + v * dt;
|
||||
let pt = part.globalize_loc(p);
|
||||
gc.line_to(pt.x, pt.y);
|
||||
}
|
||||
}
|
||||
gc.stroke();
|
||||
}
|
||||
}
|
||||
|
||||
trait Rayable {
|
||||
fn draw_ray(&self, gc: &mut Vec<Draw>, base: Vec2, dir: Vec2);
|
||||
|
||||
fn draw_fan(&self, gc: &mut Vec<Draw>, base: Vec2, dir: Vec2, spread: f32) {
|
||||
let dir = dir.normalize();
|
||||
let v = vec2(-dir.y, dir.x);
|
||||
for y in itertools_num::linspace(-spread, spread, RAYS_IN_FAN) {
|
||||
self.draw_ray(gc, base, dir + y * v);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl<T: Metric> Rayable for T {
|
||||
fn draw_ray(&self, gc: &mut Vec<Draw>, base: Vec2, dir: Vec2) {
|
||||
let dir = self.globalize(base, dir);
|
||||
fn draw_ray(gc: &mut Vec<Draw>, space: &impl Metric, base: Vec2, dir: Vec2) {
|
||||
let dir = space.globalize(base, dir);
|
||||
gc.new_path();
|
||||
gc.move_to(base.x, base.y);
|
||||
for pt in trace_iter(self, base, dir, DT).take(10000) {
|
||||
for pt in trace_iter(space, base, dir, 1.0).take(10000) {
|
||||
gc.line_to(pt.x, pt.y);
|
||||
if pt.abs().cmpgt(Vec2::splat(1000.0)).any() {
|
||||
break;
|
||||
}
|
||||
}
|
||||
gc.stroke();
|
||||
}
|
||||
|
||||
fn draw_fan(gc: &mut Vec<Draw>, space: &impl Metric, base: Vec2, dir: Vec2, spread: f32) {
|
||||
let dir = dir.normalize();
|
||||
let v = vec2(-dir.y, dir.x);
|
||||
for y in itertools_num::linspace(-spread, spread, 101) {
|
||||
draw_ray(gc, space, base, dir + y * v);
|
||||
}
|
||||
}
|
||||
|
||||
impl Interesting for Coil {
|
||||
fn draw_background(&self, gc: &mut Vec<Draw>) {
|
||||
trait Renderable {
|
||||
fn render(&self, gc: &mut Vec<Draw>);
|
||||
}
|
||||
|
||||
impl Renderable for Coil {
|
||||
fn render(&self, gc: &mut Vec<Draw>) {
|
||||
gc.new_path();
|
||||
gc.circle(0.0, 0.0, self.r + self.w + self.m);
|
||||
gc.circle(0.0, 0.0, self.r + self.w);
|
||||
|
|
@ -170,35 +139,27 @@ impl Interesting for Coil {
|
|||
gc.winding_rule(WindingRule::EvenOdd);
|
||||
gc.fill_color(Color::Rgba(0.8, 0.8, 0.8, 1.0));
|
||||
gc.fill();
|
||||
}
|
||||
|
||||
fn draw_rays(&self, gc: &mut Vec<Draw>, tracer: &(impl Rayable + ?Sized)) {
|
||||
gc.line_width(0.5);
|
||||
gc.stroke_color(Color::Rgba(1.0, 0.5, 0.0, 1.0));
|
||||
tracer.draw_fan(gc, vec2(-500.0, 0.0), vec2(1.0, 0.0), 1.0);
|
||||
draw_fan(gc, self, vec2(-500.0, 0.0), vec2(1.0, 0.0), 1.0);
|
||||
gc.stroke_color(Color::Rgba(0.0, 0.5, 1.0, 1.0));
|
||||
tracer.draw_fan(gc, vec2(0.0, self.r), vec2(1.0, 0.0), 1.0);
|
||||
draw_fan(gc, self, vec2(0.0, self.r), vec2(1.0, 0.0), 1.0);
|
||||
}
|
||||
}
|
||||
|
||||
impl Interesting for Rect {
|
||||
fn draw_background(&self, gc: &mut Vec<Draw>) {
|
||||
impl Renderable for Rect {
|
||||
fn render(&self, gc: &mut Vec<Draw>) {
|
||||
gc.new_path();
|
||||
gc.rect(-self.outer_radius, -self.external_halflength, self.outer_radius, self.external_halflength);
|
||||
gc.rect(-self.inner_radius, -self.external_halflength, self.inner_radius, self.external_halflength);
|
||||
gc.rect(-self.r.x - self.m.x, -self.r.y - self.m.y, self.r.x + self.m.x, self.r.y + self.m.y);
|
||||
gc.rect(-self.r.x, -self.r.y, self.r.x, self.r.y);
|
||||
gc.winding_rule(WindingRule::EvenOdd);
|
||||
gc.fill_color(Color::Rgba(0.8, 0.8, 0.8, 1.0));
|
||||
gc.fill();
|
||||
}
|
||||
|
||||
fn draw_rays(&self, gc: &mut Vec<Draw>, tracer: &(impl Rayable + ?Sized)) {
|
||||
gc.line_width(0.5);
|
||||
gc.stroke_color(Color::Rgba(1.0, 0.5, 0.0, 1.0));
|
||||
tracer.draw_fan(gc, vec2(-500.0, 0.0), vec2(1.0, 0.0), 1.0);
|
||||
gc.stroke_color(Color::Rgba(0.5, 1.0, 0.0, 1.0));
|
||||
tracer.draw_fan(gc, vec2(0.0, -0.5 * self.external_halflength), vec2(1.0, 1.0), 1.0);
|
||||
draw_fan(gc, self, vec2(-500.0, 0.0), vec2(1.0, 0.0), 1.0);
|
||||
gc.stroke_color(Color::Rgba(0.0, 0.5, 1.0, 1.0));
|
||||
tracer.draw_fan(gc, vec2(0.0, -0.5 * self.external_halflength), vec2(1.0, 1.0), 1.0);
|
||||
gc.stroke_color(Color::Rgba(0.2, 0.7, 0.0, 1.0));
|
||||
tracer.draw_fan(gc, vec2(-0.5 * self.inner_radius, -1.2 * self.external_halflength), vec2(0.0, 1.0), 1.0);
|
||||
draw_fan(gc, self, vec2(0.0, -0.5 * self.r.y), vec2(1.0, 1.0), 1.0);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -228,77 +189,17 @@ impl Metric for Coil {
|
|||
}
|
||||
|
||||
struct Rect {
|
||||
outer_radius: f32,
|
||||
inner_radius: f32,
|
||||
external_halflength: f32,
|
||||
internal_halflength: f32,
|
||||
}
|
||||
|
||||
impl Rect {
|
||||
fn γ(&self) -> f32 { self.external_halflength / self.internal_halflength }
|
||||
fn ri(&self) -> f32 { self.internal_halflength }
|
||||
fn re(&self) -> f32 { self.external_halflength }
|
||||
fn a(&self) -> f32 { (1.0 - self.γ()) / self.ri() }
|
||||
fn b(&self) -> f32 { 2.0 * self.γ() - 1.0 }
|
||||
|
||||
fn root(&self, x: f32) -> f32 { ((2.0 * self.γ() - 1.0).powi(2) + 4.0 * (1.0 - self.γ()) * x / self.ri()).sqrt() }
|
||||
fn d(&self, u: f32) -> f32 { 2.0 * self.a() * u + self.b() }
|
||||
pub fn x(&self, u: f32) -> f32 { (self.a() * u.abs() + self.b()) * u }
|
||||
pub fn u(&self, x: f32) -> f32 { 0.5 * self.ri() * (1.0 - 2.0 * self.γ() + self.root(x.abs())) / (1.0 - self.γ()) * x.signum() }
|
||||
pub fn dx(&self, u: f32, du: f32) -> f32 { du * self.d(u.abs()) }
|
||||
pub fn du(&self, x: f32, dx: f32) -> f32 { dx / self.root(x.abs()) }
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_rect() {
|
||||
let r = Rect {
|
||||
outer_radius: 50.0,
|
||||
inner_radius: 20.0,
|
||||
external_halflength: 100.0,
|
||||
internal_halflength: 10.0,
|
||||
};
|
||||
assert_abs_diff_eq!(r.x(r.internal_halflength), r.external_halflength, epsilon = 1.0e-5);
|
||||
assert_abs_diff_eq!(r.x(-r.internal_halflength), -r.external_halflength, epsilon = 1.0e-5);
|
||||
assert_abs_diff_eq!(r.u(r.external_halflength), r.internal_halflength, epsilon = 1.0e-5);
|
||||
assert_abs_diff_eq!(r.u(-r.external_halflength), -r.internal_halflength, epsilon = 1.0e-5);
|
||||
|
||||
assert_abs_diff_eq!(r.dx(r.internal_halflength, 3.0), 3.0, epsilon = 1.0e-5);
|
||||
assert_abs_diff_eq!(r.dx(-r.internal_halflength, 3.0), 3.0, epsilon = 1.0e-5);
|
||||
assert_abs_diff_eq!(r.du(r.external_halflength, 3.0), 3.0, epsilon = 1.0e-5);
|
||||
assert_abs_diff_eq!(r.du(-r.external_halflength, 3.0), 3.0, epsilon = 1.0e-5);
|
||||
|
||||
assert_abs_diff_eq!(r.u(r.x(1.0)), 1.0, epsilon = 1.0e-5);
|
||||
assert_abs_diff_eq!(r.u(r.x(5.0)), 5.0, epsilon = 1.0e-5);
|
||||
assert_abs_diff_eq!(r.u(r.x(-5.0)), -5.0, epsilon = 1.0e-5);
|
||||
assert_abs_diff_eq!(r.u(r.x(10.0)), 10.0, epsilon = 1.0e-5);
|
||||
assert_abs_diff_eq!(r.x(r.u(10.0)), 10.0, epsilon = 1.0e-5);
|
||||
assert_abs_diff_eq!(r.x(r.u(50.0)), 50.0, epsilon = 1.0e-5);
|
||||
assert_abs_diff_eq!(r.x(r.u(-50.0)), -50.0, epsilon = 1.0e-5);
|
||||
assert_abs_diff_eq!(r.x(r.u(100.0)), 100.0, epsilon = 1.0e-5);
|
||||
assert_abs_diff_eq!(r.d(r.u(10.0)), r.root(10.0), epsilon = 1.0e-5);
|
||||
assert_abs_diff_eq!(r.d(r.u(50.0)), r.root(50.0), epsilon = 1.0e-5);
|
||||
assert_abs_diff_eq!(r.d(r.u(100.0)), r.root(100.0), epsilon = 1.0e-5);
|
||||
assert_abs_diff_eq!(r.du(10.0, r.dx(r.u(10.0), 3.0)), 3.0, epsilon = 1.0e-5);
|
||||
assert_abs_diff_eq!(r.du(50.0, r.dx(r.u(50.0), 3.0)), 3.0, epsilon = 1.0e-5);
|
||||
assert_abs_diff_eq!(r.du(-50.0, r.dx(r.u(-50.0), 3.0)), 3.0, epsilon = 1.0e-5);
|
||||
assert_abs_diff_eq!(r.du(100.0, r.dx(r.u(100.0), 3.0)), 3.0, epsilon = 1.0e-5);
|
||||
assert_abs_diff_eq!(r.dx(1.0, r.du(r.x(1.0), 3.0)), 3.0, epsilon = 1.0e-5);
|
||||
assert_abs_diff_eq!(r.dx(5.0, r.du(r.x(5.0), 3.0)), 3.0, epsilon = 1.0e-5);
|
||||
assert_abs_diff_eq!(r.dx(-5.0, r.du(r.x(-5.0), 3.0)), 3.0, epsilon = 1.0e-5);
|
||||
assert_abs_diff_eq!(r.dx(10.0, r.du(r.x(10.0), 3.0)), 3.0, epsilon = 1.0e-5);
|
||||
scale: f32,
|
||||
r: Vec2,
|
||||
m: Vec2,
|
||||
}
|
||||
|
||||
impl Metric for Rect {
|
||||
fn halfmetric(&self, pos: Vec2) -> Decomp2 {
|
||||
let x = pos.y.abs();
|
||||
let sx = ((pos.x.abs() - self.inner_radius) / (self.outer_radius - self.inner_radius)).clamp(0.0, 1.0);
|
||||
let sy = if x <= self.external_halflength { 1.0 / self.root(x) } else { 1.0 };
|
||||
assert!(sx.is_finite());
|
||||
assert!(sy.is_finite());
|
||||
assert!(sy > 0.0);
|
||||
let s = smoothbox(pos.x, vec2(-self.r.x, self.r.x), self.m.x) * smoothbox(pos.y, vec2(-self.r.y, self.r.y), self.m.y);
|
||||
Decomp2 {
|
||||
ortho: Mat2::IDENTITY,
|
||||
diag: vec2(1.0, sy.lerp(1.0, sx)),
|
||||
diag: vec2(1.0, self.scale.powf(-s)),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -328,20 +229,11 @@ struct Inside {
|
|||
|
||||
impl boundary::Boundary for Outside {
|
||||
fn next(&self, base: Vec2, dir: Vec2, limit: f32) -> Option<(boundary::Id, Vec2, Vec2)> {
|
||||
let or = self.space.outer_radius;
|
||||
let ir = self.space.inner_radius;
|
||||
let hl = self.space.external_halflength;
|
||||
let bnd = Loop(vec![
|
||||
vec2(-or, -hl), vec2(-ir, -hl), vec2(ir, -hl), vec2(or, -hl),
|
||||
vec2(or, hl), vec2(ir, hl), vec2(-ir, hl), vec2(-or, hl),
|
||||
]);
|
||||
let (side, dist) = bnd.hit(base, dir)?;
|
||||
let size = self.space.r + self.space.m;
|
||||
let bnd = Loop(vec![vec2(-size.x, -size.y), vec2(size.x, -size.y), vec2(size.x, size.y), vec2(-size.x, size.y)]);
|
||||
let (_, dist) = bnd.hit(base, dir)?;
|
||||
if dist <= limit {
|
||||
let pt = base + dist * dir;
|
||||
return match side {
|
||||
1 | 5 => Some((boundary::Id(2), vec2(pt.x, self.space.u(pt.y)), vec2(dir.x, self.space.du(pt.y, dir.y)))),
|
||||
_ => Some((boundary::Id(1), pt, dir)),
|
||||
};
|
||||
return Some((boundary::Id(1), base + dist * dir, dir));
|
||||
}
|
||||
None
|
||||
}
|
||||
|
|
@ -355,17 +247,16 @@ impl Metric for Outside {
|
|||
|
||||
impl boundary::Boundary for Wall {
|
||||
fn next(&self, base: Vec2, dir: Vec2, limit: f32) -> Option<(boundary::Id, Vec2, Vec2)> {
|
||||
let or = self.space.outer_radius;
|
||||
let ir = self.space.inner_radius;
|
||||
let hl = self.space.external_halflength;
|
||||
let obnd = Loop(vec![vec2(-or, -hl), vec2(-or, hl), vec2(or, hl), vec2(or, -hl)]);
|
||||
let ibnd = Loop(vec![vec2(-ir, -hl), vec2(ir, -hl), vec2(ir, hl), vec2(-ir, hl)]);
|
||||
let osize = self.space.r + self.space.m;
|
||||
let isize = self.space.r;
|
||||
let obnd = Loop(vec![vec2(-osize.x, -osize.y), vec2(-osize.x, osize.y), vec2(osize.x, osize.y), vec2(osize.x, -osize.y)]);
|
||||
let ibnd = Loop(vec![vec2(-isize.x, -isize.y), vec2(isize.x, -isize.y), vec2(isize.x, isize.y), vec2(-isize.x, isize.y)]);
|
||||
if let Some((_, dist)) = ibnd.hit(base, dir) {
|
||||
if dist <= limit {
|
||||
let p = base + dist * dir;
|
||||
let v = dir;
|
||||
let v = vec2(v.x, self.space.du(p.y, v.y));
|
||||
let p = vec2(p.x, self.space.u(p.y));
|
||||
let p = vec2(p.x, p.y / self.space.scale);
|
||||
let v = vec2(v.x, v.y / self.space.scale);
|
||||
return Some((boundary::Id(2), p, v));
|
||||
}
|
||||
}
|
||||
|
|
@ -386,19 +277,16 @@ impl Metric for Wall {
|
|||
|
||||
impl boundary::Boundary for Inside {
|
||||
fn next(&self, base: Vec2, dir: Vec2, limit: f32) -> Option<(boundary::Id, Vec2, Vec2)> {
|
||||
let size = vec2(self.space.inner_radius, self.space.internal_halflength);
|
||||
let size = self.space.r;
|
||||
let size = vec2(size.x, size.y / self.space.scale);
|
||||
let bnd = Loop(vec![vec2(-size.x, -size.y), vec2(-size.x, size.y), vec2(size.x, size.y), vec2(size.x, -size.y)]);
|
||||
let (side, dist) = bnd.hit(base, dir)?;
|
||||
let (_, dist) = bnd.hit(base, dir)?;
|
||||
if dist <= limit {
|
||||
let p = base + dist * dir;
|
||||
let v = dir;
|
||||
let v = vec2(v.x, self.space.dx(p.y, v.y));
|
||||
let p = vec2(p.x, self.space.x(p.y));
|
||||
return match side {
|
||||
0 | 2 => Some((boundary::Id(1), p, v)),
|
||||
1 | 3 => Some((boundary::Id(0), p, v)),
|
||||
_ => panic!()
|
||||
};
|
||||
let p = vec2(p.x, p.y * self.space.scale);
|
||||
let v = vec2(v.x, v.y * self.space.scale);
|
||||
return Some((boundary::Id(1), p, v));
|
||||
}
|
||||
None
|
||||
}
|
||||
|
|
@ -602,15 +490,10 @@ fn smoothstep(x: f32) -> f32 {
|
|||
3.0 * x * x - 2.0 * x * x * x
|
||||
}
|
||||
|
||||
/// 1.0 for val∈[range.x, range.y], 0.0 for val∉[range.x−pad, range.y+pad], linear in-between.
|
||||
fn trapezoid(val: f32, range: Vec2, pad: f32) -> f32 {
|
||||
/// 1.0 for val∈[range.x, range.y], 0.0 for val∉[range.x−pad, range.y+pad], smoothstep in-between.
|
||||
fn smoothbox(val: f32, range: Vec2, pad: f32) -> f32 {
|
||||
let slope1 = 1.0 + (val - range.x) / pad;
|
||||
let slope2 = 1.0 - (val - range.y) / pad;
|
||||
let lin = slope1.min(slope2);
|
||||
lin.clamp(0.0, 1.0)
|
||||
}
|
||||
|
||||
/// 1.0 for val∈[range.x, range.y], 0.0 for val∉[range.x−pad, range.y+pad], smoothstep in-between.
|
||||
fn smoothbox(val: f32, range: Vec2, pad: f32) -> f32 {
|
||||
smoothstep(trapezoid(val, range, pad))
|
||||
smoothstep(lin.clamp(0.0, 1.0))
|
||||
}
|
||||
|
|
|
|||
Loading…
Reference in New Issue
Block a user