├── .gitignore
├── Cargo.toml
├── assets
    └── models
    │   ├── BoxTextured.glb
    │   ├── Lantern.glb
    │   ├── cube.bin
    │   └── cube.gltf
└── src
    ├── anima
        ├── actions.rs
        ├── animation.rs
        ├── armature.rs
        ├── asset
        │   └── mod.rs
        ├── controller.rs
        ├── example.rs
        ├── gizmo.rs
        ├── grid.rs
        ├── mod.rs
        ├── runtime
        │   ├── animation.rs
        │   ├── armature.rs
        │   ├── math.rs
        │   └── mod.rs
        ├── timeline.rs
        └── viewport.rs
    ├── main.rs
    ├── scene
        ├── asset.rs
        ├── component
        │   ├── editor.rs
        │   ├── handle.rs
        │   ├── light.rs
        │   ├── meta.rs
        │   ├── mod.rs
        │   ├── proxy.rs
        │   └── transform.rs
        ├── context.rs
        ├── filebrowser.rs
        ├── gizmo.rs
        ├── gizmo.wgsl
        ├── hierarchy.rs
        ├── inspector.rs
        ├── mod.rs
        └── tab.rs
    ├── ui
        ├── app.rs
        ├── field.rs
        ├── icon.rs
        ├── icon.ttf
        ├── mod.rs
        ├── placeholder.rs
        ├── shell
        │   ├── clipboard.rs
        │   ├── convert.rs
        │   ├── mod.rs
        │   ├── node.rs
        │   ├── render.rs
        │   ├── shader.wgsl
        │   ├── systems.rs
        │   └── tests.rs
        ├── style.rs
        └── tabs.rs
    ├── util.rs
    ├── util
        ├── anymap.rs
        ├── reflect.rs
        └── slice.rs
    └── workspace
        ├── builder.rs
        ├── builder
            ├── expr.rs
            └── types.rs
        ├── builtin.wgsl
        ├── graph.rs
        ├── link.rs
        ├── mod.rs
        ├── node.rs
        ├── nodes.rs
        ├── nodes
            ├── builtin.rs
            ├── channel.rs
            ├── input.rs
            ├── logic.rs
            ├── master.rs
            ├── math.rs
            ├── util.rs
            └── uv.rs
        ├── port.rs
        └── preview.rs


/.gitignore:
--------------------------------------------------------------------------------
1 | /target
2 | Cargo.lock


--------------------------------------------------------------------------------
/Cargo.toml:
--------------------------------------------------------------------------------
 1 | [package]
 2 | name = "shaderlab"
 3 | version = "0.1.0"
 4 | edition = "2021"
 5 | 
 6 | [dependencies]
 7 | reui = { version = "0.0.1", features = ["bevy"] }
 8 | 
 9 | bitflags = "1"
10 | slotmap = "1"
11 | arrayvec = "0.7"
12 | 
13 | async-executor = "1.4"
14 | pollster = "0.2"
15 | egui = { version = "0.18.1", features = ["bytemuck"] }
16 | egui-winit = "0.18"
17 | winit = "0.26.1"
18 | webbrowser = "0.7.0"
19 | 
20 | bytemuck = "1.9"
21 | 
22 | wgpu = "0.13"
23 | naga = { version = "0.9", features = ["wgsl-in", "wgsl-out"] }
24 | downcast-rs = "1.2"
25 | 
26 | tracing = "0.1"
27 | tracing-subscriber = { version = "0.3", features = ["env-filter"] }
28 | 
29 | ahash = "0.8.0"
30 | sublime_fuzzy = "0.7.0"
31 | 
32 | undo = "0.47"
33 | 
34 | bevy = "0.8.0"
35 | 
36 | smallvec = "1"
37 | 
38 | anyhow = "1.0"
39 | thiserror = "1.0"
40 | serde = "1"
41 | uuid = { version = "1", features = ["v4", "serde"] }
42 | ron = "0.8"
43 | 
44 | [target.'cfg(not(target_arch = "wasm32"))'.dependencies]
45 | arboard = "2.0.1"
46 | thread_local = "1.1.0"
47 | 
48 | [profile.dev]
49 | opt-level = 1
50 | 
51 | [profile.dev.package]
52 | wgpu = { opt-level = 3 }
53 | naga = { opt-level = 3 }
54 | winit = { opt-level = 3 }
55 | egui = { opt-level = 3 }
56 | bevy = { opt-level = 3 }
57 | 


--------------------------------------------------------------------------------
/assets/models/BoxTextured.glb:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/lain-dono/shaderlab/fb496dc0178b955330c1cd4a8590c44b4a9b9cd9/assets/models/BoxTextured.glb


--------------------------------------------------------------------------------
/assets/models/Lantern.glb:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/lain-dono/shaderlab/fb496dc0178b955330c1cd4a8590c44b4a9b9cd9/assets/models/Lantern.glb


--------------------------------------------------------------------------------
/assets/models/cube.bin:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/lain-dono/shaderlab/fb496dc0178b955330c1cd4a8590c44b4a9b9cd9/assets/models/cube.bin


--------------------------------------------------------------------------------
/assets/models/cube.gltf:
--------------------------------------------------------------------------------
  1 | {
  2 |     "asset" : {
  3 |         "generator" : "Khronos glTF Blender I/O v1.1.46",
  4 |         "version" : "2.0"
  5 |     },
  6 |     "scene" : 0,
  7 |     "scenes" : [
  8 |         {
  9 |             "name" : "Scene",
 10 |             "nodes" : [
 11 |                 0
 12 |             ]
 13 |         }
 14 |     ],
 15 |     "nodes" : [
 16 |         {
 17 |             "mesh" : 0,
 18 |             "name" : "Cube"
 19 |         }
 20 |     ],
 21 |     "materials" : [
 22 |         {
 23 |             "doubleSided" : true,
 24 |             "emissiveFactor" : [
 25 |                 0,
 26 |                 0,
 27 |                 0
 28 |             ],
 29 |             "name" : "Material",
 30 |             "pbrMetallicRoughness" : {
 31 |                 "baseColorFactor" : [
 32 |                     0.800000011920929,
 33 |                     0.800000011920929,
 34 |                     0.800000011920929,
 35 |                     1
 36 |                 ],
 37 |                 "metallicFactor" : 0,
 38 |                 "roughnessFactor" : 0.4000000059604645
 39 |             }
 40 |         }
 41 |     ],
 42 |     "meshes" : [
 43 |         {
 44 |             "name" : "Cube",
 45 |             "primitives" : [
 46 |                 {
 47 |                     "attributes" : {
 48 |                         "POSITION" : 0,
 49 |                         "NORMAL" : 1,
 50 |                         "TEXCOORD_0" : 2
 51 |                     },
 52 |                     "indices" : 3,
 53 |                     "material" : 0
 54 |                 }
 55 |             ]
 56 |         }
 57 |     ],
 58 |     "accessors" : [
 59 |         {
 60 |             "bufferView" : 0,
 61 |             "componentType" : 5126,
 62 |             "count" : 24,
 63 |             "max" : [
 64 |                 1,
 65 |                 1,
 66 |                 1
 67 |             ],
 68 |             "min" : [
 69 |                 -1,
 70 |                 -1,
 71 |                 -1
 72 |             ],
 73 |             "type" : "VEC3"
 74 |         },
 75 |         {
 76 |             "bufferView" : 1,
 77 |             "componentType" : 5126,
 78 |             "count" : 24,
 79 |             "type" : "VEC3"
 80 |         },
 81 |         {
 82 |             "bufferView" : 2,
 83 |             "componentType" : 5126,
 84 |             "count" : 24,
 85 |             "type" : "VEC2"
 86 |         },
 87 |         {
 88 |             "bufferView" : 3,
 89 |             "componentType" : 5123,
 90 |             "count" : 36,
 91 |             "type" : "SCALAR"
 92 |         }
 93 |     ],
 94 |     "bufferViews" : [
 95 |         {
 96 |             "buffer" : 0,
 97 |             "byteLength" : 288,
 98 |             "byteOffset" : 0
 99 |         },
100 |         {
101 |             "buffer" : 0,
102 |             "byteLength" : 288,
103 |             "byteOffset" : 288
104 |         },
105 |         {
106 |             "buffer" : 0,
107 |             "byteLength" : 192,
108 |             "byteOffset" : 576
109 |         },
110 |         {
111 |             "buffer" : 0,
112 |             "byteLength" : 72,
113 |             "byteOffset" : 768
114 |         }
115 |     ],
116 |     "buffers" : [
117 |         {
118 |             "byteLength" : 840,
119 |             "uri" : "cube.bin"
120 |         }
121 |     ]
122 | }
123 | 


--------------------------------------------------------------------------------
/src/anima/actions.rs:
--------------------------------------------------------------------------------
 1 | use super::{Armature, Transform};
 2 | 
 3 | pub struct TransformBone {
 4 |     pub bone: usize,
 5 |     pub transform: Transform,
 6 | }
 7 | 
 8 | impl undo::Action for TransformBone {
 9 |     type Target = Armature;
10 |     type Output = ();
11 |     type Error = ();
12 | 
13 |     fn apply(&mut self, target: &mut Self::Target) -> undo::Result<Self> {
14 |         let bone = &mut target.bones[self.bone];
15 |         bone.transform = bone.transform.mul_transform(self.transform);
16 |         Ok(())
17 |     }
18 | 
19 |     fn undo(&mut self, target: &mut Self::Target) -> undo::Result<Self> {
20 |         let bone = &mut target.bones[self.bone];
21 |         bone.transform = bone.transform.mul_transform(self.transform.inverse());
22 |         Ok(())
23 |     }
24 | }
25 | 


--------------------------------------------------------------------------------
/src/anima/animation.rs:
--------------------------------------------------------------------------------
  1 | use super::Transform;
  2 | use egui::Vec2;
  3 | use std::ops::{Add, Mul};
  4 | 
  5 | #[derive(Clone, Copy)]
  6 | pub enum Interpolation<T> {
  7 |     Linear,
  8 |     Spline(T, T),
  9 | }
 10 | 
 11 | pub struct Animation {
 12 |     pub name: String,
 13 |     pub bones: Vec<BoneTimeline>,
 14 | }
 15 | 
 16 | impl Animation {
 17 |     pub fn duration(&self) -> u32 {
 18 |         self.bones
 19 |             .iter()
 20 |             .filter_map(|f| f.keys.last().copied())
 21 |             .max()
 22 |             .unwrap_or(0)
 23 |     }
 24 | 
 25 |     pub fn resolve_bone_tranform(&self, bone_index: usize, time: f32) -> Transform {
 26 |         self.bones
 27 |             .get(bone_index)
 28 |             .map(|clip| clip.resolve(time))
 29 |             .unwrap_or_default()
 30 |     }
 31 | }
 32 | 
 33 | pub struct Keyframe<T> {
 34 |     pub time: u32,
 35 |     pub curve: Interpolation<T>,
 36 |     pub value: T,
 37 | }
 38 | 
 39 | impl<T> Keyframe<T> {
 40 |     pub fn linear(time: u32, value: T) -> Self {
 41 |         Self {
 42 |             time,
 43 |             curve: Interpolation::Linear,
 44 |             value,
 45 |         }
 46 |     }
 47 | }
 48 | 
 49 | pub struct BoneTimeline {
 50 |     pub label: String,
 51 |     pub open: bool,
 52 | 
 53 |     pub keys: Vec<u32>,
 54 | 
 55 |     pub rotate: Timeline<f32>,
 56 |     pub translate: Timeline<Vec2>,
 57 |     pub scale: Timeline<Vec2>,
 58 |     pub shear: Timeline<Vec2>,
 59 | }
 60 | 
 61 | impl BoneTimeline {
 62 |     pub fn update_keys(&mut self) {
 63 |         self.keys.clear();
 64 | 
 65 |         self.keys.extend(self.rotate.time_iter());
 66 |         self.keys.extend(self.translate.time_iter());
 67 |         self.keys.extend(self.scale.time_iter());
 68 |         self.keys.extend(self.shear.time_iter());
 69 | 
 70 |         self.keys.dedup();
 71 |         self.keys.sort_unstable()
 72 |     }
 73 | 
 74 |     pub fn resolve(&self, time: f32) -> Transform {
 75 |         let rotate = self.rotate.resolve_or(time, 0.0);
 76 |         let translate = self.translate.resolve_or(time, Vec2::new(0.0, 0.0));
 77 |         let scale = self.scale.resolve_or(time, Vec2::new(1.0, 1.0));
 78 |         let shear = self.shear.resolve_or(time, Vec2::new(0.0, 0.0));
 79 |         let translate = translate.to_pos2();
 80 | 
 81 |         Transform {
 82 |             rotate,
 83 |             translate,
 84 |             scale,
 85 |             shear,
 86 |         }
 87 |     }
 88 | }
 89 | 
 90 | pub trait TimelineValue: Copy + Mul<f32, Output = Self> + Add<Self, Output = Self> {
 91 |     #[inline]
 92 |     fn linear(p0: Self, p1: Self, t: f32) -> Self {
 93 |         p0 * (1.0 - t) + p1 * t
 94 |     }
 95 | 
 96 |     #[inline]
 97 |     fn spline(p0: Self, p1: Self, p2: Self, p3: Self, t: f32) -> Self {
 98 |         let h = 1.0 - t;
 99 |         let p0 = p0 * (h * h * h);
100 |         let p1 = p1 * (t * h * h * 3.0);
101 |         let p2 = p2 * (t * t * h * 3.0);
102 |         let p3 = p3 * (t * t * t);
103 |         p0 + p1 + p2 + p3
104 |     }
105 | }
106 | 
107 | impl<T> TimelineValue for T where T: Copy + Mul<f32, Output = T> + Add<T, Output = T> {}
108 | 
109 | pub struct Timeline<T> {
110 |     frames: Vec<Keyframe<T>>,
111 | }
112 | 
113 | impl<T: TimelineValue> Timeline<T> {
114 |     pub fn new(frames: Vec<Keyframe<T>>) -> Self {
115 |         Self { frames }
116 |     }
117 | 
118 |     pub fn get(&self, index: usize) -> (u32, Interpolation<T>, Option<u32>) {
119 |         let curr = &self.frames[index];
120 |         let next = self.frames.get(index + 1).map(|key| key.time);
121 |         (curr.time, curr.curve, next)
122 |     }
123 | 
124 |     pub fn add(&mut self, key: Keyframe<T>) {
125 |         self.frames.push(key);
126 |         self.frames.sort_by_key(|k| k.time);
127 |     }
128 | 
129 |     pub fn remove(&mut self, time: u32) {
130 |         self.frames.retain(|k| k.time != time);
131 |     }
132 | 
133 |     pub fn len(&self) -> usize {
134 |         self.frames.len()
135 |     }
136 | 
137 |     pub fn is_empty(&self) -> bool {
138 |         self.frames.is_empty()
139 |     }
140 | 
141 |     pub fn find(&self, time: f32) -> Option<&Keyframe<T>> {
142 |         self.find_pair(time).map(|[a, _]| a)
143 |     }
144 | 
145 |     pub fn at(&self, time: u32) -> Option<&Keyframe<T>> {
146 |         self.frames.iter().find(|a| a.time == time)
147 |     }
148 | 
149 |     pub fn find_pair(&self, time: f32) -> Option<&[Keyframe<T>; 2]> {
150 |         let frame = time.floor() as u32;
151 | 
152 |         crate::util::slice::array_windows(&self.frames)
153 |             .find(|&[a, b]| a.time <= frame && frame < b.time)
154 |     }
155 | 
156 |     pub fn resolve(&self, time: f32) -> Option<T> {
157 |         self.find_pair(time).map(|[a, b]| {
158 |             let (p0, p3) = (a.value, b.value);
159 |             let (t0, t1) = (a.time as f32, b.time as f32);
160 |             let t = (time - t0) / (t1 - t0);
161 |             match a.curve {
162 |                 Interpolation::Linear => TimelineValue::linear(p0, p3, t),
163 |                 Interpolation::Spline(p1, p2) => TimelineValue::spline(p0, p1, p2, p3, t),
164 |             }
165 |         })
166 |     }
167 | 
168 |     pub fn resolve_or(&self, time: f32, default: T) -> T {
169 |         self.resolve(time)
170 |             .or_else(|| self.frames.last().map(|a| a.value))
171 |             .unwrap_or(default)
172 |     }
173 | 
174 |     pub fn time_iter(&self) -> impl Iterator<Item = u32> + '_ {
175 |         self.frames.iter().map(|k| k.time)
176 |     }
177 | }
178 | 


--------------------------------------------------------------------------------
/src/anima/armature.rs:
--------------------------------------------------------------------------------
  1 | use super::runtime::armature::Armature;
  2 | use super::{Controller, GridViewport};
  3 | use egui::*;
  4 | 
  5 | pub fn paint_bones(
  6 |     ui: &mut Ui,
  7 |     viewport: GridViewport,
  8 |     armature: &Armature,
  9 |     controller: &Controller,
 10 |     shapes: &mut Vec<Shape>,
 11 | ) -> Option<usize> {
 12 |     let px = ui.ctx().pixels_per_point().recip();
 13 |     let mut hovered = None;
 14 | 
 15 |     for (index, (bone, &transform)) in armature
 16 |         .bones
 17 |         .iter()
 18 |         .zip(&controller.local_to_screen)
 19 |         .enumerate()
 20 |     {
 21 |         let [b, g, r, a] = bone.color.to_le_bytes();
 22 |         let color = Color32::from_rgba_unmultiplied(r, g, b, a);
 23 |         let length = bone.length;
 24 | 
 25 |         let extra = vec2(length * 0.2, length * 0.1);
 26 |         let outer_radius = (viewport.zoom * length * 0.075).max(2.0);
 27 |         let inner_radius = outer_radius * 0.8;
 28 | 
 29 |         let a = transform.apply(0.0, 0.0).into();
 30 |         let b = transform.apply(extra.x, -extra.y).into();
 31 |         let c = transform.apply(length, 0.0).into();
 32 |         let d = transform.apply(extra.x, extra.y).into();
 33 | 
 34 |         let points = vec![a, b, c, d];
 35 | 
 36 |         let distance = Pos2::distance(b, d);
 37 |         let is_hovered = check_distance([a, c], viewport.pointer, distance);
 38 |         let is_selected = Some(index) == controller.selected;
 39 | 
 40 |         if is_hovered {
 41 |             hovered = Some(index);
 42 |         }
 43 | 
 44 |         let stroke = if is_selected || is_hovered {
 45 |             Stroke::new(px, Color32::WHITE)
 46 |         } else {
 47 |             Stroke::default()
 48 |         };
 49 | 
 50 |         let path = epaint::PathShape::convex_polygon(points, color, stroke);
 51 |         shapes.push(Shape::Path(path));
 52 |         shapes.push(Shape::circle_filled(a, outer_radius, color));
 53 |         shapes.push(Shape::circle_filled(a, inner_radius, Color32::BLACK));
 54 | 
 55 |         if let Some(parent) = armature.bones.get(bone.parent as usize) {
 56 |             let stroke = Stroke::new(px, Color32::RED);
 57 | 
 58 |             let parent_transform = controller.local_to_screen[bone.parent as usize];
 59 |             let src: Pos2 = parent_transform.apply(parent.length / 2.0, 0.0).into();
 60 |             let dst: Pos2 = transform.apply(length / 2.0, 0.0).into();
 61 |             parent_arrow(shapes, src, dst, stroke, viewport.zoom);
 62 |         }
 63 |     }
 64 | 
 65 |     hovered
 66 | }
 67 | 
 68 | fn check_distance([a, b]: [Pos2; 2], pointer: Option<Pos2>, distance: f32) -> bool {
 69 |     if let Some(pointer) = pointer {
 70 |         let diff = b - a;
 71 |         let len_sq = diff.length_sq();
 72 |         if len_sq <= 0.0 {
 73 |             pointer.distance(a) < distance
 74 |         } else {
 75 |             let t = Vec2::dot(pointer - a, diff) / len_sq;
 76 |             let projection = a + diff * t.clamp(0.0, 1.0);
 77 |             pointer.distance(projection) < distance
 78 |         }
 79 |     } else {
 80 |         false
 81 |     }
 82 | }
 83 | 
 84 | fn parent_arrow(shapes: &mut Vec<Shape>, src: Pos2, dst: Pos2, stroke: Stroke, zoom: f32) {
 85 |     use egui::emath::*;
 86 |     let rot = Rot2::from_angle(std::f32::consts::TAU / 10.0);
 87 |     let len = 8.0 * zoom;
 88 |     let dir = (dst - src).normalized();
 89 |     let (dash, gap) = (4.0, 2.0);
 90 |     shapes.extend(Shape::dashed_line(&[src, dst], stroke, dash, gap));
 91 |     shapes.push(Shape::LineSegment {
 92 |         points: [dst, dst - len * (rot * dir)],
 93 |         stroke,
 94 |     });
 95 |     shapes.push(Shape::LineSegment {
 96 |         points: [dst, dst - len * (rot.inverse() * dir)],
 97 |         stroke,
 98 |     });
 99 | }
100 | 


--------------------------------------------------------------------------------
/src/anima/asset/mod.rs:
--------------------------------------------------------------------------------
1 | 
2 | 


--------------------------------------------------------------------------------
/src/anima/controller.rs:
--------------------------------------------------------------------------------
 1 | use super::Matrix;
 2 | 
 3 | pub enum PlayControl {
 4 |     First,
 5 |     Prev,
 6 |     PlayReverse,
 7 |     Pause,
 8 |     Play,
 9 |     Next,
10 |     Last,
11 | }
12 | 
13 | #[derive(Clone, Copy)]
14 | pub enum PlayState {
15 |     Stop,
16 |     Play,
17 |     PlayReverse,
18 | }
19 | 
20 | impl Default for PlayState {
21 |     fn default() -> Self {
22 |         Self::Stop
23 |     }
24 | }
25 | 
26 | #[derive(Default)]
27 | pub struct Controller {
28 |     pub current_time: u32,
29 |     //pub max_time: u32,
30 |     pub selected: Option<usize>,
31 | 
32 |     pub state: PlayState,
33 | 
34 |     pub local_to_world: Vec<Matrix>,
35 |     pub local_to_screen: Vec<Matrix>,
36 | }
37 | 
38 | impl Controller {
39 |     pub fn is_playing(&self) -> bool {
40 |         matches!(self.state, PlayState::Play | PlayState::PlayReverse)
41 |     }
42 | 
43 |     pub fn action(&mut self, control: PlayControl, max_time: u32) {
44 |         match control {
45 |             PlayControl::First => self.current_time = 0,
46 |             PlayControl::Prev if self.current_time > 0 => self.current_time -= 1,
47 |             PlayControl::Prev => self.current_time = max_time,
48 | 
49 |             PlayControl::PlayReverse => self.state = PlayState::PlayReverse,
50 |             PlayControl::Play => self.state = PlayState::Play,
51 |             PlayControl::Pause => self.state = PlayState::Stop,
52 | 
53 |             PlayControl::Next if self.current_time < max_time => self.current_time += 1,
54 |             PlayControl::Next => self.current_time = 0,
55 |             PlayControl::Last => self.current_time = max_time,
56 |         }
57 |     }
58 | 
59 |     pub fn world_to_screen(&mut self, screen: Matrix) {
60 |         let iter = self
61 |             .local_to_world
62 |             .iter()
63 |             .map(|&world| screen.prepend(world));
64 | 
65 |         self.local_to_screen.clear();
66 |         self.local_to_screen.extend(iter);
67 |     }
68 | }
69 | 


--------------------------------------------------------------------------------
/src/anima/example.rs:
--------------------------------------------------------------------------------
 1 | use super::{
 2 |     runtime::Transform, Animation, Armature, Bone, BoneTimeline, Interpolation, Keyframe, Timeline,
 3 | };
 4 | use egui::*;
 5 | 
 6 | pub fn armature() -> Armature {
 7 |     Armature {
 8 |         slots: vec![],
 9 |         bones: vec![
10 |             Bone {
11 |                 transform: Transform {
12 |                     translate: pos2(100.0, 30.0),
13 |                     ..Default::default()
14 |                 },
15 |                 length: 50.0,
16 |                 color: 0x99_00EECC,
17 |                 ..Default::default()
18 |             },
19 |             Bone {
20 |                 transform: Transform {
21 |                     translate: pos2(50.0, 0.0),
22 |                     ..Default::default()
23 |                 },
24 |                 length: 50.0,
25 |                 color: 0x99_EE00CC,
26 |                 parent: 0,
27 |                 ..Default::default()
28 |             },
29 |             Bone {
30 |                 transform: Transform {
31 |                     translate: pos2(50.0, 0.0),
32 |                     ..Default::default()
33 |                 },
34 |                 length: 50.0,
35 |                 color: 0x99_00EECC,
36 |                 parent: 1,
37 |                 ..Default::default()
38 |             },
39 |         ],
40 |     }
41 | }
42 | 
43 | pub fn animation() -> Animation {
44 |     let bones = vec![
45 |         BoneTimeline {
46 |             label: String::from("bone0"),
47 |             open: false,
48 |             keys: vec![],
49 |             translate: Timeline::new(vec![]),
50 |             rotate: Timeline::new(vec![
51 |                 Keyframe {
52 |                     time: 0,
53 |                     curve: Interpolation::Linear,
54 |                     value: 0.0,
55 |                 },
56 |                 Keyframe {
57 |                     time: 5,
58 |                     curve: Interpolation::Linear,
59 |                     value: std::f32::consts::FRAC_PI_2,
60 |                 },
61 |                 Keyframe {
62 |                     time: 8,
63 |                     curve: Interpolation::Linear,
64 |                     value: std::f32::consts::PI,
65 |                 },
66 |             ]),
67 |             scale: Timeline::new(vec![]),
68 |             shear: Timeline::new(vec![]),
69 |         },
70 |         BoneTimeline {
71 |             label: String::from("bone1"),
72 |             open: false,
73 |             keys: vec![],
74 |             translate: Timeline::new(vec![]),
75 |             rotate: Timeline::new(vec![]),
76 |             scale: Timeline::new(vec![]),
77 |             shear: Timeline::new(vec![]),
78 |         },
79 |         BoneTimeline {
80 |             label: String::from("bone2"),
81 |             open: false,
82 |             keys: vec![],
83 |             translate: Timeline::new(vec![]),
84 |             rotate: Timeline::new(vec![]),
85 |             scale: Timeline::new(vec![]),
86 |             shear: Timeline::new(vec![]),
87 |         },
88 |     ];
89 | 
90 |     let name = String::from("some animation");
91 | 
92 |     Animation { name, bones }
93 | }
94 | 


--------------------------------------------------------------------------------
/src/anima/gizmo.rs:
--------------------------------------------------------------------------------
  1 | use std::f32::consts::PI;
  2 | 
  3 | use reui::{plugin::Recorder, Color, FillRule, Offset, Path, Solidity, Stroke, Transform};
  4 | 
  5 | pub enum Tool {}
  6 | 
  7 | pub struct Gizmos<'a> {
  8 |     pub recorder: &'a mut Recorder,
  9 |     pub viewport: Transform,
 10 |     pub transform: Transform,
 11 |     pub path: Path,
 12 | }
 13 | 
 14 | impl<'a> Gizmos<'a> {
 15 |     pub fn new(recorder: &'a mut Recorder, viewport: Transform) -> Self {
 16 |         Self {
 17 |             recorder,
 18 |             viewport,
 19 |             transform: viewport,
 20 |             path: Path::new(),
 21 |         }
 22 |     }
 23 | 
 24 |     pub fn set_transform(&mut self, tx: f32, ty: f32, rotation: f32, scale: f32) {
 25 |         self.transform = self.viewport * Transform::compose(tx, ty, rotation, scale);
 26 |     }
 27 | 
 28 |     pub fn rotate(&mut self, color: Color) {
 29 |         use std::f32::consts::TAU;
 30 | 
 31 |         let a = f32::to_radians(10.0);
 32 |         let b = f32::to_radians(14.0);
 33 | 
 34 |         let inner_radius = 19.0;
 35 |         let outer_radius = 23.0;
 36 | 
 37 |         let center = Offset::zero();
 38 | 
 39 |         self.path.clear();
 40 |         self.path
 41 |             .arc(center, outer_radius, b, TAU - b, Solidity::Hole);
 42 |         self.path
 43 |             .arc(center, inner_radius, TAU - a, a, Solidity::Solid);
 44 | 
 45 |         self.path.move_to(Offset::new(outer_radius - 5.0, 0.0));
 46 |         self.path.line_to(Offset::new(outer_radius, 3.0));
 47 |         self.path.line_to(Offset::new(outer_radius + 5.0, 0.0));
 48 |         self.path.line_to(Offset::new(outer_radius, -3.0));
 49 |         self.path.close();
 50 | 
 51 |         self.shadow();
 52 |         self.fill(color);
 53 |     }
 54 | 
 55 |     pub fn arrow_translate(&mut self, color: Color) {
 56 |         let main = (10.0, 27.0, 28.0, 40.0);
 57 |         let cross = (5.0, 8.0);
 58 | 
 59 |         let control_a = Offset::new(20.0, -1.0);
 60 |         let control_b = Offset::new(20.0, 1.0);
 61 | 
 62 |         self.path.clear();
 63 |         self.path.move_to(Offset::new(main.3, 0.0));
 64 |         self.path.line_to(Offset::new(main.2, -cross.1));
 65 |         self.path.line_to(Offset::new(main.1, -cross.0));
 66 |         self.path.quad_to(control_a, Offset::new(main.0, -1.0));
 67 |         self.path.line_to(Offset::new(main.0, 1.0));
 68 |         self.path.quad_to(control_b, Offset::new(main.1, cross.0));
 69 |         self.path.line_to(Offset::new(main.2, cross.1));
 70 |         self.path.close();
 71 | 
 72 |         self.shadow();
 73 |         self.fill(color);
 74 |     }
 75 | 
 76 |     pub fn arrow_scale(&mut self, color: Color) {
 77 |         let main = (10.0, 27.0, 28.0, 40.0);
 78 |         let cross = (5.0, 8.0);
 79 | 
 80 |         let control_a = Offset::new(20.0, -1.0);
 81 |         let control_b = Offset::new(20.0, 1.0);
 82 | 
 83 |         self.path.clear();
 84 |         self.path.move_to(Offset::new(main.3, cross.1));
 85 |         self.path.line_to(Offset::new(main.3, -cross.1));
 86 |         self.path.line_to(Offset::new(main.2, -cross.1));
 87 |         self.path.line_to(Offset::new(main.1, -cross.0));
 88 |         self.path.quad_to(control_a, Offset::new(main.0, -1.0));
 89 |         self.path.line_to(Offset::new(main.0, 1.0));
 90 |         self.path.quad_to(control_b, Offset::new(main.1, cross.0));
 91 |         self.path.line_to(Offset::new(main.2, cross.1));
 92 |         self.path.close();
 93 | 
 94 |         self.shadow();
 95 |         self.fill(color);
 96 |     }
 97 | 
 98 |     pub fn length(&mut self, color: Color) {
 99 |         let inner_radius = 4.0;
100 |         let outer_radius = 5.0;
101 |         let extra_radius = 6.0;
102 | 
103 |         self.path.clear();
104 |         self.path.solidity(Solidity::Solid);
105 |         self.path.circle(Offset::zero(), outer_radius);
106 |         self.path.solidity(Solidity::Hole);
107 |         self.path.circle(Offset::zero(), inner_radius);
108 | 
109 |         self.path.move_to(Offset::new(11.0, 0.0));
110 |         self.path.line_to(Offset::new(extra_radius, 3.0));
111 |         self.path.quad_to(
112 |             Offset::new(extra_radius + 1.0, 0.0),
113 |             Offset::new(extra_radius, -3.0),
114 |         );
115 |         self.path.close();
116 | 
117 |         self.path.move_to(Offset::new(-11.0, 0.0));
118 |         self.path.line_to(Offset::new(-extra_radius, 3.0));
119 |         self.path.quad_to(
120 |             Offset::new(-extra_radius - 1.0, 0.0),
121 |             Offset::new(-extra_radius, -3.0),
122 |         );
123 |         self.path.close();
124 | 
125 |         self.shadow();
126 |         self.fill(color);
127 |     }
128 | 
129 |     pub fn pose(&mut self, color: Color) {
130 |         let inner_radius = 4.0;
131 |         let outer_radius = 5.0;
132 |         let extra_radius = 5.0;
133 |         let end = 9.0;
134 |         let cross = 2.0;
135 | 
136 |         self.path.clear();
137 |         self.path.solidity(Solidity::Solid);
138 | 
139 |         self.path.move_to(Offset::new(end, 0.0));
140 |         self.path.line_to(Offset::new(extra_radius, cross));
141 |         self.path.line_to(Offset::new(extra_radius, -cross));
142 | 
143 |         self.path.move_to(-Offset::new(end, 0.0));
144 |         self.path.line_to(-Offset::new(extra_radius, cross));
145 |         self.path.line_to(-Offset::new(extra_radius, -cross));
146 | 
147 |         self.path.move_to(Offset::new(0.0, end));
148 |         self.path.line_to(Offset::new(-cross, extra_radius));
149 |         self.path.line_to(Offset::new(cross, extra_radius));
150 | 
151 |         self.path.move_to(-Offset::new(0.0, end));
152 |         self.path.line_to(-Offset::new(-cross, extra_radius));
153 |         self.path.line_to(-Offset::new(cross, extra_radius));
154 | 
155 |         self.path.circle(Offset::zero(), outer_radius);
156 | 
157 |         self.path.solidity(Solidity::Hole);
158 |         self.path.circle(Offset::zero(), inner_radius);
159 | 
160 |         self.shadow();
161 |         self.fill(color);
162 |     }
163 | 
164 |     pub fn shear(&mut self, color: Color, value: f32) {
165 |         let min = 15.0;
166 |         let max = 60.0;
167 | 
168 |         let w = 1.0;
169 |         let s = 3.0;
170 | 
171 |         {
172 |             self.path.clear();
173 | 
174 |             self.path.move_to(Offset::new(0.0, 0.0));
175 |             let a = if value > 0.0 {
176 |                 (0.0, -value % PI)
177 |             } else {
178 |                 (-value % PI, 0.0)
179 |             };
180 |             self.path
181 |                 .arc(Offset::zero(), 38.0, a.0, a.1, Solidity::Solid);
182 |             self.path.close();
183 | 
184 |             let mut color = color;
185 |             color.alpha *= 0.25;
186 | 
187 |             self.fill(color);
188 | 
189 |             self.path.clear();
190 |             self.path.move_to(Offset::new(min, 0.0));
191 |             self.path.line_to(Offset::new(min + 1.0, 1.0));
192 |             self.path.line_to(Offset::new(48.0, 1.0));
193 |             self.path.line_to(Offset::new(48.0, -1.0));
194 |             self.path.line_to(Offset::new(min + 1.0, -1.0));
195 | 
196 |             self.fill(color);
197 |         }
198 | 
199 |         let tx = Transform::rotation(-value);
200 | 
201 |         self.path.clear();
202 | 
203 |         self.path.move_to(tx.apply(Offset::new(min, 0.0)));
204 | 
205 |         self.path.line_to(tx.apply(Offset::new(min + w, w)));
206 |         self.path.line_to(tx.apply(Offset::new(max, w)));
207 |         self.path.line_to(tx.apply(Offset::new(max + s, s)));
208 |         self.path.line_to(tx.apply(Offset::new(max + s * 2.0, 0.0)));
209 |         self.path.line_to(tx.apply(Offset::new(max + s, -s)));
210 |         self.path.line_to(tx.apply(Offset::new(max, -w)));
211 |         self.path.line_to(tx.apply(Offset::new(min + w, -w)));
212 | 
213 |         self.shadow();
214 |         self.fill(color);
215 |     }
216 | 
217 |     fn fill(&mut self, color: Color) {
218 |         self.recorder
219 |             .fill(&self.path, color, self.transform, FillRule::EvenOdd, true);
220 |     }
221 | 
222 |     fn shadow(&mut self) {
223 |         self.recorder.stroke(
224 |             &self.path,
225 |             Color::bgra(0x99000000),
226 |             Stroke::width(2.0),
227 |             self.transform,
228 |             true,
229 |         );
230 |     }
231 | }
232 | 


--------------------------------------------------------------------------------
/src/anima/mod.rs:
--------------------------------------------------------------------------------
  1 | pub mod actions;
  2 | pub mod animation;
  3 | pub mod armature;
  4 | pub mod controller;
  5 | pub mod example;
  6 | pub mod gizmo;
  7 | pub mod grid;
  8 | pub mod runtime;
  9 | pub mod timeline;
 10 | pub mod viewport;
 11 | 
 12 | pub mod asset;
 13 | 
 14 | pub use self::animation::{
 15 |     Animation, BoneTimeline, Interpolation, Keyframe, Timeline, TimelineValue,
 16 | };
 17 | pub use self::controller::{Controller, PlayControl, PlayState};
 18 | pub use self::grid::{Grid, GridViewport};
 19 | pub use self::runtime::armature::{Armature, Bone};
 20 | pub use self::runtime::math::{Matrix, Transform};
 21 | pub use self::timeline::TimelinePanel;
 22 | pub use self::viewport::Animation2d;
 23 | 
 24 | use crate::ui::{AddEditorTab, EditorPanel, PanelRenderTarget};
 25 | use bevy::core_pipeline::clear_color::ClearColorConfig;
 26 | use bevy::prelude::*;
 27 | use bevy::window::WindowId;
 28 | use reui::plugin::Recorder;
 29 | 
 30 | #[derive(Default)]
 31 | pub struct AnimaPlugin;
 32 | 
 33 | impl bevy::app::Plugin for AnimaPlugin {
 34 |     fn build(&self, app: &mut bevy::app::App) {
 35 |         app.add_plugin(reui::plugin::ReuiPlugin)
 36 |             .insert_resource(Controller {
 37 |                 current_time: 0,
 38 |                 ..default()
 39 |             })
 40 |             .insert_resource(self::example::armature())
 41 |             .insert_resource(self::example::animation())
 42 |             .add_system(sync_frame)
 43 |             .add_system_to_stage(CoreStage::PostUpdate, draw)
 44 |             .add_editor_tab::<TimelinePanel>()
 45 |             .add_editor_tab::<Animation2d>();
 46 |     }
 47 | }
 48 | 
 49 | fn sync_frame(mut ctrl: ResMut<Controller>, armature: Res<Armature>, animation: Res<Animation>) {
 50 |     ctrl.local_to_world.clear();
 51 | 
 52 |     let time = ctrl.current_time as f32;
 53 |     for (index, bone) in armature.bones.iter().enumerate() {
 54 |         let clip = animation.resolve_bone_tranform(index, time);
 55 | 
 56 |         //bone.transform.to_matrix().prepend(clip.to_matrix())
 57 |         let transform = bone.transform.mul_transform(clip).to_matrix();
 58 | 
 59 |         let parent = bone.parent as usize;
 60 |         let parent = *ctrl.local_to_world.get(parent).unwrap_or(&Matrix::IDENTITY);
 61 |         ctrl.local_to_world.push(parent.prepend(transform));
 62 |     }
 63 | }
 64 | 
 65 | impl Animation2d {
 66 |     pub fn spawn(commands: &mut Commands, images: &mut Assets<Image>) -> crate::ui::Tab {
 67 |         use bevy::prelude::*;
 68 | 
 69 |         let target = PanelRenderTarget::create_render_target(images);
 70 | 
 71 |         let clear_color = bevy::prelude::Color::rgba(0.0, 0.0, 0.0, 0.0);
 72 |         let clear_color = ClearColorConfig::Custom(clear_color);
 73 | 
 74 |         let entity = commands
 75 |             .spawn_bundle(Camera2dBundle {
 76 |                 camera_2d: Camera2d { clear_color },
 77 |                 camera: Camera {
 78 |                     target,
 79 |                     ..default()
 80 |                 },
 81 |                 ..default()
 82 |             })
 83 |             .insert(Self::default())
 84 |             .insert(EditorPanel::default())
 85 |             .insert(Recorder::default())
 86 |             .insert(PanelRenderTarget::default())
 87 |             .id();
 88 | 
 89 |         crate::ui::Tab::new(crate::ui::icon::VIEW_ORTHO, "Animate 2d", entity)
 90 |     }
 91 | }
 92 | 
 93 | fn draw(
 94 |     windows: Res<Windows>,
 95 |     time: Res<Time>,
 96 |     mut query: Query<(&mut Recorder, &Animation2d, &EditorPanel)>,
 97 | ) {
 98 |     let time = time.seconds_since_startup() as f32;
 99 |     let ppi = windows.scale_factor(WindowId::primary()) as f32;
100 |     for (mut recorder, anima, panel) in query.iter_mut() {
101 |         recorder.clear();
102 | 
103 |         if let Some(frame) = panel.viewport {
104 |             let zoom = anima.grid.zoom;
105 |             let offset = frame.center() - frame.min;
106 |             let offset = offset + anima.grid.offset * egui::vec2(-zoom, zoom);
107 |             let viewport = reui::Transform::compose(offset.x * ppi, offset.y * ppi, 0.0, ppi);
108 | 
109 |             let mut canvas = self::gizmo::Gizmos::new(&mut recorder, viewport);
110 | 
111 |             let x_color = reui::Color::bgra(0xFFFF0000);
112 |             let y_color = reui::Color::bgra(0xFF00FF00);
113 | 
114 |             use std::f32::consts::{FRAC_PI_2, PI};
115 |             let rot = -time;
116 | 
117 |             canvas.set_transform(0.0, 0.0, rot, 1.0);
118 |             canvas.rotate(x_color);
119 |             canvas.set_transform(45.0, 0.0, rot, 1.0);
120 |             canvas.length(x_color);
121 | 
122 |             canvas.set_transform(45.0, 20.0, rot, 1.0);
123 |             canvas.pose(x_color);
124 | 
125 |             canvas.set_transform(70.0, 0.0, rot, 1.0);
126 |             canvas.arrow_translate(x_color);
127 |             canvas.set_transform(70.0, 0.0, rot - FRAC_PI_2, 1.0);
128 |             canvas.arrow_translate(y_color);
129 | 
130 |             canvas.set_transform(140.0, 0.0, rot, 1.0);
131 |             canvas.arrow_scale(x_color);
132 |             canvas.set_transform(140.0, 0.0, rot - FRAC_PI_2, 1.0);
133 |             canvas.arrow_scale(y_color);
134 | 
135 |             canvas.set_transform(200.0, 0.0, 0.0, 1.0);
136 |             canvas.shear(x_color, time);
137 |             canvas.set_transform(200.0, 0.0, PI, 1.0);
138 |             canvas.shear(x_color, time);
139 | 
140 |             canvas.set_transform(200.0, 0.0, FRAC_PI_2, 1.0);
141 |             canvas.shear(y_color, -time);
142 |             canvas.set_transform(200.0, 0.0, -FRAC_PI_2, 1.0);
143 |             canvas.shear(y_color, -time);
144 |         }
145 |     }
146 | }
147 | 


--------------------------------------------------------------------------------
/src/anima/runtime/animation.rs:
--------------------------------------------------------------------------------
1 | 
2 | 


--------------------------------------------------------------------------------
/src/anima/runtime/armature.rs:
--------------------------------------------------------------------------------
  1 | use super::super::Transform;
  2 | 
  3 | pub struct BoneData {
  4 |     pub name: String,
  5 |     pub parent: String,
  6 |     pub transform: Transform,
  7 |     pub length: f32,
  8 |     pub color: u32,
  9 | }
 10 | 
 11 | pub struct SlotData {
 12 |     pub name: String,
 13 |     pub bone: String,
 14 |     pub attachment: String,
 15 | 
 16 |     pub color: u32,
 17 |     // TODO: blend + blend_color
 18 | }
 19 | 
 20 | pub struct SkinData {
 21 |     pub name: String,
 22 | }
 23 | 
 24 | pub struct ClipData {
 25 |     pub name: String,
 26 | }
 27 | 
 28 | pub struct ArmatureData {
 29 |     pub bones: Vec<BoneData>, // parent first order
 30 |     pub slots: Vec<SlotData>, // draw order
 31 |     pub skins: Vec<SkinData>,
 32 |     pub clips: Vec<ClipData>,
 33 | }
 34 | 
 35 | macro_rules! _finder {
 36 |     ($ref_fn:ident, $mut_fn:ident => $field:ident : $ty:ident) => {
 37 |         pub fn $ref_fn(&self, name: &str) -> Option<&$ty> {
 38 |             self.$field.iter().find(|item| item.name == name)
 39 |         }
 40 | 
 41 |         pub fn $mut_fn(&mut self, name: &str) -> Option<&mut $ty> {
 42 |             self.$field.iter_mut().find(|item| item.name == name)
 43 |         }
 44 |     };
 45 | }
 46 | 
 47 | impl ArmatureData {
 48 |     _finder!(bone, bone_mut => bones: BoneData);
 49 |     _finder!(slot, slot_mut => slots: SlotData);
 50 |     _finder!(skin, skin_mut => skins: SkinData);
 51 |     _finder!(clip, clip_mut => clips: ClipData);
 52 | 
 53 |     pub fn add_bone(&mut self, bone: BoneData) {
 54 |         let index = self
 55 |             .bones
 56 |             .iter()
 57 |             .position(|item| item.name == bone.parent)
 58 |             .map(|i| i + 1)
 59 |             .filter(|&i| i < self.bones.len());
 60 | 
 61 |         if let Some(index) = index {
 62 |             self.bones.insert(index, bone)
 63 |         } else {
 64 |             self.bones.push(bone)
 65 |         }
 66 |     }
 67 | }
 68 | 
 69 | pub struct Slot {
 70 |     pub name: String,
 71 |     pub bone: u32,
 72 | }
 73 | 
 74 | pub struct Bone {
 75 |     pub name: String,
 76 |     pub transform: Transform,
 77 |     pub color: u32,
 78 |     pub length: f32,
 79 |     pub parent: u32,
 80 | }
 81 | 
 82 | impl Default for Bone {
 83 |     fn default() -> Self {
 84 |         Self {
 85 |             name: String::new(),
 86 |             transform: Transform::default(),
 87 |             color: 0xFFFFFFFF,
 88 |             length: 0.0,
 89 |             parent: u32::max_value(),
 90 |         }
 91 |     }
 92 | }
 93 | 
 94 | pub struct Armature {
 95 |     pub bones: Vec<Bone>,
 96 |     pub slots: Vec<Slot>,
 97 | }
 98 | 
 99 | impl Armature {
100 |     pub fn insert_bone(&mut self, index: usize, bone: Bone) {
101 |         for bone in &mut self.bones {
102 |             if bone.parent >= index as u32 {
103 |                 bone.parent = bone.parent.saturating_add(1);
104 |             }
105 |         }
106 |         self.bones.insert(index, bone);
107 |     }
108 | 
109 |     pub fn add_bone(&mut self, bone: Bone) {
110 |         self.bones.push(bone);
111 |     }
112 | }
113 | 


--------------------------------------------------------------------------------
/src/anima/runtime/math.rs:
--------------------------------------------------------------------------------
  1 | use egui::{Pos2, Vec2};
  2 | 
  3 | #[derive(Clone, Copy)]
  4 | pub struct Transform {
  5 |     pub rotate: f32,
  6 |     pub translate: Pos2,
  7 |     pub scale: Vec2,
  8 |     pub shear: Vec2,
  9 | }
 10 | 
 11 | impl Default for Transform {
 12 |     fn default() -> Self {
 13 |         Self {
 14 |             rotate: 0.0,
 15 |             translate: Pos2::new(0.0, 0.0),
 16 |             scale: Vec2::new(1.0, 1.0),
 17 |             shear: Vec2::new(0.0, 0.0),
 18 |         }
 19 |     }
 20 | }
 21 | 
 22 | impl Transform {
 23 |     pub fn to_matrix(&self) -> Matrix {
 24 |         let (sx, cx) = (self.rotate - self.shear.x).sin_cos();
 25 |         let (sy, cy) = (self.rotate + self.shear.y).sin_cos();
 26 |         let sx = -sx;
 27 | 
 28 |         Matrix {
 29 |             a: cy * self.scale.x,
 30 |             b: sy * self.scale.x,
 31 |             c: sx * self.scale.y,
 32 |             d: cx * self.scale.y,
 33 |             tx: self.translate.x,
 34 |             ty: self.translate.y,
 35 |         }
 36 |     }
 37 | 
 38 |     pub fn inverse(&self) -> Self {
 39 |         Self {
 40 |             translate: (-self.translate.to_vec2()).to_pos2(),
 41 |             rotate: -self.rotate,
 42 |             scale: egui::vec2(self.scale.x.recip(), self.scale.y.recip()),
 43 |             shear: -self.shear,
 44 |         }
 45 |     }
 46 | 
 47 |     pub fn mul_transform(&self, transform: Self) -> Self {
 48 |         let (x, y) = transform.translate.into();
 49 |         Self {
 50 |             translate: self.to_matrix().apply(x, y).into(),
 51 |             rotate: self.rotate + transform.rotate,
 52 |             scale: self.scale * transform.scale,
 53 |             shear: self.shear + transform.shear,
 54 |         }
 55 |     }
 56 | 
 57 |     pub fn mul_vec2(&self, egui::Vec2 { x, y }: egui::Vec2) -> egui::Pos2 {
 58 |         self.to_matrix().apply(x, y).into()
 59 |     }
 60 | }
 61 | 
 62 | #[derive(Clone, Copy)]
 63 | pub struct Matrix {
 64 |     pub a: f32,
 65 |     pub b: f32,
 66 |     pub c: f32,
 67 |     pub d: f32,
 68 |     pub tx: f32,
 69 |     pub ty: f32,
 70 | }
 71 | 
 72 | impl Default for Matrix {
 73 |     fn default() -> Self {
 74 |         Self::IDENTITY
 75 |     }
 76 | }
 77 | 
 78 | impl Matrix {
 79 |     pub const IDENTITY: Self = Self::new(1.0, 0.0, 0.0, 1.0, 0.0, 0.0);
 80 | 
 81 |     pub const fn new(a: f32, b: f32, c: f32, d: f32, tx: f32, ty: f32) -> Self {
 82 |         Self { a, b, c, d, tx, ty }
 83 |     }
 84 | 
 85 |     pub fn apply(&self, x: f32, y: f32) -> [f32; 2] {
 86 |         [
 87 |             self.a * x + self.c * y + self.tx,
 88 |             self.b * x + self.d * y + self.ty,
 89 |         ]
 90 |     }
 91 | 
 92 |     pub fn apply_points(&self, points: &mut [Pos2]) {
 93 |         for p in points {
 94 |             *p = self.apply(p.x, p.y).into();
 95 |         }
 96 |     }
 97 | 
 98 |     pub fn apply_offset(&self, points: &mut [Pos2]) {
 99 |         for p in points {
100 |             p.x += self.tx;
101 |             p.y += self.ty;
102 |         }
103 |     }
104 | 
105 |     pub fn apply_inv(&self, x: f32, y: f32) -> [f32; 2] {
106 |         let id = (self.a * self.d + self.c * -self.b).recip();
107 |         [
108 |             self.d * id * x - self.c * id * y + (self.ty * self.c - self.tx * self.d) * id,
109 |             self.a * id * y - self.b * id * x + (self.tx * self.b - self.ty * self.a) * id,
110 |         ]
111 |     }
112 | 
113 |     pub fn invert(&self) -> Self {
114 |         let n = self.a * self.d - self.b * self.c;
115 |         Self {
116 |             a: self.d / n,
117 |             b: -self.b / n,
118 |             c: -self.c / n,
119 |             d: self.a / n,
120 |             tx: (self.c * self.ty - self.d * self.tx) / n,
121 |             ty: (self.b * self.tx - self.a * self.ty) / n,
122 |         }
123 |     }
124 | 
125 |     /// Appends the given Matrix to this Matrix.
126 |     pub fn append(self, rhs: Self) -> Self {
127 |         Self::concat(self, rhs)
128 |     }
129 | 
130 |     /// Prepends the given Matrix to this Matrix.
131 |     pub fn prepend(self, lhs: Self) -> Self {
132 |         Self::concat(lhs, self)
133 |     }
134 | 
135 |     #[inline(always)]
136 |     fn concat(lhs: Self, rhs: Self) -> Self {
137 |         Self {
138 |             a: lhs.a.mul_add(rhs.a, lhs.b * rhs.c),
139 |             b: lhs.a.mul_add(rhs.b, lhs.b * rhs.d),
140 |             c: lhs.c.mul_add(rhs.a, lhs.d * rhs.c),
141 |             d: lhs.c.mul_add(rhs.b, lhs.d * rhs.d),
142 |             tx: lhs.tx.mul_add(rhs.a, lhs.ty.mul_add(rhs.c, rhs.tx)),
143 |             ty: lhs.tx.mul_add(rhs.b, lhs.ty.mul_add(rhs.d, rhs.ty)),
144 |         }
145 |     }
146 | }
147 | 


--------------------------------------------------------------------------------
/src/anima/runtime/mod.rs:
--------------------------------------------------------------------------------
1 | pub mod animation;
2 | pub mod armature;
3 | pub mod math;
4 | 
5 | pub use self::math::{Matrix, Transform};
6 | 


--------------------------------------------------------------------------------
/src/main.rs:
--------------------------------------------------------------------------------
  1 | #![allow(clippy::forget_non_drop)]
  2 | #![allow(clippy::too_many_arguments)]
  3 | #![allow(clippy::type_complexity)]
  4 | 
  5 | use crate::scene::{ReflectScene, ReflectSceneSpawner};
  6 | use crate::ui::AddEditorTab;
  7 | use crate::util::anymap::AnyMap;
  8 | use bevy::log::LogPlugin;
  9 | use bevy::prelude::*;
 10 | use bevy::reflect::TypeRegistryArc;
 11 | use bevy::window::PresentMode;
 12 | use bevy::winit::{UpdateMode, WinitSettings};
 13 | 
 14 | pub mod anima;
 15 | pub mod scene;
 16 | pub mod ui;
 17 | pub mod util;
 18 | 
 19 | //mod workspace;
 20 | 
 21 | fn main() {
 22 |     crate::util::enable_tracing();
 23 | 
 24 |     let mut app = App::new();
 25 |     app.insert_resource(ClearColor(Color::CRIMSON))
 26 |         .insert_resource(Msaa { samples: 1 })
 27 |         .insert_resource(WindowDescriptor {
 28 |             //width: 1920.0 / 2.0,
 29 |             //height: 1080.0 / 2.0,
 30 |             title: String::from("ShaderLab"),
 31 |             //mode: WindowMode::Fullscreen,
 32 |             decorations: true,
 33 |             present_mode: PresentMode::AutoNoVsync,
 34 |             ..default()
 35 |         })
 36 |         .init_resource::<AnyMap>()
 37 |         // Optimal power saving and present mode settings for desktop apps.
 38 |         .insert_resource(WinitSettings {
 39 |             return_from_run: true,
 40 |             //focused_mode: UpdateMode::Continuous,
 41 |             focused_mode: UpdateMode::Reactive {
 42 |                 max_wait: std::time::Duration::from_secs_f64(1.0 / 60.0),
 43 |             },
 44 |             unfocused_mode: UpdateMode::ReactiveLowPower {
 45 |                 max_wait: std::time::Duration::from_secs(60),
 46 |             },
 47 |         })
 48 |         .add_plugins_with(DefaultPlugins, |group| group.disable::<LogPlugin>());
 49 | 
 50 |     app.add_plugin(crate::scene::component::EditorPlugin);
 51 |     app.add_plugin(crate::scene::GizmoPlugin);
 52 | 
 53 |     app.add_plugin(self::ui::EditorUiPlugin);
 54 | 
 55 |     app.add_editor_tab::<self::scene::FileBrowser>();
 56 |     app.add_editor_tab::<self::scene::Hierarchy>();
 57 |     app.add_editor_tab::<self::scene::Inspector>();
 58 |     app.add_editor_tab::<self::scene::SceneTab>();
 59 | 
 60 |     app.add_plugin(self::anima::AnimaPlugin);
 61 | 
 62 |     app.add_startup_system(setup);
 63 | 
 64 |     app.run();
 65 | }
 66 | 
 67 | fn setup(
 68 |     mut commands: Commands,
 69 |     mut images: ResMut<Assets<Image>>,
 70 |     mut spawner: ResMut<ReflectSceneSpawner>,
 71 |     mut scenes: ResMut<Assets<ReflectScene>>,
 72 |     type_registry: Res<TypeRegistryArc>,
 73 | ) {
 74 |     use crate::anima::{Animation2d, TimelinePanel};
 75 |     use crate::scene::{FileBrowser, Hierarchy, Inspector, SceneTab};
 76 |     use crate::ui::*;
 77 | 
 78 |     {
 79 |         let world = exampe_scene();
 80 |         let scene = ReflectScene::from_world(&world, &type_registry);
 81 |         let scene = scenes.add(scene);
 82 |         spawner.spawn(scene.clone());
 83 |         commands.insert_resource(scene);
 84 |     }
 85 | 
 86 |     trait SpawnTab {
 87 |         fn tab<T: Component>(&mut self, icon: char, title: &str, tab: T) -> Tab;
 88 | 
 89 |         fn placeholder(&mut self, icon: char, title: &str) -> Tab {
 90 |             self.tab(icon, title, PlaceholderTab::default())
 91 |         }
 92 |     }
 93 | 
 94 |     impl<'s, 'w> SpawnTab for Commands<'s, 'w> {
 95 |         fn tab<T: Component>(&mut self, icon: char, title: &str, tab: T) -> Tab {
 96 |             let entity = self
 97 |                 .spawn()
 98 |                 .insert_bundle((EditorPanel::default(), tab))
 99 |                 .id();
100 |             Tab::new(icon, title, entity)
101 |         }
102 |     }
103 | 
104 |     let node_tree = commands.placeholder(icon::NODETREE, "Node Tree");
105 | 
106 |     let scene = SceneTab::spawn(&mut commands, &mut images);
107 | 
108 |     let hierarchy = commands.tab(icon::OUTLINER, "Hierarchy", Hierarchy::default());
109 |     let inspector = commands.tab(icon::PROPERTIES, "Inspector", Inspector::default());
110 |     let files = commands.tab(icon::FILEBROWSER, "File Browser", FileBrowser::default());
111 | 
112 |     let assets = commands.placeholder(icon::ASSET_MANAGER, "Asset Manager");
113 | 
114 |     let anim = Animation2d::spawn(&mut commands, &mut images);
115 | 
116 |     let timeline = commands.tab(icon::TIME, "Timeline", TimelinePanel::default());
117 | 
118 |     let root = TreeNode::leaf_with(vec![anim, scene, node_tree]);
119 |     let mut split_tree = SplitTree::new(root);
120 | 
121 |     let [a, b] = split_tree.split_tabs(NodeIndex::root(), Split::Right, 0.7, vec![inspector]);
122 |     let [_, _] = split_tree.split_tabs(a, Split::Below, 0.8, vec![timeline]);
123 |     let [_, _] = split_tree.split_tabs(b, Split::Below, 0.5, vec![hierarchy, files, assets]);
124 | 
125 |     commands.insert_resource(split_tree);
126 | }
127 | 
128 | fn exampe_scene() -> World {
129 |     use crate::scene::component::{ProxyHandle, ProxyMeta, ProxyPointLight, ProxyTransform};
130 |     use crate::ui::icon;
131 |     use bevy::ecs::world::EntityMut;
132 | 
133 |     fn new<'a>(builder: &'a mut WorldChildBuilder, prefix: &str, counter: usize) -> EntityMut<'a> {
134 |         let icon = match counter % 14 {
135 |             0 => icon::MESH_CONE,
136 |             1 => icon::MESH_PLANE,
137 |             2 => icon::MESH_CYLINDER,
138 |             3 => icon::MESH_ICOSPHERE,
139 |             4 => icon::MESH_CAPSULE,
140 |             5 => icon::MESH_UVSPHERE,
141 |             6 => icon::MESH_CIRCLE,
142 |             7 => icon::MESH_MONKEY,
143 |             8 => icon::MESH_TORUS,
144 |             9 => icon::MESH_CUBE,
145 | 
146 |             10 => icon::OUTLINER_OB_CAMERA,
147 |             11 => icon::OUTLINER_OB_EMPTY,
148 |             12 => icon::OUTLINER_OB_LIGHT,
149 |             13 => icon::OUTLINER_OB_SPEAKER,
150 | 
151 |             _ => unreachable!(),
152 |         };
153 | 
154 |         let mut builder = builder.spawn();
155 |         builder.insert_bundle((
156 |             ProxyMeta::new(icon, format!("{} #{}", prefix, counter)),
157 |             ProxyHandle::<Mesh>::new("models/BoxTextured.glb#Mesh0/Primitive0"),
158 |             ProxyHandle::<StandardMaterial>::new("models/BoxTextured.glb#Material0"),
159 |         ));
160 |         builder
161 |     }
162 | 
163 |     let mut world = World::new();
164 | 
165 |     world.spawn().insert_bundle((
166 |         ProxyMeta::new(icon::LIGHT_POINT, "Point Light"),
167 |         ProxyTransform {
168 |             translation: Vec3::new(0.0, 0.0, 10.0),
169 |             ..default()
170 |         },
171 |         ProxyPointLight::default(),
172 |     ));
173 | 
174 |     let mut counter = 0;
175 | 
176 |     for _ in 0..2 {
177 |         let icon = icon::MESH_CUBE;
178 |         world
179 |             .spawn()
180 |             .insert_bundle((
181 |                 ProxyMeta::new(icon, format!("Root #{}", counter)),
182 |                 ProxyTransform {
183 |                     translation: Vec3::new(
184 |                         (counter % 2) as f32,
185 |                         (counter % 3) as f32,
186 |                         (counter % 4) as f32,
187 |                     ),
188 |                     ..default()
189 |                 },
190 |                 ProxyHandle::<Mesh>::new("models/BoxTextured.glb#Mesh0/Primitive0"),
191 |                 ProxyHandle::<StandardMaterial>::new("models/BoxTextured.glb#Material0"),
192 |             ))
193 |             .with_children(|builder| {
194 |                 for _ in 0..2 {
195 |                     counter += 1;
196 |                     new(builder, "Child", counter)
197 |                         .insert(ProxyTransform {
198 |                             translation: Vec3::new(
199 |                                 (counter % 2) as f32,
200 |                                 (counter % 3) as f32,
201 |                                 (counter % 4) as f32,
202 |                             ),
203 |                             ..default()
204 |                         })
205 |                         .with_children(|builder| {
206 |                             for _ in 0..2 {
207 |                                 counter += 1;
208 |                                 new(builder, "Sub Child", counter).insert(ProxyTransform {
209 |                                     translation: Vec3::new(
210 |                                         (counter % 2) as f32,
211 |                                         (counter % 3) as f32,
212 |                                         (counter % 4) as f32,
213 |                                     ),
214 |                                     ..default()
215 |                                 });
216 |                             }
217 |                         });
218 |                 }
219 |             });
220 |         counter += 1;
221 |     }
222 | 
223 |     world
224 | }
225 | 


--------------------------------------------------------------------------------
/src/scene/component/editor.rs:
--------------------------------------------------------------------------------
  1 | use crate::ui::{icon, Style};
  2 | use bevy::reflect::{FromType, Reflect};
  3 | use egui::style::Margin;
  4 | use egui::*;
  5 | use std::borrow::Cow;
  6 | 
  7 | pub trait ComponentEditor {
  8 |     fn desc() -> (char, Cow<'static, str>) {
  9 |         (' ', "".into())
 10 |     }
 11 | 
 12 |     fn skip() -> bool {
 13 |         false
 14 |     }
 15 | 
 16 |     fn ui(ui: &mut Ui, style: &Style, reflect: &mut dyn Reflect) {
 17 |         let (icon, name) = Self::desc();
 18 |         reflect_component_editor(ui, style, reflect, icon, &name);
 19 |     }
 20 | }
 21 | 
 22 | #[derive(Clone)]
 23 | pub struct ReflectComponentEditor {
 24 |     skip: fn() -> bool,
 25 |     ui: fn(&mut Ui, style: &Style, &mut dyn Reflect),
 26 | }
 27 | 
 28 | impl ReflectComponentEditor {
 29 |     pub fn skip(&self) -> bool {
 30 |         (self.skip)()
 31 |     }
 32 | 
 33 |     pub fn ui(&self, ui: &mut Ui, style: &Style, reflect: &mut dyn Reflect) {
 34 |         (self.ui)(ui, style, reflect);
 35 |     }
 36 | }
 37 | 
 38 | impl<T: ComponentEditor + Reflect> FromType<T> for ReflectComponentEditor {
 39 |     fn from_type() -> Self {
 40 |         Self {
 41 |             skip: T::skip,
 42 |             ui: T::ui,
 43 |         }
 44 |     }
 45 | }
 46 | 
 47 | pub fn reflect_component_editor(
 48 |     ui: &mut egui::Ui,
 49 |     style: &Style,
 50 |     reflect: &mut dyn Reflect,
 51 |     icon: char,
 52 |     name: &str,
 53 | ) {
 54 |     let id = Id::new((reflect.type_name(), "#component_header"));
 55 |     let mut state = State::load(ui.ctx(), id);
 56 | 
 57 |     if component_header(Some(&mut state), ui, style, icon, name, |_| ()) {
 58 |         let margin = Margin {
 59 |             left: 6.0,
 60 |             right: 2.0,
 61 |             top: 4.0,
 62 |             bottom: 6.0,
 63 |         };
 64 |         Frame::none().inner_margin(margin).show(ui, |ui| {
 65 |             crate::ui::field::reflect(ui, reflect);
 66 |         });
 67 |     }
 68 | 
 69 |     state.store(ui.ctx(), id);
 70 | }
 71 | 
 72 | pub fn component_header(
 73 |     state: Option<&mut State>,
 74 |     ui: &mut egui::Ui,
 75 |     style: &Style,
 76 |     icon: char,
 77 |     name: &str,
 78 |     extra: impl FnOnce(&mut Ui),
 79 | ) -> bool {
 80 |     let tri_color = style.input_text;
 81 |     let text_color = style.input_text;
 82 | 
 83 |     let width = ui.available_width();
 84 |     let (rect, response) = ui.allocate_exact_size(vec2(width, 20.0), Sense::click());
 85 |     let response = response.on_hover_cursor(CursorIcon::PointingHand);
 86 | 
 87 |     let tri_pos = rect.left_center() + vec2(8.0, 0.0);
 88 |     let icon_pos = rect.left_center() + vec2(24.0, 0.0);
 89 |     let label_pos = rect.left_center() + vec2(38.0, 0.0);
 90 |     let dots_pos = rect.right_center() - vec2(12.0, 0.0);
 91 | 
 92 |     ui.painter().text(
 93 |         icon_pos,
 94 |         Align2::CENTER_CENTER,
 95 |         icon.to_string(),
 96 |         FontId::proportional(16.0),
 97 |         text_color,
 98 |     );
 99 | 
100 |     ui.painter().text(
101 |         label_pos,
102 |         Align2::LEFT_CENTER,
103 |         name,
104 |         FontId::proportional(14.0),
105 |         text_color,
106 |     );
107 | 
108 |     let dots_rect = ui.painter().text(
109 |         dots_pos,
110 |         Align2::CENTER_CENTER,
111 |         icon::THREE_DOTS,
112 |         FontId::proportional(16.0),
113 |         text_color,
114 |     );
115 | 
116 |     {
117 |         let left_x = egui::lerp(rect.min.x..=rect.max.x, crate::ui::field::PERCENT);
118 |         let rect = rect.intersect(Rect::everything_right_of(left_x + 7.0));
119 |         let rect = rect.intersect(Rect::everything_left_of(dots_rect.min.x));
120 |         let rect = rect.shrink2(vec2(0.0, 1.0));
121 | 
122 |         let layout = Layout::top_down(Align::Min);
123 |         let mut ui = ui.child_ui(rect, layout);
124 |         extra(&mut ui)
125 |     }
126 | 
127 |     if let Some(state) = state {
128 |         if response.clicked() {
129 |             state.toggle(ui);
130 |         }
131 |         ui.painter().text(
132 |             tri_pos,
133 |             Align2::CENTER_CENTER,
134 |             if state.open {
135 |                 icon::DISCLOSURE_TRI_DOWN
136 |             } else {
137 |                 icon::DISCLOSURE_TRI_RIGHT
138 |             },
139 |             FontId::proportional(16.0),
140 |             tri_color,
141 |         );
142 |         state.open
143 |     } else {
144 |         false
145 |     }
146 | }
147 | 
148 | #[derive(Clone, Debug, Default)]
149 | pub struct State {
150 |     open: bool,
151 | }
152 | 
153 | impl State {
154 |     pub fn load(ctx: &Context, id: Id) -> Self {
155 |         ctx.data().get_temp(id).unwrap_or(Self { open: true })
156 |     }
157 | 
158 |     pub fn store(self, ctx: &Context, id: Id) {
159 |         ctx.data().insert_temp(id, self);
160 |     }
161 | 
162 |     pub fn toggle(&mut self, ui: &Ui) {
163 |         self.open = !self.open;
164 |         ui.ctx().request_repaint();
165 |     }
166 | }
167 | 


--------------------------------------------------------------------------------
/src/scene/component/handle.rs:
--------------------------------------------------------------------------------
 1 | use super::{ComponentEditor, Proxy, ReflectComponentEditor, ReflectProxy};
 2 | use crate::ui::{icon, Style};
 3 | use bevy::asset::{Asset, AssetPath};
 4 | use bevy::prelude::*;
 5 | use bevy::reflect::{FromReflect, GetPath};
 6 | use std::borrow::Cow;
 7 | use std::marker::PhantomData;
 8 | 
 9 | #[derive(Component, Reflect, FromReflect)]
10 | #[reflect(Component, Proxy, ComponentEditor)]
11 | pub struct ProxyHandle<T: Asset> {
12 |     pub path: String,
13 | 
14 |     #[reflect(ignore)]
15 |     marker: PhantomData<fn() -> T>,
16 | }
17 | 
18 | impl<T: Asset> ProxyHandle<T> {
19 |     pub fn new(path: impl Into<String>) -> Self {
20 |         Self {
21 |             path: path.into(),
22 |             marker: PhantomData,
23 |         }
24 |     }
25 | }
26 | 
27 | impl<T: Asset> Default for ProxyHandle<T> {
28 |     fn default() -> Self {
29 |         Self {
30 |             path: Default::default(),
31 |             marker: PhantomData,
32 |         }
33 |     }
34 | }
35 | 
36 | impl<T: Asset> ProxyHandle<T> {
37 |     fn resolve(self, world: &mut World) -> Option<Handle<T>> {
38 |         let asset_server = world.get_resource::<AssetServer>()?;
39 |         Some(asset_server.load(AssetPath::from(&self.path)))
40 |     }
41 | }
42 | 
43 | impl<T: Asset> Proxy for ProxyHandle<T> {
44 |     fn insert(self, world: &mut World, entity: Entity) {
45 |         if let Some(component) = self.resolve(world) {
46 |             world.entity_mut(entity).insert(component);
47 |         }
48 |     }
49 | }
50 | 
51 | impl<T: bevy::asset::Asset> ComponentEditor for ProxyHandle<T> {
52 |     fn desc() -> (char, Cow<'static, str>) {
53 |         let type_name = std::any::type_name::<T>();
54 |         if type_name == std::any::type_name::<bevy::prelude::Mesh>() {
55 |             (icon::MESH_DATA, "Mesh".into())
56 |         } else if type_name == std::any::type_name::<bevy::prelude::StandardMaterial>() {
57 |             (icon::MATERIAL_DATA, "Material".into())
58 |         } else {
59 |             (' ', format!("Handle<{}>", type_name).into())
60 |         }
61 |     }
62 | 
63 |     fn ui(ui: &mut egui::Ui, style: &Style, reflect: &mut dyn Reflect) {
64 |         let (icon, name) = Self::desc();
65 |         //crate::component::reflect_component_editor(ui, style, reflect, icon, &name);
66 |         super::editor::component_header(None, ui, style, icon, &name, |ui| {
67 |             let field = reflect.path_mut("path").unwrap();
68 |             crate::ui::field::reflect(ui, field);
69 |         });
70 |     }
71 | }
72 | 


--------------------------------------------------------------------------------
/src/scene/component/light.rs:
--------------------------------------------------------------------------------
 1 | use super::{ComponentEditor, Proxy, ReflectComponentEditor, ReflectProxy};
 2 | use crate::ui::icon;
 3 | use bevy::prelude::*;
 4 | use bevy::reflect::FromReflect;
 5 | use std::borrow::Cow;
 6 | 
 7 | #[derive(Component, Reflect, FromReflect)]
 8 | #[reflect(Component, Proxy, ComponentEditor)]
 9 | pub struct ProxyPointLight {
10 |     pub color: Color,
11 |     pub intensity: f32,
12 |     pub range: f32,
13 |     pub radius: f32,
14 |     pub shadows_enabled: bool,
15 |     pub shadow_depth_bias: f32,
16 |     pub shadow_normal_bias: f32,
17 | }
18 | 
19 | impl Default for ProxyPointLight {
20 |     fn default() -> Self {
21 |         Self {
22 |             color: Color::rgb(1.0, 1.0, 1.0),
23 |             /// Luminous power in lumens
24 |             intensity: 800.0, // Roughly a 60W non-halogen incandescent bulb
25 |             range: 20.0,
26 |             radius: 0.0,
27 |             shadows_enabled: false,
28 |             shadow_depth_bias: PointLight::DEFAULT_SHADOW_DEPTH_BIAS,
29 |             shadow_normal_bias: PointLight::DEFAULT_SHADOW_NORMAL_BIAS,
30 |         }
31 |     }
32 | }
33 | 
34 | impl Proxy for ProxyPointLight {
35 |     fn insert(self, world: &mut World, entity: Entity) {
36 |         world.entity_mut(entity).insert_bundle((
37 |             PointLight {
38 |                 color: self.color,
39 |                 intensity: self.intensity,
40 |                 range: self.range,
41 |                 radius: self.radius,
42 |                 shadows_enabled: self.shadows_enabled,
43 |                 shadow_depth_bias: self.shadow_depth_bias,
44 |                 shadow_normal_bias: self.shadow_normal_bias,
45 |             },
46 |             bevy::pbr::CubemapVisibleEntities::default(),
47 |             bevy::render::primitives::CubemapFrusta::default(),
48 |         ));
49 |     }
50 | }
51 | 
52 | impl ComponentEditor for ProxyPointLight {
53 |     fn desc() -> (char, Cow<'static, str>) {
54 |         (icon::LIGHT_POINT, "PointLight".into())
55 |     }
56 | }
57 | 


--------------------------------------------------------------------------------
/src/scene/component/meta.rs:
--------------------------------------------------------------------------------
  1 | use super::{ComponentEditor, Proxy, ReflectComponentEditor, ReflectProxy};
  2 | use crate::ui::Style;
  3 | use bevy::prelude::*;
  4 | use bevy::reflect::{DynamicStruct, FromReflect};
  5 | use egui::*;
  6 | use std::borrow::Cow;
  7 | 
  8 | #[derive(Component, Reflect, FromReflect)]
  9 | #[reflect(Component, Proxy, ComponentEditor)]
 10 | pub struct ProxyMeta {
 11 |     pub icon: u32,
 12 |     pub name: Cow<'static, str>,
 13 |     pub is_visible: bool,
 14 | }
 15 | 
 16 | impl ProxyMeta {
 17 |     pub fn new(icon: char, name: impl Into<Cow<'static, str>>) -> Self {
 18 |         Self {
 19 |             icon: icon as u32,
 20 |             name: name.into(),
 21 |             is_visible: true,
 22 |         }
 23 |     }
 24 | }
 25 | 
 26 | impl Default for ProxyMeta {
 27 |     fn default() -> Self {
 28 |         Self::new('?', "Entity")
 29 |     }
 30 | }
 31 | 
 32 | impl Proxy for ProxyMeta {
 33 |     fn insert(self, world: &mut World, entity: Entity) {
 34 |         let mut v = ComputedVisibility::not_visible();
 35 |         v.set_visible_in_view();
 36 | 
 37 |         world.entity_mut(entity).insert_bundle((
 38 |             Name::new(self.name),
 39 |             Visibility {
 40 |                 is_visible: self.is_visible,
 41 |             },
 42 |             v,
 43 |         ));
 44 |     }
 45 | }
 46 | 
 47 | impl ComponentEditor for ProxyMeta {
 48 |     fn ui(ui: &mut Ui, style: &Style, component: &mut dyn Reflect) {
 49 |         let data = component.downcast_mut::<DynamicStruct>().unwrap();
 50 | 
 51 |         ui.horizontal(|ui| {
 52 |             let frame = Frame::none().inner_margin(style::Margin::symmetric(2.0, 3.0));
 53 |             frame.fill(style.tab_base).show(ui, |ui| {
 54 |                 /*
 55 |                 if false {
 56 |                     let icon = if self.lock.is_some() {
 57 |                         crate::blender::LOCKED
 58 |                     } else {
 59 |                         crate::blender::UNLOCKED
 60 |                     };
 61 |                     let widget = Button::new(icon.to_string()).frame(false);
 62 |                     if ui.add(widget).clicked() {
 63 |                         if self.lock.is_some() {
 64 |                             self.lock.take();
 65 |                         } else {
 66 |                             self.lock = Some(entity.index);
 67 |                         }
 68 |                     }
 69 |                     ui.add_space(4.0);
 70 |                 }
 71 |                 */
 72 | 
 73 |                 let icon_field = data.get_field_mut::<u32>("icon").unwrap();
 74 | 
 75 |                 let icon_char = char::from_u32(*icon_field).unwrap();
 76 |                 let icon = text::LayoutJob::simple_singleline(
 77 |                     icon_char.into(),
 78 |                     FontId::proportional(16.0),
 79 |                     style.input_text,
 80 |                 );
 81 | 
 82 |                 let InnerResponse { inner, response } = ui.menu_button(icon, |ui| {
 83 |                     style.for_scrollbar(ui);
 84 |                     let scroll = ScrollArea::vertical().auto_shrink([false; 2]);
 85 |                     scroll.id_source("inspector icons").show(ui, |ui| {
 86 |                         style.set_theme_visuals(ui);
 87 |                         style.scrollarea(ui);
 88 |                         ui.set_width(300.0);
 89 |                         ui.horizontal_wrapped(|ui| {
 90 |                             for c in 0xE900..=0xEB99 {
 91 |                                 let c = char::from_u32(c).unwrap();
 92 |                                 if ui.button(String::from(c)).clicked() {
 93 |                                     ui.close_menu();
 94 |                                     return Some(c);
 95 |                                 }
 96 |                             }
 97 | 
 98 |                             None
 99 |                         })
100 |                     })
101 |                 });
102 |                 response.on_hover_cursor(egui::CursorIcon::PointingHand);
103 | 
104 |                 if let Some(icon) = inner.and_then(|r| r.inner.inner) {
105 |                     *icon_field = icon as u32;
106 |                 }
107 | 
108 |                 ui.add_space(4.0);
109 | 
110 |                 let name = data.get_field_mut::<Cow<'static, str>>("name").unwrap();
111 | 
112 |                 let text = TextEdit::singleline(name.to_mut());
113 |                 ui.add(text.desired_width(f32::INFINITY));
114 |             });
115 |         });
116 |     }
117 | }
118 | 


--------------------------------------------------------------------------------
/src/scene/component/mod.rs:
--------------------------------------------------------------------------------
 1 | pub mod editor;
 2 | pub mod proxy;
 3 | 
 4 | mod handle;
 5 | mod light;
 6 | mod meta;
 7 | mod transform;
 8 | 
 9 | pub use self::editor::{reflect_component_editor, ComponentEditor, ReflectComponentEditor};
10 | pub use self::handle::ProxyHandle;
11 | pub use self::light::ProxyPointLight;
12 | pub use self::meta::ProxyMeta;
13 | pub use self::proxy::{Proxy, ReflectProxy};
14 | pub use self::transform::ProxyTransform;
15 | 
16 | pub struct EditorPlugin;
17 | 
18 | impl bevy::app::Plugin for EditorPlugin {
19 |     fn build(&self, app: &mut bevy::app::App) {
20 |         use bevy::prelude::*;
21 | 
22 |         app.add_plugin(crate::scene::ScenePlugin)
23 |             .register_type::<ProxyMeta>()
24 |             .register_type::<ProxyTransform>()
25 |             .register_type::<ProxyPointLight>()
26 |             .register_type::<ProxyHandle<Mesh>>()
27 |             .register_type::<ProxyHandle<StandardMaterial>>();
28 |     }
29 | }
30 | 
31 | impl ComponentEditor for bevy::prelude::Parent {
32 |     fn skip() -> bool {
33 |         true
34 |     }
35 | }
36 | 
37 | impl ComponentEditor for bevy::prelude::Children {
38 |     fn skip() -> bool {
39 |         true
40 |     }
41 | }
42 | 


--------------------------------------------------------------------------------
/src/scene/component/proxy.rs:
--------------------------------------------------------------------------------
 1 | use bevy::prelude::*;
 2 | use bevy::reflect::FromType;
 3 | 
 4 | pub trait Proxy {
 5 |     fn insert(self, world: &mut World, entity: Entity);
 6 | }
 7 | 
 8 | #[derive(Clone)]
 9 | pub struct ReflectProxy {
10 |     resolve_and_add_func: fn(&mut World, Entity, &dyn Reflect),
11 | }
12 | 
13 | impl ReflectProxy {
14 |     pub fn resolve_and_add(&self, world: &mut World, entity: Entity, proxy: &dyn Reflect) {
15 |         (self.resolve_and_add_func)(world, entity, proxy);
16 |     }
17 | }
18 | 
19 | impl<T: Proxy + FromWorld + Reflect> FromType<T> for ReflectProxy {
20 |     fn from_type() -> Self {
21 |         Self {
22 |             resolve_and_add_func: |world, entity, reflected_proxy| {
23 |                 let mut proxy = T::from_world(world);
24 |                 proxy.apply(reflected_proxy);
25 |                 proxy.insert(world, entity);
26 |             },
27 |         }
28 |     }
29 | }
30 | 


--------------------------------------------------------------------------------
/src/scene/component/transform.rs:
--------------------------------------------------------------------------------
 1 | use super::{ComponentEditor, Proxy, ReflectComponentEditor, ReflectProxy};
 2 | use crate::ui::icon;
 3 | use bevy::prelude::*;
 4 | use bevy::reflect::FromReflect;
 5 | use std::borrow::Cow;
 6 | 
 7 | #[derive(Component, Reflect, FromReflect)]
 8 | #[reflect(Component, Proxy, ComponentEditor)]
 9 | pub struct ProxyTransform {
10 |     pub translation: Vec3,
11 |     pub rotation: Quat,
12 |     pub scale: Vec3,
13 | }
14 | 
15 | impl ProxyTransform {
16 |     pub fn to_local(&self) -> Transform {
17 |         Transform {
18 |             translation: self.translation,
19 |             rotation: self.rotation,
20 |             scale: self.scale,
21 |         }
22 |     }
23 | 
24 |     pub fn to_global(&self) -> GlobalTransform {
25 |         self.to_local().into()
26 |     }
27 | }
28 | 
29 | impl Default for ProxyTransform {
30 |     fn default() -> Self {
31 |         Self {
32 |             translation: Vec3::ZERO,
33 |             rotation: Quat::IDENTITY,
34 |             scale: Vec3::ONE,
35 |         }
36 |     }
37 | }
38 | 
39 | impl Proxy for ProxyTransform {
40 |     fn insert(self, world: &mut World, entity: Entity) {
41 |         world
42 |             .entity_mut(entity)
43 |             .insert_bundle((self.to_local(), GlobalTransform::default()));
44 |     }
45 | }
46 | 
47 | impl ComponentEditor for ProxyTransform {
48 |     fn desc() -> (char, Cow<'static, str>) {
49 |         (icon::ORIENTATION_LOCAL, "Transform".into())
50 |     }
51 | }
52 | 


--------------------------------------------------------------------------------
/src/scene/context.rs:
--------------------------------------------------------------------------------
  1 | use crate::scene::{ReflectEntity, ReflectScene};
  2 | use crate::util::anymap::AnyMap;
  3 | use bevy::prelude::{AssetServer, Children};
  4 | use bevy::reflect::{
  5 |     FromReflect, GetField, GetTupleField, GetTupleStructField, Reflect, ReflectMut, ReflectRef,
  6 |     TypeRegistry,
  7 | };
  8 | 
  9 | pub struct SelectedEntityId(usize);
 10 | 
 11 | pub struct EditorContext<'a> {
 12 |     pub scene: &'a mut ReflectScene,
 13 |     pub types: &'a TypeRegistry,
 14 |     pub assets: &'a mut AssetServer,
 15 |     pub state: &'a mut AnyMap,
 16 | }
 17 | 
 18 | impl<'a> EditorContext<'a> {
 19 |     pub fn select(&mut self, entity: usize) {
 20 |         bevy::log::info!("select entity: {}", entity);
 21 |         self.state.insert(SelectedEntityId(entity));
 22 |     }
 23 | 
 24 |     pub fn selected_index(&mut self, lock: Option<usize>) -> Option<usize> {
 25 |         lock.or_else(|| unsafe {
 26 |             self.state
 27 |                 .query::<Option<&SelectedEntityId>>()
 28 |                 .map(|id| id.0)
 29 |         })
 30 |     }
 31 | 
 32 |     pub fn find_selected(&mut self, lock: Option<usize>) -> Option<EntityEditor> {
 33 |         let index = self.selected_index(lock)?;
 34 |         self.get(index)
 35 |     }
 36 | 
 37 |     pub fn get_scene<'s>(
 38 |         scene: &'s mut ReflectScene,
 39 |         assets: &'s mut AssetServer,
 40 |         types: &'s TypeRegistry,
 41 |         index: usize,
 42 |     ) -> Option<EntityEditor<'s>> {
 43 |         scene.entities.get_mut(index).map(|entity| EntityEditor {
 44 |             index,
 45 |             entity,
 46 |             types,
 47 |             assets,
 48 |         })
 49 |     }
 50 | 
 51 |     pub fn get(&mut self, index: usize) -> Option<EntityEditor> {
 52 |         Self::get_scene(self.scene, self.assets, self.types, index)
 53 |     }
 54 | }
 55 | 
 56 | pub struct EntityEditor<'a> {
 57 |     pub index: usize,
 58 |     pub types: &'a TypeRegistry,
 59 |     pub entity: &'a mut ReflectEntity,
 60 |     pub assets: &'a mut AssetServer,
 61 | }
 62 | 
 63 | impl<'a> EntityEditor<'a> {
 64 |     #[inline]
 65 |     pub fn has<T: Reflect>(&self) -> bool {
 66 |         let type_name = std::any::type_name::<T>();
 67 |         self.entity
 68 |             .components
 69 |             .iter()
 70 |             .any(|c| c.type_name() == type_name)
 71 |     }
 72 | 
 73 |     #[inline]
 74 |     pub fn without<T: Reflect>(&self) -> bool {
 75 |         let type_name = std::any::type_name::<T>();
 76 |         self.entity
 77 |             .components
 78 |             .iter()
 79 |             .all(|c| c.type_name() != type_name)
 80 |     }
 81 | 
 82 |     #[inline]
 83 |     pub fn children(&self) -> Option<&(dyn bevy::reflect::List + 'static)> {
 84 |         let type_name = std::any::type_name::<Children>();
 85 |         let children = self
 86 |             .entity
 87 |             .components
 88 |             .iter()
 89 |             .find(|c| c.type_name() == type_name)?;
 90 | 
 91 |         let reflect = children.reflect_ref();
 92 | 
 93 |         let reflect = if let ReflectRef::TupleStruct(reflect) = reflect {
 94 |             reflect
 95 |         } else {
 96 |             return None;
 97 |         };
 98 | 
 99 |         if let ReflectRef::List(list) = reflect.field(0)?.reflect_ref() {
100 |             Some(list)
101 |         } else {
102 |             None
103 |         }
104 |     }
105 | }
106 | 
107 | impl ReflectEntityGetters for ReflectEntity {
108 |     fn component_ref<R: Reflect>(&self) -> Option<ReflectRef> {
109 |         let type_name = std::any::type_name::<R>();
110 |         self.components
111 |             .iter()
112 |             .find(|c| c.type_name() == type_name)
113 |             .map(|r| r.reflect_ref())
114 |     }
115 | 
116 |     fn component_mut<R: Reflect>(&mut self) -> Option<ReflectMut> {
117 |         let type_name = std::any::type_name::<R>();
118 |         self.components
119 |             .iter_mut()
120 |             .find(|c| c.type_name() == type_name)
121 |             .map(|r| r.reflect_mut())
122 |     }
123 | 
124 |     fn component_read<R: FromReflect + Sized>(&self) -> Option<R> {
125 |         let type_name = std::any::type_name::<R>();
126 |         self.components
127 |             .iter()
128 |             .find(|c| c.type_name() == type_name)
129 |             .and_then(|r| R::from_reflect(r.as_ref()))
130 |     }
131 | }
132 | 
133 | pub trait ReflectEntityGetters {
134 |     fn component_ref<R: Reflect>(&self) -> Option<ReflectRef>;
135 |     fn component_mut<R: Reflect>(&mut self) -> Option<ReflectMut>;
136 |     fn component_read<R: FromReflect>(&self) -> Option<R>;
137 | 
138 |     fn has<T: Reflect>(&self) -> bool {
139 |         self.component_ref::<T>().is_some()
140 |     }
141 | 
142 |     fn without<T: Reflect>(&self) -> bool {
143 |         self.component_ref::<T>().is_none()
144 |     }
145 | 
146 |     fn children(&self) -> Option<&(dyn bevy::reflect::List + 'static)> {
147 |         let reflect = if let ReflectRef::TupleStruct(reflect) = self.component_ref::<Children>()? {
148 |             reflect
149 |         } else {
150 |             return None;
151 |         };
152 |         if let ReflectRef::List(list) = reflect.field(0)?.reflect_ref() {
153 |             Some(list)
154 |         } else {
155 |             None
156 |         }
157 |     }
158 | 
159 |     fn tuple_field_ref<R: Reflect, F: Reflect>(&self, index: usize) -> Option<&F> {
160 |         match self.component_ref::<R>()? {
161 |             ReflectRef::Tuple(s) => s.get_field(index),
162 |             ReflectRef::TupleStruct(s) => s.get_field(index),
163 |             _ => None,
164 |         }
165 |     }
166 | 
167 |     fn tuple_field_mut<R: Reflect, F: Reflect>(&mut self, index: usize) -> Option<&mut F> {
168 |         match self.component_mut::<R>()? {
169 |             ReflectMut::Tuple(s) => s.get_field_mut(index),
170 |             ReflectMut::TupleStruct(s) => s.get_field_mut(index),
171 |             _ => None,
172 |         }
173 |     }
174 | 
175 |     fn struct_field_ref<R: Reflect, F: Reflect>(&self, name: &str) -> Option<&F> {
176 |         match self.component_ref::<R>()? {
177 |             ReflectRef::Struct(s) => s.get_field(name),
178 |             _ => None,
179 |         }
180 |     }
181 | 
182 |     fn struct_field_mut<R: Reflect, F: Reflect>(&mut self, name: &str) -> Option<&mut F> {
183 |         match self.component_mut::<R>()? {
184 |             ReflectMut::Struct(s) => s.field_mut(name).and_then(|c| c.downcast_mut()),
185 |             _ => None,
186 |         }
187 |     }
188 | }
189 | 


--------------------------------------------------------------------------------
/src/scene/filebrowser.rs:
--------------------------------------------------------------------------------
 1 | use crate::ui::{icon, EditorTab, Style};
 2 | use bevy::asset::AssetIo;
 3 | use bevy::ecs::system::lifetimeless::SRes;
 4 | use bevy::ecs::system::SystemParamItem;
 5 | use bevy::prelude::*;
 6 | use std::ffi::OsStr;
 7 | use std::path::Path;
 8 | 
 9 | #[derive(Default, Component)]
10 | pub struct FileBrowser;
11 | 
12 | impl EditorTab for FileBrowser {
13 |     type Param = (SRes<Style>, SRes<AssetServer>);
14 | 
15 |     fn ui<'w>(
16 |         &mut self,
17 |         ui: &mut egui::Ui,
18 |         _entity: Entity,
19 |         (style, assets): &mut SystemParamItem<'w, '_, Self::Param>,
20 |     ) {
21 |         let rect = ui.available_rect_before_wrap();
22 |         ui.painter().rect_filled(rect, 0.0, style.panel);
23 |         let io = assets.asset_io();
24 |         read_dir(ui, io, ".".as_ref());
25 |     }
26 | }
27 | 
28 | fn read_dir(ui: &mut egui::Ui, io: &dyn AssetIo, path: &Path) {
29 |     ui.indent(&path, |ui| {
30 |         if let Ok(dir) = io.read_directory(path) {
31 |             for path in dir {
32 |                 let path_string = path.file_name().unwrap().to_string_lossy().to_string();
33 |                 if io.is_dir(&path) {
34 |                     ui.label(format!("{} {}", icon::FILE_FOLDER, path_string));
35 |                     read_dir(ui, io, &path);
36 |                 } else {
37 |                     let ext = path.extension().map(OsStr::to_string_lossy);
38 |                     let icon = if let Some(ext) = ext.as_deref() {
39 |                         match ext {
40 |                             "scene" => icon::SCENE_DATA,
41 |                             "material" => icon::MATERIAL_DATA,
42 |                             "image" => icon::TEXTURE_DATA,
43 |                             "mesh" => icon::MESH_DATA,
44 | 
45 |                             "shader" => icon::NODE_MATERIAL,
46 | 
47 |                             "gltf" | "glb" => icon::FILE_3D,
48 |                             "jpg" | "jpeg" | "png" => icon::FILE_IMAGE,
49 |                             "mp3" | "ogg" | "flac" | "wav" => icon::FILE_SOUND,
50 | 
51 |                             _ => icon::FILE,
52 |                         }
53 |                     } else {
54 |                         icon::FILE
55 |                     };
56 | 
57 |                     ui.label(format!("{} {}", icon, path_string));
58 |                 }
59 |             }
60 |         }
61 |     });
62 | }
63 | 


--------------------------------------------------------------------------------
/src/scene/gizmo.wgsl:
--------------------------------------------------------------------------------
  1 | struct View {
  2 |     view_proj: mat4x4<f32>,
  3 |     view: mat4x4<f32>,
  4 |     inverse_view: mat4x4<f32>,
  5 |     projection: mat4x4<f32>,
  6 |     world_position: vec3<f32>,
  7 | 
  8 |     width: f32,
  9 |     height: f32,
 10 | }
 11 | 
 12 | @group(0) @binding(0) var<uniform> view: View;
 13 | 
 14 | struct LineInput {
 15 |     @location(0) position: vec3<f32>,
 16 |     @location(1) color: vec4<f32>,
 17 | }
 18 | 
 19 | struct LineOutput {
 20 |     @builtin(position) position: vec4<f32>,
 21 |     @location(0) color: vec4<f32>,
 22 | }
 23 | 
 24 | @vertex
 25 | fn vs_main_line(in: LineInput) -> LineOutput {
 26 |     let position = view.view_proj * vec4<f32>(in.position, 1.0);
 27 |     return LineOutput(position, in.color);
 28 | }
 29 | 
 30 | @fragment
 31 | fn fs_main_line(in: LineOutput) -> @location(0) vec4<f32> {
 32 |     return in.color;
 33 | }
 34 | 
 35 | 
 36 | // https://asliceofrendering.com/scene%20helper/2020/01/05/InfiniteGrid/
 37 | 
 38 | fn inverse4x4(m: mat4x4<f32>) -> mat4x4<f32> {
 39 |     let a00 = m[0][0]; let a01 = m[0][1]; let a02 = m[0][2]; let a03 = m[0][3];
 40 |     let a10 = m[1][0]; let a11 = m[1][1]; let a12 = m[1][2]; let a13 = m[1][3];
 41 |     let a20 = m[2][0]; let a21 = m[2][1]; let a22 = m[2][2]; let a23 = m[2][3];
 42 |     let a30 = m[3][0]; let a31 = m[3][1]; let a32 = m[3][2]; let a33 = m[3][3];
 43 | 
 44 |     let b00 = a00 * a11 - a01 * a10;
 45 |     let b01 = a00 * a12 - a02 * a10;
 46 |     let b02 = a00 * a13 - a03 * a10;
 47 |     let b03 = a01 * a12 - a02 * a11;
 48 |     let b04 = a01 * a13 - a03 * a11;
 49 |     let b05 = a02 * a13 - a03 * a12;
 50 |     let b06 = a20 * a31 - a21 * a30;
 51 |     let b07 = a20 * a32 - a22 * a30;
 52 |     let b08 = a20 * a33 - a23 * a30;
 53 |     let b09 = a21 * a32 - a22 * a31;
 54 |     let b10 = a21 * a33 - a23 * a31;
 55 |     let b11 = a22 * a33 - a23 * a32;
 56 | 
 57 |     let det = b00 * b11 - b01 * b10 + b02 * b09 + b03 * b08 - b04 * b07 + b05 * b06;
 58 | 
 59 |     return mat4x4<f32>(
 60 |         (a11 * b11 - a12 * b10 + a13 * b09) / det,
 61 |         (a02 * b10 - a01 * b11 - a03 * b09) / det,
 62 |         (a31 * b05 - a32 * b04 + a33 * b03) / det,
 63 |         (a22 * b04 - a21 * b05 - a23 * b03) / det,
 64 |         (a12 * b08 - a10 * b11 - a13 * b07) / det,
 65 |         (a00 * b11 - a02 * b08 + a03 * b07) / det,
 66 |         (a32 * b02 - a30 * b05 - a33 * b01) / det,
 67 |         (a20 * b05 - a22 * b02 + a23 * b01) / det,
 68 |         (a10 * b10 - a11 * b08 + a13 * b06) / det,
 69 |         (a01 * b08 - a00 * b10 - a03 * b06) / det,
 70 |         (a30 * b04 - a31 * b02 + a33 * b00) / det,
 71 |         (a21 * b02 - a20 * b04 - a23 * b00) / det,
 72 |         (a11 * b07 - a10 * b09 - a12 * b06) / det,
 73 |         (a00 * b09 - a01 * b07 + a02 * b06) / det,
 74 |         (a31 * b01 - a30 * b03 - a32 * b00) / det,
 75 |         (a20 * b03 - a21 * b01 + a22 * b00) / det,
 76 |     );
 77 | }
 78 | 
 79 | struct GridOutput {
 80 |     @builtin(position) position: vec4<f32>,
 81 |     @location(0) near: vec3<f32>,
 82 |     @location(1) far: vec3<f32>,
 83 |     @location(2) uv: vec2<f32>,
 84 | }
 85 | 
 86 | fn unproject_point(x: f32, y: f32, z: f32) -> vec3<f32> {
 87 |     let unprojected = inverse4x4(view.view_proj) * vec4<f32>(x, y, z, 1.0);
 88 |     return unprojected.xyz / unprojected.w;
 89 | }
 90 | 
 91 | fn resolution() -> vec2<f32> {
 92 |     return vec2<f32>(view.width, view.height);
 93 | }
 94 | 
 95 | @vertex
 96 | fn vs_main_grid(@builtin(vertex_index) in_vertex_index: u32) -> GridOutput {
 97 |     let u = f32((in_vertex_index << 1u) & 2u);
 98 |     let v = f32(in_vertex_index & 2u);
 99 |     let u = u - 1.0;
100 |     let v = 1.0 - v;
101 | 
102 |     return GridOutput(
103 |         vec4<f32>(u, v, 0.0, 1.0),
104 |         unproject_point(u, v, 1.000),
105 |         unproject_point(u, v, 0.0000001),
106 |         vec2<f32>(u, v),
107 |     );
108 | }
109 | 
110 | fn grid(pos: vec3<f32>, scale: f32, axis: bool) -> vec4<f32> {
111 |     let coord = pos.xz * scale; // use the scale variable to set the distance between the lines
112 |     let derivative = fwidth(coord);
113 |     let grid = abs(fract(coord - 0.5) - 0.5) / derivative;
114 |     let grid_line = min(grid.x, grid.y);
115 |     let minimumz = min(derivative.y, 1.0);
116 |     let minimumx = min(derivative.x, 1.0);
117 |     let alpha = 1.0 - min(grid_line, 1.0);
118 |     var color = vec4<f32>(0.01) * alpha;
119 |     if (axis) {
120 |         let extra = 1.0 / scale;
121 |         // z axis
122 |         if (pos.x > -extra * minimumx && pos.x < extra * minimumx) {
123 |             color.x = 0.0;
124 |             color.y = 0.0;
125 |             color.z = 0.1 * alpha;
126 |             //color.w = 1.0;
127 |         }
128 |         // x axis
129 |         if (pos.z > -extra * minimumz && pos.z < extra * minimumz) {
130 |             color.x = 0.1 * alpha;
131 |             color.y = 0.0;
132 |             color.z = 0.0;
133 |             //color.w = 1.0;
134 |         }
135 |     }
136 | 
137 |     return color;
138 | }
139 | 
140 | struct FragOut {
141 |     @builtin(frag_depth) depth: f32,
142 |     @location(0) color: vec4<f32>,
143 | }
144 | 
145 | @fragment
146 | fn fs_main_grid(in: GridOutput) -> FragOut {
147 |     let t = -in.near.y / (in.far.y - in.near.y);
148 |     let pos = in.near + t * (in.far - in.near);
149 | 
150 |     let near = 0.0005;
151 |     let clip = view.view_proj * vec4<f32>(pos.xyz, 1.0);
152 |     let depth = clip.z / clip.w;
153 |     let fading = 1.0 - near / depth;
154 | 
155 |     let color = (grid(pos, 1.0, false) + grid(pos, 0.1, true)) * f32(t > 0.0);
156 |     return FragOut(depth, color * fading);
157 | }


--------------------------------------------------------------------------------
/src/scene/hierarchy.rs:
--------------------------------------------------------------------------------
  1 | use super::component::ProxyMeta;
  2 | use super::context::{EditorContext, ReflectEntityGetters};
  3 | use super::{ReflectScene, SceneMapping};
  4 | use crate::ui::{icon, EditorTab, Style};
  5 | use crate::util::anymap::AnyMap;
  6 | use bevy::ecs::system::lifetimeless::{SRes, SResMut};
  7 | use bevy::ecs::system::SystemParamItem;
  8 | use bevy::prelude::*;
  9 | use bevy::reflect::TypeRegistry;
 10 | use egui::style::Margin;
 11 | use egui::widgets::TextEdit;
 12 | use egui::*;
 13 | use std::borrow::Cow;
 14 | 
 15 | #[derive(Default, Component)]
 16 | pub struct Hierarchy {
 17 |     search: String,
 18 | }
 19 | 
 20 | impl EditorTab for Hierarchy {
 21 |     type Param = (
 22 |         SRes<Style>,
 23 |         SRes<Handle<ReflectScene>>,
 24 |         SResMut<AnyMap>,
 25 |         SResMut<Assets<ReflectScene>>,
 26 |         SRes<TypeRegistry>,
 27 |         SResMut<AssetServer>,
 28 |     );
 29 | 
 30 |     fn ui<'w>(
 31 |         &mut self,
 32 |         ui: &mut egui::Ui,
 33 |         _entity: Entity,
 34 |         (style, scene, state, scenes, types, assets): &mut SystemParamItem<'w, '_, Self::Param>,
 35 |     ) {
 36 |         let scene = scenes.get_mut(scene).unwrap();
 37 |         let mut ctx = EditorContext {
 38 |             scene,
 39 |             state,
 40 |             types,
 41 |             assets,
 42 |         };
 43 | 
 44 |         let rect = ui.available_rect_before_wrap();
 45 |         ui.painter().rect_filled(rect, 0.0, style.panel);
 46 | 
 47 |         ui.scope(|ui| {
 48 |             ui.spacing_mut().item_spacing = vec2(0.0, 0.0);
 49 |             style.set_theme_visuals(ui);
 50 | 
 51 |             ui.horizontal(|ui| {
 52 |                 let frame = Frame::none().inner_margin(Margin::symmetric(3.0, 3.0));
 53 |                 frame.fill(style.tab_base).show(ui, |ui| {
 54 |                     let text = TextEdit::singleline(&mut self.search);
 55 |                     ui.add(text.desired_width(f32::INFINITY));
 56 |                 });
 57 |             });
 58 | 
 59 |             style.for_scrollbar(ui);
 60 | 
 61 |             let scroll = ScrollArea::vertical().auto_shrink([false; 2]);
 62 |             scroll.id_source("hierarchy scroll").show(ui, |ui| {
 63 |                 style.scrollarea(ui);
 64 |                 for index in 0..ctx.scene.entities.len() {
 65 |                     if ctx.get(index).unwrap().without::<Parent>() {
 66 |                         item_widget(0, index, ui, style, &mut ctx);
 67 |                     }
 68 |                 }
 69 |             });
 70 |         });
 71 |     }
 72 | }
 73 | 
 74 | #[derive(Clone, Debug, Default)]
 75 | struct State {
 76 |     open: bool,
 77 | }
 78 | 
 79 | impl State {
 80 |     pub fn load(ctx: &Context, id: Id) -> Self {
 81 |         ctx.data().get_temp(id).unwrap_or(Self { open: true })
 82 |     }
 83 | 
 84 |     fn store(self, ctx: &Context, id: Id) {
 85 |         ctx.data().insert_temp(id, self);
 86 |     }
 87 | 
 88 |     pub fn toggle(&mut self, ui: &Ui) {
 89 |         self.open = !self.open;
 90 |         ui.ctx().request_repaint();
 91 |     }
 92 | }
 93 | 
 94 | fn item_widget(level: usize, entity: usize, ui: &mut Ui, style: &Style, ctx: &mut EditorContext) {
 95 |     let id = Id::new((entity, "#hierarchy_item"));
 96 |     let mut state = State::load(ui.ctx(), id);
 97 |     let is_open = state.open;
 98 | 
 99 |     let fill_color = style.panel;
100 |     let active_color = style.selection;
101 |     let tri_color = style.input_text;
102 |     let text_color = style.input_text;
103 | 
104 |     let full_width = ui.available_width();
105 |     let full_size = vec2(full_width, 20.0);
106 |     let (rect, response_bg) = ui.allocate_exact_size(full_size, Sense::hover());
107 | 
108 |     let bg_color = if response_bg.hovered() || ctx.selected_index(None) == Some(entity) {
109 |         active_color
110 |     } else {
111 |         fill_color
112 |     };
113 | 
114 |     ui.painter().rect_filled(response_bg.rect, 0.0, bg_color);
115 | 
116 |     let offset = vec2(16.0 * level as f32, 0.0);
117 | 
118 |     let tri_icon_pos = rect.left_center() + vec2(8.0, 0.0) + offset;
119 |     let custom_icon_pos = rect.left_center() + vec2(23.0, 0.0) + offset;
120 |     let label_pos = rect.left_center() + vec2(36.0, 0.0) + offset;
121 |     let hide_icon_pos = rect.right_center() - vec2(16.0, 0.0);
122 | 
123 |     let cursor = egui::CursorIcon::PointingHand;
124 |     let sense = Sense::click();
125 | 
126 |     let editor = ctx.get(entity).unwrap();
127 | 
128 |     if let Some(icon) = editor.entity.struct_field_mut::<ProxyMeta, u32>("icon") {
129 |         let rect = Rect::from_center_size(custom_icon_pos, vec2(16.0, 20.0));
130 |         let _response = ui.allocate_rect(rect, sense).on_hover_cursor(cursor);
131 | 
132 |         ui.painter().text(
133 |             custom_icon_pos,
134 |             Align2::CENTER_CENTER,
135 |             char::from_u32(*icon).unwrap(),
136 |             FontId::proportional(16.0),
137 |             text_color,
138 |         );
139 |     }
140 | 
141 |     if let Some(name) = editor
142 |         .entity
143 |         .struct_field_mut::<ProxyMeta, Cow<'static, str>>("name")
144 |         .map(Cow::to_mut)
145 |     {
146 |         ui.painter().text(
147 |             label_pos,
148 |             Align2::LEFT_CENTER,
149 |             name.clone(),
150 |             FontId::proportional(14.0),
151 |             text_color,
152 |         );
153 |     }
154 | 
155 |     if let Some(is_visible) = editor
156 |         .entity
157 |         .struct_field_mut::<ProxyMeta, bool>("is_visible")
158 |     {
159 |         let rect = Rect::from_center_size(hide_icon_pos, vec2(16.0, 20.0));
160 |         let response = ui.allocate_rect(rect, sense).on_hover_cursor(cursor);
161 |         if response.clicked() {
162 |             *is_visible = !*is_visible;
163 |         }
164 |         ui.painter().text(
165 |             hide_icon_pos,
166 |             Align2::CENTER_CENTER,
167 |             if *is_visible {
168 |                 icon::HIDE_OFF
169 |             } else {
170 |                 icon::HIDE_ON
171 |             },
172 |             FontId::proportional(16.0),
173 |             text_color,
174 |         );
175 |     }
176 | 
177 |     let has_children = editor
178 |         .children()
179 |         .map_or(false, |children| !children.is_empty());
180 | 
181 |     if has_children {
182 |         let rect = Rect::from_center_size(tri_icon_pos, vec2(16.0, 20.0));
183 |         let response = ui.allocate_rect(rect, sense).on_hover_cursor(cursor);
184 |         if response.clicked() {
185 |             state.toggle(ui);
186 |         }
187 |         ui.painter().text(
188 |             tri_icon_pos,
189 |             Align2::CENTER_CENTER,
190 |             if is_open {
191 |                 icon::DISCLOSURE_TRI_DOWN
192 |             } else {
193 |                 icon::DISCLOSURE_TRI_RIGHT
194 |             },
195 |             FontId::proportional(16.0),
196 |             tri_color,
197 |         );
198 |     }
199 | 
200 |     if let Some(children) = editor.children() {
201 |         let children: Vec<u32> = children
202 |             .iter()
203 |             .map(|e| e.downcast_ref::<Entity>().unwrap().id())
204 |             .collect();
205 | 
206 |         if is_open {
207 |             for entity in children {
208 |                 let mapping = ctx.state.get::<SceneMapping>().unwrap();
209 |                 let entity = mapping.entity[&entity];
210 |                 item_widget(level + 1, entity, ui, style, ctx);
211 |             }
212 |         }
213 |     }
214 | 
215 |     if response_bg.interact(egui::Sense::click()).clicked() {
216 |         ctx.select(entity);
217 |     }
218 | 
219 |     state.store(ui.ctx(), id);
220 | }
221 | 


--------------------------------------------------------------------------------
/src/scene/inspector.rs:
--------------------------------------------------------------------------------
  1 | use super::component::{reflect_component_editor, ComponentEditor, ReflectComponentEditor};
  2 | use super::context::EditorContext;
  3 | use super::ReflectScene;
  4 | use crate::ui::{EditorTab, Style};
  5 | use crate::util::anymap::AnyMap;
  6 | use bevy::ecs::system::lifetimeless::{SRes, SResMut};
  7 | use bevy::ecs::system::SystemParamItem;
  8 | use bevy::prelude::*;
  9 | use bevy::reflect::{FromType, Reflect, TypeRegistry};
 10 | use egui::style::Margin;
 11 | use egui::*;
 12 | 
 13 | #[derive(Default, Component)]
 14 | pub struct Inspector {
 15 |     lock: Option<usize>,
 16 | }
 17 | 
 18 | impl EditorTab for Inspector {
 19 |     type Param = (
 20 |         SRes<Style>,
 21 |         SRes<Handle<ReflectScene>>,
 22 |         SResMut<AnyMap>,
 23 |         SResMut<Assets<ReflectScene>>,
 24 |         SRes<TypeRegistry>,
 25 |         SResMut<AssetServer>,
 26 |     );
 27 | 
 28 |     fn ui<'w>(
 29 |         &mut self,
 30 |         ui: &mut egui::Ui,
 31 |         _entity: Entity,
 32 |         (style, scene, state, scenes, types, assets): &mut SystemParamItem<'w, '_, Self::Param>,
 33 |     ) {
 34 |         let scene = scenes.get_mut(scene).unwrap();
 35 |         let mut ctx = EditorContext {
 36 |             scene,
 37 |             state,
 38 |             types,
 39 |             assets,
 40 |         };
 41 | 
 42 |         let rect = ui.available_rect_before_wrap();
 43 |         ui.painter().rect_filled(rect, 0.0, style.panel);
 44 | 
 45 |         let entity = match ctx.find_selected(self.lock) {
 46 |             Some(entity) => entity,
 47 |             None => {
 48 |                 Frame::none()
 49 |                     .inner_margin(Margin::same(16.0))
 50 |                     .show(ui, |ui| {
 51 |                         ui.vertical_centered_justified(|ui| ui.label("Select something..."));
 52 |                     });
 53 |                 return;
 54 |             }
 55 |         };
 56 | 
 57 |         ui.scope(|ui| {
 58 |             ui.spacing_mut().item_spacing = vec2(0.0, 0.0);
 59 | 
 60 |             style.set_theme_visuals(ui);
 61 |             style.for_scrollbar(ui);
 62 | 
 63 |             let scroll = ScrollArea::vertical().auto_shrink([false; 2]);
 64 |             scroll.show(ui, |ui| {
 65 |                 style.scrollarea(ui);
 66 | 
 67 |                 let frame = Frame::none();
 68 |                 frame.fill(style.panel).show(ui, |ui| {
 69 |                     for component in entity.entity.components.iter_mut().map(AsMut::as_mut) {
 70 |                         let type_name = component.type_name();
 71 | 
 72 |                         {
 73 |                             use bevy::prelude::*;
 74 |                             add_custom_editor_if::<Parent>(entity.types, type_name);
 75 |                             add_custom_editor_if::<Children>(entity.types, type_name);
 76 |                         }
 77 | 
 78 |                         let registry = entity.types.read();
 79 |                         let registration = match registry.get_with_name(type_name) {
 80 |                             Some(registration) => registration,
 81 |                             None => continue,
 82 |                         };
 83 | 
 84 |                         if let Some(editor) = registration.data::<ReflectComponentEditor>() {
 85 |                             if editor.skip() {
 86 |                                 continue;
 87 |                             }
 88 |                             editor.ui(ui, style, component);
 89 |                         } else {
 90 |                             let name = registration.short_name();
 91 |                             reflect_component_editor(ui, style, component, ' ', name);
 92 |                         }
 93 | 
 94 |                         let width = ui.available_width();
 95 |                         let (_, separator) = ui.allocate_space(vec2(width, 1.0));
 96 |                         ui.painter().rect_filled(separator, 0.0, style.separator);
 97 |                     }
 98 |                 });
 99 |             });
100 |         });
101 |     }
102 | }
103 | 
104 | fn add_custom_editor_if<T: ComponentEditor + Reflect>(types: &TypeRegistry, type_name: &str) {
105 |     if type_name == std::any::type_name::<T>() {
106 |         let mut registry = types.write();
107 |         if let Some(registration) = registry.get_with_name_mut(type_name) {
108 |             let data: ReflectComponentEditor = FromType::<T>::from_type();
109 |             registration.insert(data);
110 |         }
111 |     }
112 | }
113 | 


--------------------------------------------------------------------------------
/src/scene/mod.rs:
--------------------------------------------------------------------------------
 1 | pub mod asset;
 2 | pub mod component;
 3 | pub mod context;
 4 | pub mod filebrowser;
 5 | pub mod gizmo;
 6 | pub mod hierarchy;
 7 | pub mod inspector;
 8 | pub mod tab;
 9 | 
10 | pub use self::{
11 |     asset::{
12 |         ReflectEntity, ReflectScene, ReflectSceneLoader, ReflectSceneSpawnError,
13 |         ReflectSceneSpawner, SceneMapping,
14 |     },
15 |     filebrowser::FileBrowser,
16 |     gizmo::{GizmoPlugin, GIZMO_DRIVER},
17 |     hierarchy::Hierarchy,
18 |     inspector::Inspector,
19 |     tab::SceneTab,
20 | };
21 | 
22 | use bevy::ecs::event::Events;
23 | use bevy::prelude::*;
24 | 
25 | #[derive(Default)]
26 | pub struct ScenePlugin;
27 | 
28 | impl Plugin for ScenePlugin {
29 |     fn build(&self, app: &mut App) {
30 |         app.add_asset::<ReflectScene>()
31 |             .init_asset_loader::<ReflectSceneLoader>()
32 |             .init_resource::<ReflectSceneSpawner>()
33 |             .add_system_to_stage(
34 |                 CoreStage::PreUpdate,
35 |                 scene_spawner_system.exclusive_system().at_end(),
36 |             );
37 |     }
38 | }
39 | 
40 | pub fn scene_spawner_system(world: &mut World) {
41 |     world.resource_scope(|world, mut spawner: Mut<ReflectSceneSpawner>| {
42 |         let scene_asset_events = world.resource::<Events<AssetEvent<ReflectScene>>>();
43 | 
44 |         let mut handles = Vec::new();
45 |         let spawner = &mut *spawner;
46 |         for event in spawner.event_reader.iter(scene_asset_events) {
47 |             if let AssetEvent::Modified { handle } = event {
48 |                 if spawner.scenes.contains_key(handle) {
49 |                     handles.push(handle.clone_weak());
50 |                 }
51 |             }
52 |         }
53 | 
54 |         spawner.despawn_queued(world).unwrap();
55 |         spawner.spawn_queued(world).unwrap();
56 |         spawner.update_spawned(world, &handles).unwrap();
57 |         spawner.set_scene_instance_parent_sync(world);
58 |     });
59 | }
60 | 


--------------------------------------------------------------------------------
/src/ui/icon.ttf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/lain-dono/shaderlab/fb496dc0178b955330c1cd4a8590c44b4a9b9cd9/src/ui/icon.ttf


--------------------------------------------------------------------------------
/src/ui/mod.rs:
--------------------------------------------------------------------------------
  1 | pub mod app;
  2 | pub mod field;
  3 | pub mod icon;
  4 | pub mod placeholder;
  5 | pub mod shell;
  6 | pub mod style;
  7 | pub mod tabs;
  8 | 
  9 | pub use self::app::{EditorPanel, EditorTab};
 10 | pub use self::placeholder::PlaceholderTab;
 11 | pub use self::style::Style;
 12 | pub use self::tabs::{NodeIndex, Split, SplitTree, Tab, TreeNode};
 13 | 
 14 | use bevy::ecs::system::StaticSystemParam;
 15 | use bevy::prelude::*;
 16 | use bevy::render::camera::RenderTarget;
 17 | use bevy::render::{render_graph::RenderGraph, RenderApp};
 18 | use bevy::window::WindowId;
 19 | 
 20 | #[derive(Debug, Hash, PartialEq, Eq, Clone, StageLabel)]
 21 | pub enum EditorStage {
 22 |     Root,
 23 |     Tabs,
 24 |     Finish,
 25 | }
 26 | 
 27 | pub struct EditorUiPlugin;
 28 | 
 29 | impl bevy::app::Plugin for EditorUiPlugin {
 30 |     fn build(&self, app: &mut bevy::app::App) {
 31 |         use self::app::*;
 32 |         use bevy::prelude::*;
 33 | 
 34 |         app.add_plugin(self::shell::EguiPlugin)
 35 |             .init_resource::<self::style::Style>()
 36 |             .init_resource::<SharedData>()
 37 |             .add_startup_system(setup_icon_font)
 38 |             .add_stage_after(
 39 |                 CoreStage::PreUpdate,
 40 |                 EditorStage::Root,
 41 |                 SystemStage::parallel(),
 42 |             )
 43 |             .add_stage_after(
 44 |                 CoreStage::Update,
 45 |                 EditorStage::Tabs,
 46 |                 SystemStage::parallel(),
 47 |             )
 48 |             .add_stage_before(
 49 |                 CoreStage::PostUpdate,
 50 |                 EditorStage::Finish,
 51 |                 SystemStage::parallel(),
 52 |             )
 53 |             .add_system_to_stage(EditorStage::Root, ui_root)
 54 |             .add_system_to_stage(EditorStage::Root, update_panel_render_target.after(ui_root))
 55 |             .add_system_to_stage(EditorStage::Finish, ui_tabs)
 56 |             .add_system_to_stage(EditorStage::Finish, ui_finish.after(ui_tabs))
 57 |             .add_editor_tab::<PlaceholderTab>();
 58 | 
 59 |         {
 60 |             let render_app = app.sub_app_mut(RenderApp);
 61 |             let mut graph = render_app.world.resource_mut::<RenderGraph>();
 62 | 
 63 |             // add egui nodes
 64 |             crate::ui::shell::setup_pipeline(&mut graph, WindowId::primary(), "ui_root");
 65 |         }
 66 |     }
 67 | }
 68 | 
 69 | fn setup_icon_font(mut context: ResMut<self::shell::EguiContext>) {
 70 |     let font = egui::FontData::from_static(include_bytes!("icon.ttf"));
 71 | 
 72 |     let mut fonts = egui::FontDefinitions::default();
 73 |     fonts.font_data.insert("blender".to_owned(), font);
 74 |     fonts.families.insert(
 75 |         egui::FontFamily::Name("blender".into()),
 76 |         vec!["Hack".to_owned(), "blender".into()],
 77 |     );
 78 |     fonts
 79 |         .families
 80 |         .get_mut(&egui::FontFamily::Proportional)
 81 |         .unwrap()
 82 |         .push("blender".to_owned());
 83 | 
 84 |     fonts
 85 |         .families
 86 |         .get_mut(&egui::FontFamily::Monospace)
 87 |         .unwrap()
 88 |         .push("blender".to_owned());
 89 | 
 90 |     let [ctx] = context.ctx_mut([WindowId::primary()]);
 91 |     ctx.set_fonts(fonts);
 92 | }
 93 | 
 94 | pub trait AddEditorTab {
 95 |     fn add_editor_tab<T: EditorTab + 'static>(&mut self) -> &mut Self;
 96 | }
 97 | 
 98 | impl AddEditorTab for bevy::app::App {
 99 |     fn add_editor_tab<T: EditorTab + 'static>(&mut self) -> &mut Self {
100 |         fn system<T: EditorTab>(
101 |             mut context: ResMut<crate::ui::shell::EguiContext>,
102 |             mut panel_view: Query<(Entity, &EditorPanel, &mut T)>,
103 |             query: StaticSystemParam<T::Param>,
104 |         ) {
105 |             let [ctx] = context.ctx_mut([bevy::window::WindowId::primary()]);
106 |             let mut query = query.into_inner();
107 |             for (entity, viewport, mut tab) in panel_view.iter_mut() {
108 |                 if let Some(viewport) = viewport.viewport {
109 |                     let mut ui = egui::Ui::new(
110 |                         ctx.clone(),
111 |                         egui::LayerId::background(),
112 |                         egui::Id::new(entity),
113 |                         viewport,
114 |                         viewport,
115 |                     );
116 |                     tab.ui(&mut ui, entity, &mut query);
117 |                 }
118 |             }
119 |         }
120 | 
121 |         self.add_system_to_stage(EditorStage::Tabs, system::<T>);
122 |         self
123 |     }
124 | }
125 | 
126 | #[derive(Default, Component)]
127 | pub struct PanelRenderTarget {
128 |     pub texture_id: Option<egui::TextureId>,
129 | }
130 | 
131 | impl PanelRenderTarget {
132 |     pub fn create_render_target(images: &mut Assets<Image>) -> RenderTarget {
133 |         let size = wgpu::Extent3d {
134 |             width: 1,
135 |             height: 1,
136 |             depth_or_array_layers: 1,
137 |         };
138 | 
139 |         let mut image = Image {
140 |             texture_descriptor: wgpu::TextureDescriptor {
141 |                 label: None,
142 |                 size,
143 |                 dimension: wgpu::TextureDimension::D2,
144 |                 format: wgpu::TextureFormat::Bgra8UnormSrgb,
145 |                 mip_level_count: 1,
146 |                 sample_count: 1,
147 |                 usage: wgpu::TextureUsages::TEXTURE_BINDING
148 |                     | wgpu::TextureUsages::COPY_DST
149 |                     | wgpu::TextureUsages::RENDER_ATTACHMENT,
150 |             },
151 |             ..default()
152 |         };
153 | 
154 |         // fill image.data with zeroes
155 |         image.resize(size);
156 | 
157 |         RenderTarget::Image(images.add(image))
158 |     }
159 | }
160 | 
161 | pub fn update_panel_render_target(
162 |     mut context: ResMut<self::shell::EguiContext>,
163 |     mut images: ResMut<Assets<Image>>,
164 |     mut query: Query<(&mut PanelRenderTarget, &EditorPanel, &Camera)>,
165 | ) {
166 |     let [ctx] = context.ctx_mut([bevy::window::WindowId::primary()]);
167 |     let ppi = ctx.pixels_per_point();
168 | 
169 |     for (mut panel, tab, camera) in query.iter_mut() {
170 |         let handle = if let RenderTarget::Image(handle) = &camera.target {
171 |             handle
172 |         } else {
173 |             continue;
174 |         };
175 | 
176 |         if let Some(image) = images.get_mut(handle) {
177 |             if let Some(viewport) = tab.viewport {
178 |                 let width = (viewport.width() * ppi) as u32;
179 |                 let height = (viewport.height() * ppi) as u32;
180 | 
181 |                 panel.texture_id = Some(context.add_image(handle.clone_weak()));
182 | 
183 |                 image.resize(wgpu::Extent3d {
184 |                     width: width.max(1),
185 |                     height: height.max(1),
186 |                     depth_or_array_layers: 1,
187 |                 });
188 |             }
189 |         }
190 |     }
191 | }
192 | 


--------------------------------------------------------------------------------
/src/ui/placeholder.rs:
--------------------------------------------------------------------------------
 1 | use crate::ui::EditorTab;
 2 | use bevy::ecs::system::SystemParamItem;
 3 | use bevy::prelude::*;
 4 | 
 5 | #[derive(Default, Component)]
 6 | pub struct PlaceholderTab;
 7 | 
 8 | impl EditorTab for PlaceholderTab {
 9 |     type Param = Res<'static, crate::ui::Style>;
10 | 
11 |     fn ui<'w>(
12 |         &mut self,
13 |         ui: &mut egui::Ui,
14 |         _entity: Entity,
15 |         style: &mut SystemParamItem<'w, '_, Self::Param>,
16 |     ) {
17 |         let rect = ui.available_rect_before_wrap();
18 |         ui.painter().rect_filled(rect, 0.0, style.panel);
19 |     }
20 | }
21 | 


--------------------------------------------------------------------------------
/src/ui/shell/clipboard.rs:
--------------------------------------------------------------------------------
 1 | #[cfg(not(target_arch = "wasm32"))]
 2 | use {
 3 |     arboard::Clipboard,
 4 |     bevy::log,
 5 |     std::cell::{RefCell, RefMut},
 6 |     thread_local::ThreadLocal,
 7 | };
 8 | 
 9 | /// A resource for accessing clipboard.
10 | #[derive(Default)]
11 | pub struct EguiClipboard {
12 |     #[cfg(not(target_arch = "wasm32"))]
13 |     clipboard: ThreadLocal<Option<RefCell<Clipboard>>>,
14 |     #[cfg(target_arch = "wasm32")]
15 |     clipboard: String,
16 | }
17 | 
18 | #[cfg(target_arch = "wasm32")]
19 | impl EguiClipboard {
20 |     /// Gets clipboard contents. Returns [`None`] if clipboard provider is unavailable or returns an error.
21 |     #[allow(clippy::unnecessary_wraps)]
22 |     #[must_use]
23 |     pub fn contents(&self) -> Option<String> {
24 |         Some(self.clipboard.clone())
25 |     }
26 | 
27 |     /// Sets clipboard contents.
28 |     pub fn set_contents(&mut self, contents: &str) {
29 |         self.clipboard = contents.to_owned();
30 |     }
31 | }
32 | 
33 | #[cfg(not(target_arch = "wasm32"))]
34 | impl EguiClipboard {
35 |     /// Gets clipboard contents. Returns [`None`] if clipboard provider is unavailable or returns an error.
36 |     #[must_use]
37 |     pub fn contents(&self) -> Option<String> {
38 |         if let Some(mut clipboard) = self.get() {
39 |             match clipboard.get_text() {
40 |                 Ok(contents) => return Some(contents),
41 |                 Err(err) => log::info!("Failed to get clipboard contents: {:?}", err),
42 |             }
43 |         };
44 |         None
45 |     }
46 | 
47 |     /// Sets clipboard contents.
48 |     pub fn set_contents(&mut self, contents: &str) {
49 |         if let Some(mut clipboard) = self.get() {
50 |             if let Err(err) = clipboard.set_text(contents.to_owned()) {
51 |                 log::error!("Failed to set clipboard contents: {:?}", err);
52 |             }
53 |         }
54 |     }
55 | 
56 |     fn get(&self) -> Option<RefMut<Clipboard>> {
57 |         self.clipboard
58 |             .get_or(|| {
59 |                 Clipboard::new()
60 |                     .map(RefCell::new)
61 |                     .map_err(|err| log::info!("Failed to initialize clipboard: {:?}", err))
62 |                     .ok()
63 |             })
64 |             .as_ref()
65 |             .map(|cell| cell.borrow_mut())
66 |     }
67 | }
68 | 


--------------------------------------------------------------------------------
/src/ui/shell/convert.rs:
--------------------------------------------------------------------------------
  1 | use bevy::input::keyboard::KeyCode;
  2 | 
  3 | pub fn cursor_icon(cursor_icon: egui::CursorIcon) -> Option<bevy::window::CursorIcon> {
  4 |     match cursor_icon {
  5 |         egui::CursorIcon::Default => Some(bevy::window::CursorIcon::Default),
  6 |         egui::CursorIcon::PointingHand => Some(bevy::window::CursorIcon::Hand),
  7 |         egui::CursorIcon::ResizeHorizontal => Some(bevy::window::CursorIcon::EwResize),
  8 |         egui::CursorIcon::ResizeNeSw => Some(bevy::window::CursorIcon::NeswResize),
  9 |         egui::CursorIcon::ResizeNwSe => Some(bevy::window::CursorIcon::NwseResize),
 10 |         egui::CursorIcon::ResizeVertical => Some(bevy::window::CursorIcon::NsResize),
 11 |         egui::CursorIcon::Text => Some(bevy::window::CursorIcon::Text),
 12 |         egui::CursorIcon::Grab => Some(bevy::window::CursorIcon::Grab),
 13 |         egui::CursorIcon::Grabbing => Some(bevy::window::CursorIcon::Grabbing),
 14 |         egui::CursorIcon::ContextMenu => Some(bevy::window::CursorIcon::ContextMenu),
 15 |         egui::CursorIcon::Help => Some(bevy::window::CursorIcon::Help),
 16 |         egui::CursorIcon::Progress => Some(bevy::window::CursorIcon::Progress),
 17 |         egui::CursorIcon::Wait => Some(bevy::window::CursorIcon::Wait),
 18 |         egui::CursorIcon::Cell => Some(bevy::window::CursorIcon::Cell),
 19 |         egui::CursorIcon::Crosshair => Some(bevy::window::CursorIcon::Crosshair),
 20 |         egui::CursorIcon::VerticalText => Some(bevy::window::CursorIcon::VerticalText),
 21 |         egui::CursorIcon::Alias => Some(bevy::window::CursorIcon::Alias),
 22 |         egui::CursorIcon::Copy => Some(bevy::window::CursorIcon::Copy),
 23 |         egui::CursorIcon::Move => Some(bevy::window::CursorIcon::Move),
 24 |         egui::CursorIcon::NoDrop => Some(bevy::window::CursorIcon::NoDrop),
 25 |         egui::CursorIcon::NotAllowed => Some(bevy::window::CursorIcon::NotAllowed),
 26 |         egui::CursorIcon::AllScroll => Some(bevy::window::CursorIcon::AllScroll),
 27 |         egui::CursorIcon::ZoomIn => Some(bevy::window::CursorIcon::ZoomIn),
 28 |         egui::CursorIcon::ZoomOut => Some(bevy::window::CursorIcon::ZoomOut),
 29 |         egui::CursorIcon::ResizeEast => Some(bevy::window::CursorIcon::EResize),
 30 |         egui::CursorIcon::ResizeSouthEast => Some(bevy::window::CursorIcon::SeResize),
 31 |         egui::CursorIcon::ResizeSouth => Some(bevy::window::CursorIcon::SResize),
 32 |         egui::CursorIcon::ResizeSouthWest => Some(bevy::window::CursorIcon::SwResize),
 33 |         egui::CursorIcon::ResizeWest => Some(bevy::window::CursorIcon::WResize),
 34 |         egui::CursorIcon::ResizeNorthWest => Some(bevy::window::CursorIcon::NwResize),
 35 |         egui::CursorIcon::ResizeNorth => Some(bevy::window::CursorIcon::NResize),
 36 |         egui::CursorIcon::ResizeNorthEast => Some(bevy::window::CursorIcon::NeResize),
 37 |         egui::CursorIcon::ResizeColumn => Some(bevy::window::CursorIcon::ColResize),
 38 |         egui::CursorIcon::ResizeRow => Some(bevy::window::CursorIcon::RowResize),
 39 |         egui::CursorIcon::None => None,
 40 |     }
 41 | }
 42 | 
 43 | pub fn key(key_code: KeyCode) -> Option<egui::Key> {
 44 |     let key = match key_code {
 45 |         KeyCode::Down => egui::Key::ArrowDown,
 46 |         KeyCode::Left => egui::Key::ArrowLeft,
 47 |         KeyCode::Right => egui::Key::ArrowRight,
 48 |         KeyCode::Up => egui::Key::ArrowUp,
 49 |         KeyCode::Escape => egui::Key::Escape,
 50 |         KeyCode::Tab => egui::Key::Tab,
 51 |         KeyCode::Back => egui::Key::Backspace,
 52 |         KeyCode::Return => egui::Key::Enter,
 53 |         KeyCode::Space => egui::Key::Space,
 54 |         KeyCode::Insert => egui::Key::Insert,
 55 |         KeyCode::Delete => egui::Key::Delete,
 56 |         KeyCode::Home => egui::Key::Home,
 57 |         KeyCode::End => egui::Key::End,
 58 |         KeyCode::PageUp => egui::Key::PageUp,
 59 |         KeyCode::PageDown => egui::Key::PageDown,
 60 |         KeyCode::Numpad0 | KeyCode::Key0 => egui::Key::Num0,
 61 |         KeyCode::Numpad1 | KeyCode::Key1 => egui::Key::Num1,
 62 |         KeyCode::Numpad2 | KeyCode::Key2 => egui::Key::Num2,
 63 |         KeyCode::Numpad3 | KeyCode::Key3 => egui::Key::Num3,
 64 |         KeyCode::Numpad4 | KeyCode::Key4 => egui::Key::Num4,
 65 |         KeyCode::Numpad5 | KeyCode::Key5 => egui::Key::Num5,
 66 |         KeyCode::Numpad6 | KeyCode::Key6 => egui::Key::Num6,
 67 |         KeyCode::Numpad7 | KeyCode::Key7 => egui::Key::Num7,
 68 |         KeyCode::Numpad8 | KeyCode::Key8 => egui::Key::Num8,
 69 |         KeyCode::Numpad9 | KeyCode::Key9 => egui::Key::Num9,
 70 |         KeyCode::A => egui::Key::A,
 71 |         KeyCode::B => egui::Key::B,
 72 |         KeyCode::C => egui::Key::C,
 73 |         KeyCode::D => egui::Key::D,
 74 |         KeyCode::E => egui::Key::E,
 75 |         KeyCode::F => egui::Key::F,
 76 |         KeyCode::G => egui::Key::G,
 77 |         KeyCode::H => egui::Key::H,
 78 |         KeyCode::I => egui::Key::I,
 79 |         KeyCode::J => egui::Key::J,
 80 |         KeyCode::K => egui::Key::K,
 81 |         KeyCode::L => egui::Key::L,
 82 |         KeyCode::M => egui::Key::M,
 83 |         KeyCode::N => egui::Key::N,
 84 |         KeyCode::O => egui::Key::O,
 85 |         KeyCode::P => egui::Key::P,
 86 |         KeyCode::Q => egui::Key::Q,
 87 |         KeyCode::R => egui::Key::R,
 88 |         KeyCode::S => egui::Key::S,
 89 |         KeyCode::T => egui::Key::T,
 90 |         KeyCode::U => egui::Key::U,
 91 |         KeyCode::V => egui::Key::V,
 92 |         KeyCode::W => egui::Key::W,
 93 |         KeyCode::X => egui::Key::X,
 94 |         KeyCode::Y => egui::Key::Y,
 95 |         KeyCode::Z => egui::Key::Z,
 96 |         _ => return None,
 97 |     };
 98 |     Some(key)
 99 | }
100 | 


--------------------------------------------------------------------------------
/src/ui/shell/render.rs:
--------------------------------------------------------------------------------
  1 | use super::{
  2 |     node::EguiPipeline, EguiContext, EguiManagedTextures, EguiRenderOutput, EguiSettings,
  3 |     WindowSize,
  4 | };
  5 | use bevy::prelude::*;
  6 | use bevy::render::render_resource::{DynamicUniformBuffer, ShaderType};
  7 | use bevy::render::Extract;
  8 | use bevy::render::{
  9 |     render_resource::{BindGroup, BufferId},
 10 |     renderer::{RenderDevice, RenderQueue},
 11 |     {render_asset::RenderAssets, texture::Image},
 12 | };
 13 | use bevy::{asset::HandleId, utils::HashMap, window::WindowId};
 14 | use wgpu::{BindGroupDescriptor, BindGroupEntry, BindingResource};
 15 | 
 16 | pub struct ExtractedRenderOutput(pub HashMap<WindowId, EguiRenderOutput>);
 17 | pub struct ExtractedWindowSizes(pub HashMap<WindowId, WindowSize>);
 18 | pub struct ExtractedEguiContext(pub HashMap<WindowId, egui::Context>);
 19 | pub struct ExtractedEguiSettings(pub EguiSettings);
 20 | 
 21 | pub struct EguiTextureBindGroups {
 22 |     pub bind_groups: HashMap<EguiTexture, BindGroup>,
 23 | }
 24 | 
 25 | #[derive(Debug, PartialEq, Eq, Hash)]
 26 | pub enum EguiTexture {
 27 |     /// Textures allocated via egui.
 28 |     Managed(WindowId, u64),
 29 |     /// Textures allocated via bevy.
 30 |     User(u64),
 31 | }
 32 | 
 33 | pub struct ExtractedEguiTextures {
 34 |     pub egui_textures: HashMap<(WindowId, u64), Handle<Image>>,
 35 |     pub user_textures: HashMap<Handle<Image>, u64>,
 36 | }
 37 | 
 38 | impl ExtractedEguiTextures {
 39 |     pub fn handles(&self) -> impl Iterator<Item = (EguiTexture, HandleId)> + '_ {
 40 |         self.egui_textures
 41 |             .iter()
 42 |             .map(|(&(window_id, texture_id), handle)| {
 43 |                 (EguiTexture::Managed(window_id, texture_id), handle.id)
 44 |             })
 45 |             .chain(
 46 |                 self.user_textures
 47 |                     .iter()
 48 |                     .map(|(handle, &id)| (EguiTexture::User(id), handle.id)),
 49 |             )
 50 |     }
 51 | }
 52 | 
 53 | #[derive(Default)]
 54 | pub struct EguiTransforms {
 55 |     pub buffer: DynamicUniformBuffer<EguiTransform>,
 56 |     pub offsets: HashMap<WindowId, u32>,
 57 |     pub bind_group: Option<(BufferId, BindGroup)>,
 58 | }
 59 | 
 60 | #[derive(ShaderType, Default)]
 61 | pub struct EguiTransform {
 62 |     scale: Vec2,
 63 |     translation: Vec2,
 64 | }
 65 | 
 66 | impl EguiTransform {
 67 |     fn new(window_size: WindowSize, scale_factor: f32) -> Self {
 68 |         let x = 2.0 / (window_size.scaled_width() / scale_factor);
 69 |         let y = -2.0 / (window_size.scaled_height() / scale_factor);
 70 |         Self {
 71 |             scale: Vec2::new(x, y),
 72 |             translation: Vec2::new(-1.0, 1.0),
 73 |         }
 74 |     }
 75 | }
 76 | 
 77 | pub fn extract_render_data(
 78 |     mut commands: Commands,
 79 |     render_output: Extract<Res<HashMap<WindowId, EguiRenderOutput>>>,
 80 |     sizes: Extract<Res<HashMap<WindowId, WindowSize>>>,
 81 |     settings: Extract<Res<EguiSettings>>,
 82 |     context: Extract<Res<EguiContext>>,
 83 | ) {
 84 |     commands.insert_resource(ExtractedRenderOutput(render_output.clone()));
 85 |     commands.insert_resource(ExtractedEguiSettings(settings.clone()));
 86 |     commands.insert_resource(ExtractedEguiContext(context.ctx.clone()));
 87 |     commands.insert_resource(ExtractedWindowSizes(sizes.clone()));
 88 | }
 89 | 
 90 | pub fn extract_textures(
 91 |     mut commands: Commands,
 92 |     context: Extract<Res<EguiContext>>,
 93 |     textures: Extract<Res<EguiManagedTextures>>,
 94 | ) {
 95 |     commands.insert_resource(ExtractedEguiTextures {
 96 |         egui_textures: textures
 97 |             .0
 98 |             .iter()
 99 |             .map(|(&(window_id, texture_id), managed_texture)| {
100 |                 ((window_id, texture_id), managed_texture.handle.clone())
101 |             })
102 |             .collect(),
103 |         user_textures: context.user_textures.clone(),
104 |     });
105 | }
106 | 
107 | pub fn prepare_transforms(
108 |     mut transforms: ResMut<EguiTransforms>,
109 |     window_sizes: Res<ExtractedWindowSizes>,
110 |     settings: Res<ExtractedEguiSettings>,
111 |     pipeline: Res<EguiPipeline>,
112 |     device: Res<RenderDevice>,
113 |     queue: Res<RenderQueue>,
114 | ) {
115 |     transforms.buffer.clear();
116 |     transforms.offsets.clear();
117 | 
118 |     for (window, size) in &window_sizes.0 {
119 |         let offset = transforms
120 |             .buffer
121 |             .push(EguiTransform::new(*size, settings.0.scale_factor as f32));
122 |         transforms.offsets.insert(*window, offset);
123 |     }
124 | 
125 |     transforms.buffer.write_buffer(&device, &queue);
126 | 
127 |     if let Some(buffer) = transforms.buffer.buffer() {
128 |         match transforms.bind_group {
129 |             Some((id, _)) if buffer.id() == id => {}
130 |             _ => {
131 |                 let transform_bind_group = device.create_bind_group(&BindGroupDescriptor {
132 |                     label: Some("egui transform bind group"),
133 |                     layout: &pipeline.transform_bind_group_layout,
134 |                     entries: &[BindGroupEntry {
135 |                         binding: 0,
136 |                         resource: transforms.buffer.binding().unwrap(),
137 |                     }],
138 |                 });
139 |                 transforms.bind_group = Some((buffer.id(), transform_bind_group));
140 |             }
141 |         };
142 |     }
143 | }
144 | 
145 | pub fn queue_bind_groups(
146 |     mut commands: Commands,
147 |     textures: Res<ExtractedEguiTextures>,
148 |     render_device: Res<RenderDevice>,
149 |     gpu_images: Res<RenderAssets<Image>>,
150 |     pipeline: Res<EguiPipeline>,
151 | ) {
152 |     let bind_groups = textures
153 |         .handles()
154 |         .filter_map(|(texture, handle_id)| {
155 |             let gpu_image = gpu_images.get(&Handle::weak(handle_id))?;
156 |             let bind_group = render_device.create_bind_group(&BindGroupDescriptor {
157 |                 label: None,
158 |                 layout: &pipeline.texture_bind_group_layout,
159 |                 entries: &[
160 |                     BindGroupEntry {
161 |                         binding: 0,
162 |                         resource: BindingResource::TextureView(&gpu_image.texture_view),
163 |                     },
164 |                     BindGroupEntry {
165 |                         binding: 1,
166 |                         resource: BindingResource::Sampler(&gpu_image.sampler),
167 |                     },
168 |                 ],
169 |             });
170 |             Some((texture, bind_group))
171 |         })
172 |         .collect();
173 | 
174 |     commands.insert_resource(EguiTextureBindGroups { bind_groups })
175 | }
176 | 


--------------------------------------------------------------------------------
/src/ui/shell/shader.wgsl:
--------------------------------------------------------------------------------
 1 | struct Transform {
 2 |     scale: vec2<f32>,
 3 |     translation: vec2<f32>,
 4 | }
 5 | 
 6 | struct VertexInput {
 7 |     @location(0) position: vec2<f32>,
 8 |     @location(1) uv: vec2<f32>,
 9 |     @location(2) color: vec4<f32>,
10 | }
11 | 
12 | struct VertexOutput {
13 |     @builtin(position) position: vec4<f32>,
14 |     @location(0) color: vec4<f32>,
15 |     @location(1) uv: vec2<f32>,
16 | }
17 | 
18 | @group(0) @binding(0) var<uniform> transform: Transform;
19 | @group(1) @binding(0) var image_texture: texture_2d<f32>;
20 | @group(1) @binding(1) var image_sampler: sampler;
21 | 
22 | fn linear_from_srgb(srgb: vec3<f32>) -> vec3<f32> {
23 |     let cutoff = srgb < vec3<f32>(0.04045);
24 |     let lower = srgb / 12.92;
25 |     let higher = pow((srgb + 0.055) / 1.055, vec3<f32>(2.4));
26 |     return select(higher, lower, cutoff);
27 | }
28 | 
29 | @vertex
30 | fn vs_main(in: VertexInput) -> VertexOutput {
31 |     let position = in.position * transform.scale + transform.translation;
32 |     let color = vec4<f32>(linear_from_srgb(in.color.rgb), in.color.a);
33 |     return VertexOutput(vec4<f32>(position, 0.0, 1.0), color, in.uv);
34 | }
35 | 
36 | @fragment
37 | fn fs_main(in: VertexOutput) -> @location(0) vec4<f32> {
38 |     return in.color * textureSample(image_texture, image_sampler, in.uv);
39 | }


--------------------------------------------------------------------------------
/src/ui/shell/tests.rs:
--------------------------------------------------------------------------------
 1 | use super::*;
 2 | use bevy::{render::settings::WgpuSettings, winit::WinitPlugin, DefaultPlugins};
 3 | 
 4 | #[test]
 5 | fn headless_mode() {
 6 |     App::new()
 7 |         .insert_resource(WgpuSettings {
 8 |             backends: None,
 9 |             ..Default::default()
10 |         })
11 |         .add_plugins_with(DefaultPlugins, |group| group.disable::<WinitPlugin>())
12 |         .add_plugin(EguiPlugin)
13 |         .update();
14 | }
15 | 
16 | #[test]
17 | fn ctx_for_windows_mut_unique_check_passes() {
18 |     let mut context = EguiContext::new();
19 |     let primary_window = WindowId::primary();
20 |     let second_window = WindowId::new();
21 |     context.ctx.insert(primary_window, Default::default());
22 |     context.ctx.insert(second_window, Default::default());
23 |     let [primary_ctx, second_ctx] = context.ctx_mut([primary_window, second_window]);
24 |     assert!(primary_ctx != second_ctx);
25 | }
26 | 
27 | #[test]
28 | #[should_panic(expected = "Window ids passed to `EguiContext::ctx_for_windows_mut` must be unique")]
29 | fn ctx_for_windows_mut_unique_check_panics() {
30 |     let mut context = EguiContext::new();
31 |     let primary_window = WindowId::primary();
32 |     context.ctx.insert(primary_window, Default::default());
33 |     let _ = context.ctx_mut([primary_window, primary_window]);
34 | }
35 | 
36 | #[test]
37 | fn try_ctx_for_windows_mut_unique_check_passes() {
38 |     let mut context = EguiContext::new();
39 |     let primary_window = WindowId::primary();
40 |     let second_window = WindowId::new();
41 |     context.ctx.insert(primary_window, Default::default());
42 |     context.ctx.insert(second_window, Default::default());
43 |     let [primary_ctx, second_ctx] = context.try_ctx_mut([primary_window, second_window]);
44 |     assert!(primary_ctx.is_some());
45 |     assert!(second_ctx.is_some());
46 |     assert!(primary_ctx != second_ctx);
47 | }
48 | 
49 | #[test]
50 | #[should_panic(expected = "Window ids passed to `EguiContext::ctx_for_windows_mut` must be unique")]
51 | fn try_ctx_for_windows_mut_unique_check_panics() {
52 |     let mut context = EguiContext::new();
53 |     let primary_window = WindowId::primary();
54 |     context.ctx.insert(primary_window, Default::default());
55 |     let _ = context.try_ctx_mut([primary_window, primary_window]);
56 | }
57 | 


--------------------------------------------------------------------------------
/src/ui/style.rs:
--------------------------------------------------------------------------------
  1 | use crate::util::map_to_pixel;
  2 | use egui::{Color32, CursorIcon, Rect, Rounding, Sense, Ui};
  3 | 
  4 | #[derive(Clone)]
  5 | pub struct Style {
  6 |     pub separator_size: f32,
  7 |     pub separator_extra: f32,
  8 | 
  9 |     pub app_bg: Color32,
 10 | 
 11 |     pub top_base: Color32,
 12 |     pub top_text: Color32,
 13 |     pub top_active: Color32,
 14 |     pub top_disable: Color32,
 15 | 
 16 |     pub tab_rounding: Rounding,
 17 |     pub tab_bar: Color32,
 18 |     pub tab_base: Color32,
 19 |     pub tab_text: Color32,
 20 |     //pub tab_active: Color32,
 21 |     pub tab_outline: Color32,
 22 | 
 23 |     pub selection: Color32,
 24 |     pub selection_opaque: Color32,
 25 | 
 26 |     pub background: Color32,
 27 |     pub panel: Color32,
 28 |     pub tabbar: Color32,
 29 |     pub separator: Color32,
 30 |     pub input_stroke: Color32,
 31 |     pub input_fill: Color32,
 32 |     pub input_text: Color32,
 33 | }
 34 | 
 35 | impl Default for Style {
 36 |     fn default() -> Self {
 37 |         let background = Color32::from_gray(0x00);
 38 |         let panel = Color32::from_gray(0x2B);
 39 |         let tabbar = Color32::from_gray(0x14);
 40 |         let separator = Color32::from_gray(0x1E);
 41 | 
 42 |         let input_stroke = Color32::from_gray(0x37);
 43 |         let input_fill = Color32::from_gray(0x1B);
 44 |         let input_text = Color32::from_gray(0xEE);
 45 | 
 46 |         Self {
 47 |             background,
 48 |             panel,
 49 |             tabbar,
 50 |             separator,
 51 |             input_stroke,
 52 |             input_text,
 53 |             input_fill,
 54 | 
 55 |             selection: Color32::from_rgba_unmultiplied(61, 133, 224, 30),
 56 |             selection_opaque: Color32::from_rgb(61, 133, 224),
 57 | 
 58 |             separator_size: 4.0,
 59 |             separator_extra: 80.0,
 60 | 
 61 |             //app_bg: Color32::from_gray(0x14),
 62 |             app_bg: background,
 63 | 
 64 |             top_base: Color32::from_gray(0x2d),
 65 |             top_text: Color32::from_gray(0x9d),
 66 |             top_active: Color32::from_gray(0x55),
 67 |             top_disable: Color32::from_gray(0x20),
 68 | 
 69 |             tab_rounding: Rounding {
 70 |                 ne: 2.0,
 71 |                 nw: 2.0,
 72 |                 se: 0.0,
 73 |                 sw: 0.0,
 74 |             },
 75 | 
 76 |             //tab_bar: Color32::from_gray(0x20),
 77 |             //tab_base: Color32::from_gray(0x30),
 78 |             tab_bar: tabbar,
 79 |             tab_base: panel,
 80 | 
 81 |             tab_text: Color32::from_gray(0x9d),
 82 |             //tab_active: Color32::from_gray(0x40),
 83 |             tab_outline: Color32::from_gray(0x1c),
 84 |         }
 85 |     }
 86 | }
 87 | 
 88 | impl Style {
 89 |     pub fn set_theme_visuals(&self, ui: &mut Ui) {
 90 |         let visuals = ui.visuals_mut();
 91 | 
 92 |         let expansion = 0.0;
 93 |         visuals.widgets.noninteractive.expansion = expansion;
 94 |         visuals.widgets.inactive.expansion = expansion;
 95 |         visuals.widgets.hovered.expansion = expansion;
 96 |         visuals.widgets.active.expansion = expansion;
 97 |         visuals.widgets.open.expansion = expansion;
 98 | 
 99 |         visuals.widgets.noninteractive.bg_fill = self.input_fill;
100 |         visuals.widgets.inactive.bg_fill = self.input_fill;
101 |         visuals.widgets.hovered.bg_fill = self.input_fill;
102 |         visuals.widgets.active.bg_fill = self.input_fill;
103 |         visuals.widgets.open.bg_fill = self.input_fill;
104 | 
105 |         visuals.widgets.noninteractive.fg_stroke.color = self.input_text;
106 |         visuals.widgets.inactive.fg_stroke.color = self.input_text;
107 |         visuals.widgets.hovered.fg_stroke.color = self.input_text;
108 |         visuals.widgets.active.fg_stroke.color = self.input_text;
109 |         visuals.widgets.open.fg_stroke.color = self.input_text;
110 | 
111 |         let rounding = Rounding::same(2.0);
112 | 
113 |         visuals.extreme_bg_color = self.input_fill;
114 |         visuals.widgets.noninteractive.rounding = rounding;
115 |         visuals.widgets.inactive.rounding = rounding;
116 |         visuals.widgets.hovered.rounding = rounding;
117 |         visuals.widgets.active.rounding = rounding;
118 |         visuals.widgets.open.rounding = rounding;
119 | 
120 |         visuals.selection.bg_fill = self.selection_opaque;
121 |         visuals.selection.stroke.color = Color32::WHITE;
122 |     }
123 | 
124 |     pub fn for_scrollbar(&self, ui: &mut Ui) {
125 |         let spacing = ui.spacing_mut();
126 |         spacing.scroll_bar_width = 4.0;
127 | 
128 |         let visuals = ui.visuals_mut();
129 |         let rounding = Rounding::same(0.0);
130 | 
131 |         visuals.extreme_bg_color = self.panel;
132 |         visuals.clip_rect_margin = 0.0;
133 |         visuals.widgets.noninteractive.rounding = rounding;
134 |         visuals.widgets.inactive.rounding = rounding;
135 |         visuals.widgets.hovered.rounding = rounding;
136 |         visuals.widgets.active.rounding = rounding;
137 |         visuals.widgets.open.rounding = rounding;
138 |     }
139 | 
140 |     pub fn scrollarea(&self, ui: &mut Ui) {
141 |         let visuals = ui.visuals_mut();
142 |         let rounding = Rounding::same(2.0);
143 | 
144 |         visuals.extreme_bg_color = self.input_fill;
145 |         visuals.widgets.noninteractive.rounding = rounding;
146 |         visuals.widgets.inactive.rounding = rounding;
147 |         visuals.widgets.hovered.rounding = rounding;
148 |         visuals.widgets.active.rounding = rounding;
149 |         visuals.widgets.open.rounding = rounding;
150 |     }
151 | 
152 |     pub fn hsplit(&self, ui: &mut Ui, fraction: &mut f32, rect: Rect) -> (Rect, Rect, Rect) {
153 |         let pixels_per_point = ui.ctx().pixels_per_point();
154 | 
155 |         let mut separator = rect;
156 | 
157 |         let midpoint = rect.min.x + rect.width() * *fraction;
158 |         separator.min.x = midpoint - self.separator_size * 0.5;
159 |         separator.max.x = midpoint + self.separator_size * 0.5;
160 | 
161 |         let response = ui
162 |             .allocate_rect(separator, Sense::click_and_drag())
163 |             .on_hover_cursor(CursorIcon::ResizeHorizontal);
164 | 
165 |         {
166 |             let delta = response.drag_delta().x;
167 |             let range = rect.max.x - rect.min.x;
168 |             let min = (self.separator_extra / range).min(1.0);
169 |             let max = 1.0 - min;
170 |             let (min, max) = (min.min(max), max.max(min));
171 |             *fraction = (*fraction + delta / range).clamp(min, max);
172 |         }
173 | 
174 |         let midpoint = rect.min.x + rect.width() * *fraction;
175 |         separator.min.x = map_to_pixel(
176 |             midpoint - self.separator_size * 0.5,
177 |             pixels_per_point,
178 |             f32::round,
179 |         );
180 |         separator.max.x = map_to_pixel(
181 |             midpoint + self.separator_size * 0.5,
182 |             pixels_per_point,
183 |             f32::round,
184 |         );
185 | 
186 |         (
187 |             rect.intersect(Rect::everything_right_of(separator.max.x)),
188 |             separator,
189 |             rect.intersect(Rect::everything_left_of(separator.min.x)),
190 |         )
191 |     }
192 | 
193 |     pub fn vsplit(&self, ui: &mut Ui, fraction: &mut f32, rect: Rect) -> (Rect, Rect, Rect) {
194 |         let pixels_per_point = ui.ctx().pixels_per_point();
195 | 
196 |         let mut separator = rect;
197 | 
198 |         let midpoint = rect.min.y + rect.height() * *fraction;
199 |         separator.min.y = midpoint - self.separator_size * 0.5;
200 |         separator.max.y = midpoint + self.separator_size * 0.5;
201 | 
202 |         let response = ui
203 |             .allocate_rect(separator, Sense::click_and_drag())
204 |             .on_hover_cursor(CursorIcon::ResizeVertical);
205 | 
206 |         {
207 |             let delta = response.drag_delta().y;
208 |             let range = rect.max.y - rect.min.y;
209 | 
210 |             let min = (self.separator_extra / range).min(1.0);
211 |             let max = 1.0 - min;
212 |             let (min, max) = (min.min(max), max.max(min));
213 |             *fraction = (*fraction + delta / range).clamp(min, max);
214 |         }
215 | 
216 |         let midpoint = rect.min.y + rect.height() * *fraction;
217 |         separator.min.y = map_to_pixel(
218 |             midpoint - self.separator_size * 0.5,
219 |             pixels_per_point,
220 |             f32::round,
221 |         );
222 |         separator.max.y = map_to_pixel(
223 |             midpoint + self.separator_size * 0.5,
224 |             pixels_per_point,
225 |             f32::round,
226 |         );
227 | 
228 |         (
229 |             rect.intersect(Rect::everything_above(separator.min.y)),
230 |             separator,
231 |             rect.intersect(Rect::everything_below(separator.max.y)),
232 |         )
233 |     }
234 | }
235 | 


--------------------------------------------------------------------------------
/src/ui/tabs.rs:
--------------------------------------------------------------------------------
  1 | use bevy::prelude::Entity;
  2 | use egui::Rect;
  3 | 
  4 | pub struct Tab {
  5 |     pub icon: char,
  6 |     pub title: String,
  7 |     pub entity: Entity,
  8 | }
  9 | 
 10 | impl ToString for Tab {
 11 |     fn to_string(&self) -> String {
 12 |         format!("{}  {}", self.icon, self.title)
 13 |     }
 14 | }
 15 | 
 16 | impl Tab {
 17 |     pub fn new(icon: char, title: impl Into<String>, entity: Entity) -> Self {
 18 |         Self {
 19 |             icon,
 20 |             title: title.into(),
 21 |             entity,
 22 |         }
 23 |     }
 24 | }
 25 | 
 26 | pub enum TreeNode {
 27 |     None,
 28 |     Leaf {
 29 |         rect: Rect,
 30 |         viewport: Rect,
 31 |         tabs: Vec<Tab>,
 32 |         active: usize,
 33 |     },
 34 |     Vertical {
 35 |         rect: Rect,
 36 |         fraction: f32,
 37 |     },
 38 |     Horizontal {
 39 |         rect: Rect,
 40 |         fraction: f32,
 41 |     },
 42 | }
 43 | 
 44 | impl TreeNode {
 45 |     pub fn leaf(tab: Tab) -> Self {
 46 |         Self::Leaf {
 47 |             rect: Rect::NOTHING,
 48 |             viewport: Rect::NOTHING,
 49 |             tabs: vec![tab],
 50 |             active: 0,
 51 |         }
 52 |     }
 53 | 
 54 |     pub fn leaf_with(tabs: Vec<Tab>) -> Self {
 55 |         Self::Leaf {
 56 |             rect: Rect::NOTHING,
 57 |             viewport: Rect::NOTHING,
 58 |             tabs,
 59 |             active: 0,
 60 |         }
 61 |     }
 62 | 
 63 |     pub fn set_rect(&mut self, new_rect: Rect) {
 64 |         match self {
 65 |             Self::None => (),
 66 |             Self::Leaf { rect, .. }
 67 |             | Self::Vertical { rect, .. }
 68 |             | Self::Horizontal { rect, .. } => *rect = new_rect,
 69 |         }
 70 |     }
 71 | 
 72 |     pub fn is_none(&self) -> bool {
 73 |         matches!(self, Self::None)
 74 |     }
 75 | 
 76 |     pub fn is_leaf(&self) -> bool {
 77 |         matches!(self, Self::Leaf { .. })
 78 |     }
 79 | 
 80 |     pub fn split(&mut self, split: Split, fraction: f32) -> Self {
 81 |         let rect = Rect::NOTHING;
 82 |         let src = match split {
 83 |             Split::Left | Split::Right => TreeNode::Horizontal { fraction, rect },
 84 |             Split::Above | Split::Below => TreeNode::Vertical { fraction, rect },
 85 |         };
 86 |         std::mem::replace(self, src)
 87 |     }
 88 | 
 89 |     #[track_caller]
 90 |     pub fn append_tab(&mut self, tab: Tab) {
 91 |         match self {
 92 |             TreeNode::Leaf { tabs, .. } => tabs.push(tab),
 93 |             _ => unreachable!(),
 94 |         }
 95 |     }
 96 | 
 97 |     pub fn remove_tab(&mut self, index: usize) -> Option<Tab> {
 98 |         match self {
 99 |             TreeNode::Leaf { tabs, .. } => Some(tabs.remove(index)),
100 |             _ => None,
101 |         }
102 |     }
103 | }
104 | 
105 | #[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
106 | pub struct NodeIndex(pub usize);
107 | 
108 | impl NodeIndex {
109 |     pub const fn root() -> Self {
110 |         Self(0)
111 |     }
112 | 
113 |     pub const fn left(self) -> Self {
114 |         Self(self.0 * 2 + 1)
115 |     }
116 | 
117 |     pub const fn right(self) -> Self {
118 |         Self(self.0 * 2 + 2)
119 |     }
120 | 
121 |     pub const fn parent(self) -> Option<Self> {
122 |         if self.0 > 0 {
123 |             Some(Self((self.0 - 1) / 2))
124 |         } else {
125 |             None
126 |         }
127 |     }
128 | 
129 |     pub const fn level(self) -> usize {
130 |         (usize::BITS - (self.0 + 1).leading_zeros()) as usize
131 |     }
132 | 
133 |     pub const fn is_left(self) -> bool {
134 |         self.0 % 2 != 0
135 |     }
136 | 
137 |     pub const fn is_right(self) -> bool {
138 |         self.0 % 2 == 0
139 |     }
140 | 
141 |     const fn children_at(self, level: usize) -> std::ops::Range<usize> {
142 |         let base = 1 << level;
143 |         let s = (self.0 + 1) * base - 1;
144 |         let e = (self.0 + 2) * base - 1;
145 |         s..e
146 |     }
147 | 
148 |     const fn children_left(self, level: usize) -> std::ops::Range<usize> {
149 |         let base = 1 << level;
150 |         let s = (self.0 + 1) * base - 1;
151 |         let e = (self.0 + 1) * base + base / 2 - 1;
152 |         s..e
153 |     }
154 | 
155 |     const fn children_right(self, level: usize) -> std::ops::Range<usize> {
156 |         let base = 1 << level;
157 |         let s = (self.0 + 1) * base + base / 2 - 1;
158 |         let e = (self.0 + 2) * base - 1;
159 |         s..e
160 |     }
161 | }
162 | 
163 | #[derive(Clone, Copy)]
164 | pub enum Split {
165 |     Left,
166 |     Right,
167 |     Above,
168 |     Below,
169 | }
170 | 
171 | pub struct SplitTree {
172 |     tree: Vec<TreeNode>,
173 | }
174 | 
175 | impl std::ops::Index<NodeIndex> for SplitTree {
176 |     type Output = TreeNode;
177 | 
178 |     #[inline(always)]
179 |     fn index(&self, index: NodeIndex) -> &Self::Output {
180 |         &self.tree[index.0]
181 |     }
182 | }
183 | 
184 | impl std::ops::IndexMut<NodeIndex> for SplitTree {
185 |     #[inline(always)]
186 |     fn index_mut(&mut self, index: NodeIndex) -> &mut Self::Output {
187 |         &mut self.tree[index.0]
188 |     }
189 | }
190 | 
191 | impl SplitTree {
192 |     pub fn new(root: TreeNode) -> Self {
193 |         Self { tree: vec![root] }
194 |     }
195 | 
196 |     #[inline]
197 |     pub fn len(&self) -> usize {
198 |         self.tree.len()
199 |     }
200 | 
201 |     pub fn is_empty(&self) -> bool {
202 |         self.tree.is_empty()
203 |     }
204 | 
205 |     pub fn iter(&self) -> std::slice::Iter<'_, TreeNode> {
206 |         self.tree.iter()
207 |     }
208 | 
209 |     pub fn iter_mut(&mut self) -> std::slice::IterMut<'_, TreeNode> {
210 |         self.tree.iter_mut()
211 |     }
212 | 
213 |     pub fn split_tabs(
214 |         &mut self,
215 |         parent: NodeIndex,
216 |         split: Split,
217 |         fraction: f32,
218 |         tabs: Vec<Tab>,
219 |     ) -> [NodeIndex; 2] {
220 |         self.split(parent, split, fraction, TreeNode::leaf_with(tabs))
221 |     }
222 | 
223 |     pub fn split(
224 |         &mut self,
225 |         parent: NodeIndex,
226 |         split: Split,
227 |         fraction: f32,
228 |         new: TreeNode,
229 |     ) -> [NodeIndex; 2] {
230 |         let old = self[parent].split(split, fraction);
231 |         assert!(old.is_leaf());
232 | 
233 |         {
234 |             let index = self.tree.iter().rposition(|n| !n.is_none()).unwrap_or(0);
235 |             let level = NodeIndex(index).level();
236 |             self.tree.resize_with(1 << (level + 1), || TreeNode::None);
237 |         }
238 | 
239 |         let index = match split {
240 |             Split::Right | Split::Above => [parent.right(), parent.left()],
241 |             Split::Left | Split::Below => [parent.left(), parent.right()],
242 |         };
243 | 
244 |         self[index[0]] = old;
245 |         self[index[1]] = new;
246 | 
247 |         index
248 |     }
249 | 
250 |     pub fn remove_empty_leaf(&mut self) {
251 |         let mut nodes = self.tree.iter().enumerate();
252 |         let node = nodes.find_map(|(index, node)| match node {
253 |             TreeNode::Leaf { tabs, .. } if tabs.is_empty() => Some(index),
254 |             _ => None,
255 |         });
256 | 
257 |         let node = match node {
258 |             Some(node) => NodeIndex(node),
259 |             None => return,
260 |         };
261 | 
262 |         let parent = node.parent().unwrap();
263 | 
264 |         self[parent] = TreeNode::None;
265 |         self[node] = TreeNode::None;
266 | 
267 |         let mut level = 0;
268 | 
269 |         if node.is_left() {
270 |             'left_end: loop {
271 |                 let dst = parent.children_at(level);
272 |                 let src = parent.children_right(level + 1);
273 |                 for (dst, src) in dst.zip(src) {
274 |                     if src >= self.tree.len() {
275 |                         break 'left_end;
276 |                     }
277 |                     self.tree[dst] = std::mem::replace(&mut self.tree[src], TreeNode::None);
278 |                 }
279 |                 level += 1;
280 |             }
281 |         } else {
282 |             'right_end: loop {
283 |                 let dst = parent.children_at(level);
284 |                 let src = parent.children_left(level + 1);
285 |                 for (dst, src) in dst.zip(src) {
286 |                     if src >= self.tree.len() {
287 |                         break 'right_end;
288 |                     }
289 |                     self.tree[dst] = std::mem::replace(&mut self.tree[src], TreeNode::None);
290 |                 }
291 |                 level += 1;
292 |             }
293 |         }
294 |     }
295 | }
296 | 


--------------------------------------------------------------------------------
/src/util.rs:
--------------------------------------------------------------------------------
 1 | //! Utility structures and functions.
 2 | 
 3 | #![allow(dead_code)]
 4 | 
 5 | pub mod anymap;
 6 | pub mod reflect;
 7 | pub mod slice;
 8 | 
 9 | pub fn enable_tracing() {
10 |     use tracing_subscriber::{fmt, EnvFilter};
11 | 
12 |     let format = fmt::format()
13 |         .without_time()
14 |         .with_target(false)
15 |         .with_source_location(false)
16 |         .compact();
17 | 
18 |     tracing_subscriber::fmt()
19 |         .with_env_filter(EnvFilter::from_default_env())
20 |         .event_format(format)
21 |         .init();
22 | }
23 | 
24 | /// # Safety
25 | /// N/A
26 | pub unsafe fn fuck_ref<'a, T: ?Sized>(ptr: &T) -> &'a T {
27 |     &*(ptr as *const T)
28 | }
29 | 
30 | /// # Safety
31 | /// N/A
32 | pub unsafe fn fuck_mut<'a, T: ?Sized>(ptr: &mut T) -> &'a mut T {
33 |     &mut *(ptr as *mut T)
34 | }
35 | 
36 | pub fn linear_from_srgb_f64(r: f64, g: f64, b: f64) -> [f64; 3] {
37 |     let cutoff = [r < 0.04045, g < 0.04045, b < 0.04045];
38 |     let lower = [r / 12.92, g / 12.92, b / 12.92];
39 |     let higher = [
40 |         ((r + 0.055) / 1.055).powf(2.4),
41 |         ((g + 0.055) / 1.055).powf(2.4),
42 |         ((b + 0.055) / 1.055).powf(2.4),
43 |     ];
44 |     [
45 |         if cutoff[0] { lower[0] } else { higher[0] },
46 |         if cutoff[1] { lower[1] } else { higher[1] },
47 |         if cutoff[2] { lower[2] } else { higher[2] },
48 |     ]
49 | }
50 | 
51 | pub fn expand_to_pixel(mut rect: egui::Rect, ppi: f32) -> egui::Rect {
52 |     rect.min = map_to_pixel_pos(rect.min, ppi, f32::floor);
53 |     rect.max = map_to_pixel_pos(rect.max, ppi, f32::ceil);
54 |     rect
55 | }
56 | 
57 | pub fn shrink_to_pixel(mut rect: egui::Rect, ppi: f32) -> egui::Rect {
58 |     rect.min = map_to_pixel_pos(rect.min, ppi, f32::ceil);
59 |     rect.max = map_to_pixel_pos(rect.max, ppi, f32::floor);
60 |     rect
61 | }
62 | 
63 | pub fn round_to_pixel(mut rect: egui::Rect, pixels_per_point: f32) -> egui::Rect {
64 |     rect.min = map_to_pixel_pos(rect.min, pixels_per_point, f32::round);
65 |     rect.max = map_to_pixel_pos(rect.max, pixels_per_point, f32::round);
66 |     rect
67 | }
68 | 
69 | pub fn map_to_pixel_pos(mut pos: egui::Pos2, ppi: f32, map: fn(f32) -> f32) -> egui::Pos2 {
70 |     pos.x = map_to_pixel(pos.x, ppi, map);
71 |     pos.y = map_to_pixel(pos.y, ppi, map);
72 |     pos
73 | }
74 | 
75 | pub fn map_to_pixel_vec(mut pos: egui::Vec2, ppi: f32, map: fn(f32) -> f32) -> egui::Vec2 {
76 |     pos.x = map_to_pixel(pos.x, ppi, map);
77 |     pos.y = map_to_pixel(pos.y, ppi, map);
78 |     pos
79 | }
80 | 
81 | #[inline(always)]
82 | pub fn map_to_pixel(point: f32, ppi: f32, map: fn(f32) -> f32) -> f32 {
83 |     map(point * ppi) / ppi
84 | }
85 | 


--------------------------------------------------------------------------------
/src/util/anymap.rs:
--------------------------------------------------------------------------------
  1 | use bevy::utils::HashMap;
  2 | use std::any::{Any, TypeId};
  3 | 
  4 | #[derive(Default)]
  5 | pub struct AnyMap {
  6 |     data: HashMap<TypeId, Box<dyn Any>>,
  7 | }
  8 | 
  9 | unsafe impl Send for AnyMap {}
 10 | unsafe impl Sync for AnyMap {}
 11 | 
 12 | impl AnyMap {
 13 |     #[inline]
 14 |     pub fn has<R: Any>(&self) -> bool {
 15 |         self.data.contains_key(&TypeId::of::<R>())
 16 |     }
 17 | 
 18 |     #[inline]
 19 |     pub fn insert<R: Any>(&mut self, res: R) -> Option<Box<R>> {
 20 |         self.data
 21 |             .insert(TypeId::of::<R>(), Box::new(res))
 22 |             .map(|r| unsafe { r.downcast::<R>().unwrap_unchecked() })
 23 |     }
 24 | 
 25 |     #[inline]
 26 |     pub fn get_or_insert<R: Any>(&mut self, default: impl FnOnce() -> R) -> &mut R {
 27 |         unsafe {
 28 |             self.data
 29 |                 .entry(TypeId::of::<R>())
 30 |                 .or_insert_with(|| Box::new(default()))
 31 |                 .downcast_mut::<R>()
 32 |                 .unwrap_unchecked()
 33 |         }
 34 |     }
 35 | 
 36 |     #[inline]
 37 |     pub fn get<R: Any>(&self) -> Option<&R> {
 38 |         self.data
 39 |             .get(&TypeId::of::<R>())
 40 |             .map(|r| unsafe { r.downcast_ref::<R>().unwrap_unchecked() })
 41 |     }
 42 | 
 43 |     #[inline]
 44 |     pub fn get_mut<R: Any>(&mut self) -> Option<&mut R> {
 45 |         self.data
 46 |             .get_mut(&TypeId::of::<R>())
 47 |             .map(|r| unsafe { r.downcast_mut::<R>().unwrap_unchecked() })
 48 |     }
 49 | 
 50 |     #[inline]
 51 |     pub fn remove<R: Any>(&mut self) -> Option<Box<R>> {
 52 |         self.data
 53 |             .remove(&TypeId::of::<R>())
 54 |             .map(|r| unsafe { r.downcast::<R>().unwrap_unchecked() })
 55 |     }
 56 | 
 57 |     /// # Safety
 58 |     ///
 59 |     /// Can produce multiple mutable references.
 60 |     #[inline]
 61 |     #[track_caller]
 62 |     pub unsafe fn query<'a, Q: AnyMapQuery<'a>>(&'a mut self) -> Q::Result {
 63 |         Q::query(self)
 64 |     }
 65 | }
 66 | 
 67 | pub trait AnyMapQuery<'a> {
 68 |     type Result;
 69 | 
 70 |     #[track_caller]
 71 |     fn query(map: &'a mut AnyMap) -> Self::Result;
 72 | }
 73 | 
 74 | impl<'a, T: Any> AnyMapQuery<'a> for Option<&'a T> {
 75 |     type Result = Option<&'a T>;
 76 | 
 77 |     #[track_caller]
 78 |     fn query(map: &'a mut AnyMap) -> Self::Result {
 79 |         map.data
 80 |             .get(&TypeId::of::<T>())
 81 |             .and_then(|r| r.downcast_ref::<T>())
 82 |     }
 83 | }
 84 | 
 85 | impl<'a, T: Any> AnyMapQuery<'a> for &'a T {
 86 |     type Result = &'a T;
 87 | 
 88 |     #[track_caller]
 89 |     fn query(map: &'a mut AnyMap) -> Self::Result {
 90 |         <Option<&'a T> as AnyMapQuery<'a>>::query(map).unwrap()
 91 |     }
 92 | }
 93 | 
 94 | impl<'a, T: Any> AnyMapQuery<'a> for Option<&'a mut T> {
 95 |     type Result = Option<&'a mut T>;
 96 | 
 97 |     #[track_caller]
 98 |     fn query(map: &'a mut AnyMap) -> Self::Result {
 99 |         map.data
100 |             .get_mut(&TypeId::of::<T>())
101 |             .and_then(|r| r.downcast_mut::<T>())
102 |     }
103 | }
104 | 
105 | impl<'a, T: Any> AnyMapQuery<'a> for &'a mut T {
106 |     type Result = &'a mut T;
107 | 
108 |     #[track_caller]
109 |     fn query(map: &'a mut AnyMap) -> Self::Result {
110 |         <Option<&'a mut T> as AnyMapQuery<'a>>::query(map).unwrap()
111 |     }
112 | }
113 | 
114 | macro_rules! impl_tuple {
115 |     ($($type:ident),+) => {
116 |         impl<'a, $($type: AnyMapQuery<'a>),+> AnyMapQuery<'a> for ($($type,)+) {
117 |             type Result = ($($type::Result,)+);
118 | 
119 |             #[track_caller]
120 |             fn query(map: &'a mut AnyMap) -> Self::Result {
121 |                 unsafe {
122 |                     (
123 |                         $( $type::query(&mut *(map as *mut _)), )+
124 |                     )
125 |                 }
126 |             }
127 |         }
128 |     };
129 | }
130 | 
131 | impl_tuple!(A);
132 | impl_tuple!(A, B);
133 | impl_tuple!(A, B, C);
134 | impl_tuple!(A, B, C, D);
135 | impl_tuple!(A, B, C, D, E);
136 | impl_tuple!(A, B, C, D, E, F);
137 | impl_tuple!(A, B, C, D, E, F, G);
138 | impl_tuple!(A, B, C, D, E, F, G, H);
139 | impl_tuple!(A, B, C, D, E, F, G, H, I);
140 | impl_tuple!(A, B, C, D, E, F, G, H, I, J);
141 | impl_tuple!(A, B, C, D, E, F, G, H, I, J, K);
142 | impl_tuple!(A, B, C, D, E, F, G, H, I, J, K, L);
143 | 
144 | #[test]
145 | fn query() {
146 |     struct Foo;
147 |     struct Bar;
148 | 
149 |     let mut store = AnyMap::default();
150 | 
151 |     store.insert(Foo);
152 |     store.insert(Bar);
153 | 
154 |     let (_foo, _bar, _opt_foo) = unsafe { store.query::<(&Foo, &mut Bar, Option<&Foo>)>() };
155 | }
156 | 


--------------------------------------------------------------------------------
/src/util/reflect.rs:
--------------------------------------------------------------------------------
 1 | use bevy::prelude::*;
 2 | use bevy::reflect::*;
 3 | 
 4 | pub fn debug_reflect(level: usize, reflect: &dyn Reflect) {
 5 |     if let Some(value) = reflect.downcast_ref::<f32>() {
 6 |         return println!("<{}> {}", reflect.type_name(), value);
 7 |     }
 8 | 
 9 |     if let Some(value) = reflect.downcast_ref::<Vec3>() {
10 |         return println!("<{}> {}", reflect.type_name(), value);
11 |     }
12 |     if let Some(value) = reflect.downcast_ref::<Quat>() {
13 |         return println!("<{}> {}", reflect.type_name(), value);
14 |     }
15 |     if let Some(value) = reflect.downcast_ref::<String>() {
16 |         return println!("<{}> {}", reflect.type_name(), value);
17 |     }
18 | 
19 |     println!();
20 |     for _ in 0..level {
21 |         print!("  ");
22 |     }
23 | 
24 |     match reflect.reflect_ref() {
25 |         ReflectRef::Struct(reflect) => debug_struct(level + 1, reflect),
26 |         ReflectRef::TupleStruct(reflect) => debug_tuple_struct(level + 1, reflect),
27 |         ReflectRef::Tuple(reflect) => debug_tuple(level + 1, reflect),
28 |         ReflectRef::List(reflect) => debug_list(level + 1, reflect),
29 |         ReflectRef::Array(reflect) => debug_array(level + 1, reflect),
30 |         ReflectRef::Map(reflect) => debug_map(level + 1, reflect),
31 |         ReflectRef::Value(reflect) => println!("{}", reflect.type_name()),
32 |     }
33 | }
34 | 
35 | pub fn debug_struct(level: usize, reflect: &(dyn Struct + 'static)) {
36 |     println!("{} {{", reflect.type_name());
37 |     for (index, field) in reflect.iter_fields().enumerate() {
38 |         if let Some(name) = reflect.name_at(index) {
39 |             for _ in 0..level {
40 |                 print!("  ");
41 |             }
42 |             print!("{}: ", name);
43 |         }
44 |         debug_reflect(level + 1, field);
45 |     }
46 |     for _ in 0..level.saturating_sub(1) {
47 |         print!("  ");
48 |     }
49 |     println!("}}");
50 | }
51 | 
52 | pub fn debug_tuple_struct(level: usize, reflect: &(dyn TupleStruct + 'static)) {
53 |     println!("tuple_struct<{}>", reflect.type_name());
54 |     for index in 0..reflect.field_len() {
55 |         let field = reflect.field(index).unwrap();
56 |         debug_reflect(level + 1, field);
57 |     }
58 | }
59 | 
60 | pub fn debug_tuple(level: usize, reflect: &(dyn Tuple + 'static)) {
61 |     println!("tuple<{}>", reflect.type_name());
62 |     for index in 0..reflect.field_len() {
63 |         let field = reflect.field(index).unwrap();
64 |         debug_reflect(level + 1, field);
65 |     }
66 | }
67 | 
68 | pub fn debug_list(_level: usize, reflect: &(dyn List + 'static)) {
69 |     println!("list<{}>", reflect.type_name());
70 | }
71 | 
72 | pub fn debug_array(_level: usize, reflect: &(dyn Array + 'static)) {
73 |     println!("array<{}>", reflect.type_name());
74 | }
75 | 
76 | pub fn debug_map(_level: usize, reflect: &(dyn Map + 'static)) {
77 |     println!("map<{}>", reflect.type_name());
78 | }
79 | 


--------------------------------------------------------------------------------
/src/util/slice.rs:
--------------------------------------------------------------------------------
  1 | use std::marker::PhantomData;
  2 | 
  3 | pub fn array_windows<T, const N: usize>(slice: &[T]) -> ArrayWindows<'_, T, N> {
  4 |     assert_ne!(N, 0);
  5 |     ArrayWindows::new(slice)
  6 | }
  7 | 
  8 | /// A windowed iterator over a slice in overlapping chunks (`N` elements at a
  9 | /// time), starting at the beginning of the slice
 10 | ///
 11 | /// This struct is created by the [`array_windows`] method on [slices].
 12 | ///
 13 | /// # Example
 14 | ///
 15 | /// ```
 16 | /// #![feature(array_windows)]
 17 | ///
 18 | /// let slice = [0, 1, 2, 3];
 19 | /// let iter = slice.array_windows::<2>();
 20 | /// ```
 21 | ///
 22 | /// [`array_windows`]: slice::array_windows
 23 | /// [slices]: slice
 24 | #[derive(Debug, Clone, Copy)]
 25 | #[must_use = "iterators are lazy and do nothing unless consumed"]
 26 | pub struct ArrayWindows<'a, T: 'a, const N: usize> {
 27 |     slice_head: *const T,
 28 |     num: usize,
 29 |     marker: PhantomData<&'a [T; N]>,
 30 | }
 31 | 
 32 | impl<'a, T: 'a, const N: usize> ArrayWindows<'a, T, N> {
 33 |     #[inline]
 34 |     pub(super) fn new(slice: &'a [T]) -> Self {
 35 |         let num_windows = slice.len().saturating_sub(N - 1);
 36 |         Self {
 37 |             slice_head: slice.as_ptr(),
 38 |             num: num_windows,
 39 |             marker: PhantomData,
 40 |         }
 41 |     }
 42 | }
 43 | 
 44 | impl<'a, T, const N: usize> Iterator for ArrayWindows<'a, T, N> {
 45 |     type Item = &'a [T; N];
 46 | 
 47 |     #[inline]
 48 |     fn next(&mut self) -> Option<Self::Item> {
 49 |         if self.num == 0 {
 50 |             return None;
 51 |         }
 52 |         // SAFETY:
 53 |         // This is safe because it's indexing into a slice guaranteed to be length > N.
 54 |         let ret = unsafe { &*self.slice_head.cast::<[T; N]>() };
 55 |         // SAFETY: Guaranteed that there are at least 1 item remaining otherwise
 56 |         // earlier branch would've been hit
 57 |         self.slice_head = unsafe { self.slice_head.add(1) };
 58 | 
 59 |         self.num -= 1;
 60 |         Some(ret)
 61 |     }
 62 | 
 63 |     #[inline]
 64 |     fn size_hint(&self) -> (usize, Option<usize>) {
 65 |         (self.num, Some(self.num))
 66 |     }
 67 | 
 68 |     #[inline]
 69 |     fn count(self) -> usize {
 70 |         self.num
 71 |     }
 72 | 
 73 |     #[inline]
 74 |     fn nth(&mut self, n: usize) -> Option<Self::Item> {
 75 |         if self.num <= n {
 76 |             self.num = 0;
 77 |             return None;
 78 |         }
 79 |         // SAFETY:
 80 |         // This is safe because it's indexing into a slice guaranteed to be length > N.
 81 |         let ret = unsafe { &*self.slice_head.add(n).cast::<[T; N]>() };
 82 |         // SAFETY: Guaranteed that there are at least n items remaining
 83 |         self.slice_head = unsafe { self.slice_head.add(n + 1) };
 84 | 
 85 |         self.num -= n + 1;
 86 |         Some(ret)
 87 |     }
 88 | 
 89 |     #[inline]
 90 |     fn last(mut self) -> Option<Self::Item> {
 91 |         self.nth(self.num.checked_sub(1)?)
 92 |     }
 93 | }
 94 | 
 95 | impl<'a, T, const N: usize> DoubleEndedIterator for ArrayWindows<'a, T, N> {
 96 |     #[inline]
 97 |     fn next_back(&mut self) -> Option<&'a [T; N]> {
 98 |         if self.num == 0 {
 99 |             return None;
100 |         }
101 |         // SAFETY: Guaranteed that there are n items remaining, n-1 for 0-indexing.
102 |         let ret = unsafe { &*self.slice_head.add(self.num - 1).cast::<[T; N]>() };
103 |         self.num -= 1;
104 |         Some(ret)
105 |     }
106 | 
107 |     #[inline]
108 |     fn nth_back(&mut self, n: usize) -> Option<&'a [T; N]> {
109 |         if self.num <= n {
110 |             self.num = 0;
111 |             return None;
112 |         }
113 |         // SAFETY: Guaranteed that there are n items remaining, n-1 for 0-indexing.
114 |         let ret = unsafe { &*self.slice_head.add(self.num - (n + 1)).cast::<[T; N]>() };
115 |         self.num -= n + 1;
116 |         Some(ret)
117 |     }
118 | }
119 | 
120 | //  impl<T, const N: usize> ExactSizeIterator for ArrayWindows<'_, T, N> {
121 | //      fn is_empty(&self) -> bool {
122 | //          self.num == 0
123 | //      }
124 | //  }
125 | 


--------------------------------------------------------------------------------
/src/workspace/builder/expr.rs:
--------------------------------------------------------------------------------
  1 | use super::FnBuilder;
  2 | use naga::{
  3 |     BinaryOperator, Constant, ConstantInner, Expression, Handle, MathFunction, ScalarKind,
  4 |     ScalarValue, Type, TypeInner, UnaryOperator, VectorSize,
  5 | };
  6 | 
  7 | #[derive(Debug)]
  8 | pub enum EmitError {
  9 |     PortNotFound,
 10 |     MaybeDefault,
 11 |     FailType,
 12 |     Resolve(naga::proc::ResolveError),
 13 |     Validation(naga::WithSpan<naga::valid::ValidationError>),
 14 |     Wgsl(naga::back::wgsl::Error),
 15 | }
 16 | 
 17 | pub type EmitResult<T = Handle<Expression>> = Result<T, EmitError>;
 18 | 
 19 | impl From<naga::proc::ResolveError> for EmitError {
 20 |     fn from(err: naga::proc::ResolveError) -> Self {
 21 |         Self::Resolve(err)
 22 |     }
 23 | }
 24 | 
 25 | impl From<naga::WithSpan<naga::valid::ValidationError>> for EmitError {
 26 |     fn from(err: naga::WithSpan<naga::valid::ValidationError>) -> Self {
 27 |         Self::Validation(err)
 28 |     }
 29 | }
 30 | 
 31 | impl From<naga::back::wgsl::Error> for EmitError {
 32 |     fn from(err: naga::back::wgsl::Error) -> Self {
 33 |         Self::Wgsl(err)
 34 |     }
 35 | }
 36 | 
 37 | pub trait Emit: 'static {
 38 |     fn emit(&self, function: &mut FnBuilder) -> EmitResult;
 39 | 
 40 |     fn sint(self) -> Cast
 41 |     where
 42 |         Self: Sized,
 43 |     {
 44 |         Cast(ScalarKind::Sint, Box::new(self))
 45 |     }
 46 | 
 47 |     fn uint(self) -> Cast
 48 |     where
 49 |         Self: Sized,
 50 |     {
 51 |         Cast(ScalarKind::Uint, Box::new(self))
 52 |     }
 53 | 
 54 |     fn float(self) -> Cast
 55 |     where
 56 |         Self: Sized,
 57 |     {
 58 |         Cast(ScalarKind::Float, Box::new(self))
 59 |     }
 60 | 
 61 |     fn negate(self) -> Unary
 62 |     where
 63 |         Self: Sized,
 64 |     {
 65 |         Unary(UnaryOperator::Negate, Box::new(self))
 66 |     }
 67 | 
 68 |     fn not(self) -> Unary
 69 |     where
 70 |         Self: Sized,
 71 |     {
 72 |         Unary(UnaryOperator::Not, Box::new(self))
 73 |     }
 74 | }
 75 | 
 76 | macro_rules! impl_emit {
 77 |     ($(
 78 |         $name:ident
 79 |         ($self:ident, $function:ident) $body:stmt
 80 |     )+) => {
 81 |         $(
 82 |             impl Emit for $name {
 83 |                 fn emit(&$self, $function: &mut FnBuilder) -> EmitResult {
 84 |                     $body
 85 |                 }
 86 |             }
 87 | 
 88 |             impl_emit!(@ $name Add add Add);
 89 |             impl_emit!(@ $name Sub sub Subtract);
 90 |             impl_emit!(@ $name Mul mul Multiply);
 91 |             impl_emit!(@ $name Div div Divide);
 92 |             impl_emit!(@ $name Rem rem Modulo);
 93 |             impl_emit!(@ $name BitAnd bitand And);
 94 |             impl_emit!(@ $name BitOr bitor InclusiveOr);
 95 |             impl_emit!(@ $name BitXor bitxor ExclusiveOr);
 96 |             impl_emit!(@ $name Shl shl ShiftLeft);
 97 |             impl_emit!(@ $name Shr shr ShiftRight);
 98 |         )+
 99 |     };
100 | 
101 |     (@ $for:ident $rust_op:ident $f:ident $naga_op:ident) => {
102 |         impl<RHS: Emit> std::ops::$rust_op<RHS> for $for {
103 |             type Output = Binary;
104 |             fn $f(self, rhs: RHS) -> Self::Output {
105 |                 Binary(Box::new(self), BinaryOperator::$naga_op, Box::new(rhs))
106 |             }
107 |         }
108 |     }
109 | }
110 | 
111 | #[derive(Clone, Copy)]
112 | pub struct FunctionArgument(pub u32);
113 | 
114 | #[derive(Clone, Copy)]
115 | pub struct AccessIndex(pub Handle<Expression>, pub u32);
116 | 
117 | pub struct Math(MathFunction, arrayvec::ArrayVec<Box<dyn Emit>, 4>);
118 | pub struct Cast(ScalarKind, Box<dyn Emit>);
119 | pub struct Binary(Box<dyn Emit>, BinaryOperator, Box<dyn Emit>);
120 | pub struct Unary(UnaryOperator, Box<dyn Emit>);
121 | 
122 | #[derive(Clone)]
123 | pub struct Expr(pub naga::Expression);
124 | 
125 | #[derive(Clone, Copy)]
126 | pub struct Sint(pub i64);
127 | #[derive(Clone, Copy)]
128 | pub struct Uint(pub u64);
129 | #[derive(Clone, Copy)]
130 | pub struct Float(pub f64);
131 | #[derive(Clone, Copy)]
132 | pub struct Bool(pub bool);
133 | 
134 | #[derive(Clone, Copy)]
135 | pub struct Wrap(pub Handle<Expression>);
136 | 
137 | pub struct Let {
138 |     name: String,
139 |     expr: Box<dyn Emit>,
140 | }
141 | 
142 | impl Let {
143 |     pub fn new(name: impl Into<String>, expr: impl Emit) -> Self {
144 |         Self {
145 |             name: name.into(),
146 |             expr: Box::new(expr),
147 |         }
148 |     }
149 | }
150 | 
151 | impl Emit for Handle<Expression> {
152 |     fn emit(&self, _: &mut FnBuilder) -> EmitResult {
153 |         Ok(*self)
154 |     }
155 | }
156 | 
157 | impl Emit for naga::ScalarValue {
158 |     fn emit(&self, function: &mut FnBuilder) -> EmitResult {
159 |         let value = *self;
160 |         let width = if matches!(self, ScalarValue::Bool(_)) {
161 |             naga::BOOL_WIDTH
162 |         } else {
163 |             4
164 |         };
165 |         let expr = Expression::Constant(function.module.constant(Constant {
166 |             name: None,
167 |             specialization: None,
168 |             inner: ConstantInner::Scalar { width, value },
169 |         }));
170 |         Ok(function.expression(expr))
171 |     }
172 | }
173 | 
174 | impl_emit! {
175 |     Wrap(self, _fn) Ok(self.0)
176 |     Expr(self, function) Ok(function.emit(self.0.clone()))
177 |     Sint(self, function) ScalarValue::Sint(self.0).emit(function)
178 |     Uint(self, function) ScalarValue::Uint(self.0).emit(function)
179 |     Float(self, function) ScalarValue::Float(self.0).emit(function)
180 |     Bool(self, function) ScalarValue::Bool(self.0).emit(function)
181 | 
182 |     AccessIndex(self, function) Ok(function.expression(Expression::AccessIndex { base: self.0, index: self.1 }))
183 |     FunctionArgument(self, function) Ok(function.expression(Expression::FunctionArgument(self.0)))
184 | 
185 |     Let(self, function) {
186 |         let expr = self.expr.emit(function)?;
187 |         function.insert_expression_name(expr, &self.name);
188 |         Ok(expr)
189 |     }
190 |     Math(self, function) {
191 |         let arg = &self.1;
192 |         let expr = Expression::Math {
193 |             fun: self.0,
194 |             arg: arg[0].emit(function)?,
195 |             arg1: (arg.len() > 1).then(|| arg[1].emit(function)).transpose()?,
196 |             arg2: (arg.len() > 2).then(|| arg[2].emit(function)).transpose()?,
197 |             arg3: (arg.len() > 3).then(|| arg[3].emit(function)).transpose()?,
198 |         };
199 |         Ok(function.emit(expr))
200 |     }
201 |     Cast(self, function) {
202 |         let expr = Expression::As {
203 |             expr: self.1.emit(function)?,
204 |             kind: self.0,
205 |             convert: Some(4),
206 |         };
207 |         Ok(function.emit(expr))
208 |     }
209 |     Binary(self, function) {
210 |         let expr = Expression::Binary {
211 |             left: self.0.emit(function)?,
212 |             op: self.1,
213 |             right: self.2.emit(function)?,
214 |         };
215 |         Ok(function.emit(expr))
216 |     }
217 |     Unary(self, function) {
218 |         let expr = Expression::Unary {
219 |             op: self.0,
220 |             expr: self.1.emit(function)?,
221 |         };
222 |         Ok(function.emit(expr))
223 |     }
224 | }
225 | 
226 | impl<T: Emit> Emit for [T; 2] {
227 |     fn emit(&self, function: &mut FnBuilder) -> EmitResult {
228 |         let components = vec![self[0].emit(function)?, self[1].emit(function)?];
229 |         let ty = function.extract_type(components[0])?;
230 |         let kind = ty.scalar_kind().unwrap();
231 |         let ty = function.insert_type(Type {
232 |             name: None,
233 |             inner: TypeInner::Vector {
234 |                 size: VectorSize::Bi,
235 |                 kind,
236 |                 width: match kind {
237 |                     ScalarKind::Bool => naga::BOOL_WIDTH,
238 |                     _ => 4,
239 |                 },
240 |             },
241 |         });
242 |         Ok(function.emit(Expression::Compose { ty, components }))
243 |     }
244 | }
245 | impl<T: Emit> Emit for [T; 3] {
246 |     fn emit(&self, function: &mut FnBuilder) -> EmitResult {
247 |         let components = vec![
248 |             self[0].emit(function)?,
249 |             self[1].emit(function)?,
250 |             self[2].emit(function)?,
251 |         ];
252 |         let ty = function.extract_type(components[0])?;
253 |         let kind = ty.scalar_kind().unwrap();
254 |         let ty = function.insert_type(Type {
255 |             name: None,
256 |             inner: TypeInner::Vector {
257 |                 size: VectorSize::Tri,
258 |                 kind,
259 |                 width: match kind {
260 |                     ScalarKind::Bool => naga::BOOL_WIDTH,
261 |                     _ => 4,
262 |                 },
263 |             },
264 |         });
265 |         Ok(function.emit(Expression::Compose { ty, components }))
266 |     }
267 | }
268 | impl<T: Emit> Emit for [T; 4] {
269 |     fn emit(&self, function: &mut FnBuilder) -> EmitResult {
270 |         let components = vec![
271 |             self[0].emit(function)?,
272 |             self[1].emit(function)?,
273 |             self[2].emit(function)?,
274 |             self[3].emit(function)?,
275 |         ];
276 |         let ty = function.extract_type(components[0])?;
277 |         let kind = ty.scalar_kind().unwrap();
278 |         let ty = function.insert_type(Type {
279 |             name: None,
280 |             inner: TypeInner::Vector {
281 |                 size: VectorSize::Quad,
282 |                 kind,
283 |                 width: match kind {
284 |                     ScalarKind::Bool => naga::BOOL_WIDTH,
285 |                     _ => 4,
286 |                 },
287 |             },
288 |         });
289 |         Ok(function.emit(Expression::Compose { ty, components }))
290 |     }
291 | }
292 | 


--------------------------------------------------------------------------------
/src/workspace/builder/types.rs:
--------------------------------------------------------------------------------
  1 | use super::expr::{Emit, EmitResult};
  2 | use super::FnBuilder;
  3 | use naga::{
  4 |     front::Typifier,
  5 |     proc::{ResolveContext, ResolveError},
  6 |     Expression, Function, Handle, Module, ScalarKind, SwizzleComponent, Type, TypeInner,
  7 |     VectorSize,
  8 | };
  9 | 
 10 | pub struct BaseTypes {
 11 |     pub bool: Handle<Type>,
 12 |     pub bool2: Handle<Type>,
 13 |     pub bool3: Handle<Type>,
 14 |     pub bool4: Handle<Type>,
 15 | 
 16 |     pub u32: Handle<Type>,
 17 |     pub u32x2: Handle<Type>,
 18 |     pub u32x3: Handle<Type>,
 19 |     pub u32x4: Handle<Type>,
 20 | 
 21 |     pub i32: Handle<Type>,
 22 |     pub i32x2: Handle<Type>,
 23 |     pub i32x3: Handle<Type>,
 24 |     pub i32x4: Handle<Type>,
 25 | 
 26 |     pub f32: Handle<Type>,
 27 |     pub f32x2: Handle<Type>,
 28 |     pub f32x3: Handle<Type>,
 29 |     pub f32x4: Handle<Type>,
 30 | }
 31 | 
 32 | impl BaseTypes {
 33 |     pub fn new(module: &mut super::ModuleBuilder) -> Self {
 34 |         const fn scalar(kind: ScalarKind, width: u8) -> Type {
 35 |             let inner = TypeInner::Scalar { kind, width };
 36 |             Type { name: None, inner }
 37 |         }
 38 | 
 39 |         const fn vector(kind: ScalarKind, size: VectorSize, width: u8) -> Type {
 40 |             let inner = TypeInner::Vector { size, kind, width };
 41 |             Type { name: None, inner }
 42 |         }
 43 | 
 44 |         Self {
 45 |             bool: module.insert_type(scalar(ScalarKind::Bool, naga::BOOL_WIDTH)),
 46 |             bool2: module.insert_type(vector(ScalarKind::Bool, VectorSize::Bi, naga::BOOL_WIDTH)),
 47 |             bool3: module.insert_type(vector(ScalarKind::Bool, VectorSize::Tri, naga::BOOL_WIDTH)),
 48 |             bool4: module.insert_type(vector(ScalarKind::Bool, VectorSize::Quad, naga::BOOL_WIDTH)),
 49 | 
 50 |             u32: module.insert_type(scalar(ScalarKind::Uint, 4)),
 51 |             u32x2: module.insert_type(vector(ScalarKind::Uint, VectorSize::Bi, 4)),
 52 |             u32x3: module.insert_type(vector(ScalarKind::Uint, VectorSize::Tri, 4)),
 53 |             u32x4: module.insert_type(vector(ScalarKind::Uint, VectorSize::Quad, 4)),
 54 | 
 55 |             i32: module.insert_type(scalar(ScalarKind::Sint, 4)),
 56 |             i32x2: module.insert_type(vector(ScalarKind::Sint, VectorSize::Bi, 4)),
 57 |             i32x3: module.insert_type(vector(ScalarKind::Sint, VectorSize::Tri, 4)),
 58 |             i32x4: module.insert_type(vector(ScalarKind::Sint, VectorSize::Quad, 4)),
 59 | 
 60 |             f32: module.insert_type(scalar(ScalarKind::Float, 4)),
 61 |             f32x2: module.insert_type(vector(ScalarKind::Float, VectorSize::Bi, 4)),
 62 |             f32x3: module.insert_type(vector(ScalarKind::Float, VectorSize::Tri, 4)),
 63 |             f32x4: module.insert_type(vector(ScalarKind::Float, VectorSize::Quad, 4)),
 64 |         }
 65 |     }
 66 | }
 67 | 
 68 | pub fn extract_type<'a>(
 69 |     ifier: &'a mut Typifier,
 70 |     module: &'a Module,
 71 |     function: &'a Function,
 72 |     expr_handle: Handle<Expression>,
 73 | ) -> Result<&'a TypeInner, ResolveError> {
 74 |     let ctx = ResolveContext {
 75 |         constants: &module.constants,
 76 |         types: &module.types,
 77 |         global_vars: &module.global_variables,
 78 |         local_vars: &function.local_variables,
 79 |         functions: &module.functions,
 80 |         arguments: &function.arguments,
 81 |     };
 82 |     ifier.grow(expr_handle, &function.expressions, &ctx)?;
 83 |     Ok(ifier.get(expr_handle, &module.types))
 84 | }
 85 | 
 86 | /*
 87 | pub fn is_scalar(ty: &TypeInner) -> Option<ScalarKind> {
 88 |     match ty {
 89 |         TypeInner::Scalar { kind, .. } => Some(*kind),
 90 |         _ => None,
 91 |     }
 92 | }
 93 | 
 94 | pub fn is_vector(ty: &TypeInner) -> Option<(ScalarKind, VectorSize)> {
 95 |     match ty {
 96 |         TypeInner::Vector { kind, size, .. } => Some((*kind, *size)),
 97 |         _ => None,
 98 |     }
 99 | }
100 | 
101 | #[derive(Clone, Copy)]
102 | pub enum MatrixKind {
103 |     M2,
104 |     M3,
105 |     M4,
106 | }
107 | */
108 | 
109 | #[derive(Clone, Copy)]
110 | pub enum VectorKind {
111 |     V1,
112 |     V2,
113 |     V3,
114 |     V4,
115 | }
116 | 
117 | impl VectorKind {
118 |     pub fn parse(ty: &TypeInner) -> Option<Self> {
119 |         match ty {
120 |             TypeInner::Scalar { .. } => Some(VectorKind::V1),
121 |             TypeInner::Vector { size, .. } => Some(match size {
122 |                 VectorSize::Bi => VectorKind::V2,
123 |                 VectorSize::Tri => VectorKind::V3,
124 |                 VectorSize::Quad => VectorKind::V4,
125 |             }),
126 |             _ => None,
127 |         }
128 |     }
129 | }
130 | 
131 | impl VectorKind {
132 |     pub fn min(self, other: Self) -> Self {
133 |         match (self, other) {
134 |             (Self::V1, _) | (_, Self::V1) => Self::V1,
135 |             (Self::V2, _) | (_, Self::V2) => Self::V2,
136 |             (Self::V3, _) | (_, Self::V3) => Self::V3,
137 |             (Self::V4, Self::V4) => Self::V4,
138 |         }
139 |     }
140 | 
141 |     pub fn max(self, other: Self) -> Self {
142 |         match (self, other) {
143 |             (Self::V4, _) | (_, Self::V4) => Self::V4,
144 |             (Self::V3, _) | (_, Self::V3) => Self::V3,
145 |             (Self::V2, _) | (_, Self::V2) => Self::V2,
146 |             (Self::V1, Self::V1) => Self::V1,
147 |         }
148 |     }
149 | 
150 |     pub fn splat<T: Emit + Copy>(&self, function: &mut FnBuilder, value: T) -> EmitResult {
151 |         match self {
152 |             VectorKind::V1 => value.emit(function),
153 |             VectorKind::V2 => [value, value].emit(function),
154 |             VectorKind::V3 => [value, value, value].emit(function),
155 |             VectorKind::V4 => [value, value, value, value].emit(function),
156 |         }
157 |     }
158 | }
159 | 
160 | impl<'a, 'storage> FnBuilder<'a, 'storage> {
161 |     pub fn resolve_vector(
162 |         &mut self,
163 |         expr: Handle<Expression>,
164 |         src: VectorKind,
165 |         dst: VectorKind,
166 |     ) -> EmitResult {
167 |         use super::expr::Float;
168 |         use VectorKind::*;
169 | 
170 |         let function = self;
171 | 
172 |         let zero = Float(0.0).emit(function)?;
173 |         let one = Float(1.0).emit(function)?;
174 | 
175 |         macro_rules! swizzle {
176 |             ($x:ident, $y:ident, $z:ident, $w:ident) => {
177 |                 [
178 |                     swizzle!(@$x),
179 |                     swizzle!(@$y),
180 |                     swizzle!(@$z),
181 |                     swizzle!(@$w),
182 |                 ]
183 |             };
184 | 
185 |             (@x) => { SwizzleComponent::X };
186 |             (@y) => { SwizzleComponent::Y };
187 |             (@z) => { SwizzleComponent::Z };
188 |             (@w) => { SwizzleComponent::W };
189 |         }
190 | 
191 |         macro_rules! expr_swizzle {
192 |             ($vector:expr, $size:ident, [$x:ident, $y:ident, $z:ident, $w:ident]) => {
193 |                 Expression::Swizzle {
194 |                     vector: $vector,
195 |                     size: naga::VectorSize::$size,
196 |                     pattern: swizzle!($x, $y, $z, $w),
197 |                 }
198 |             };
199 |         }
200 | 
201 |         Ok(match (src, dst) {
202 |             // same
203 |             (V1, V1) | (V2, V2) | (V3, V3) | (V4, V4) => expr,
204 | 
205 |             // promoting
206 |             (V1, V2) => [expr, zero].emit(function)?,
207 |             (V1, V3) => [expr, zero, zero].emit(function)?,
208 |             (V1, V4) => [expr, zero, zero, one].emit(function)?,
209 | 
210 |             (V2, V3) => {
211 |                 let x = function.access_index(expr, 0);
212 |                 let y = function.access_index(expr, 1);
213 |                 [x, y, zero].emit(function)?
214 |             }
215 |             (V2, V4) => {
216 |                 let x = function.access_index(expr, 0);
217 |                 let y = function.access_index(expr, 1);
218 |                 [x, y, zero, one].emit(function)?
219 |             }
220 | 
221 |             (V3, V4) => {
222 |                 let x = function.access_index(expr, 0);
223 |                 let y = function.access_index(expr, 1);
224 |                 let z = function.access_index(expr, 2);
225 |                 [x, y, z, one].emit(function)?
226 |             }
227 | 
228 |             // truncating
229 |             (V2, V1) | (V3, V1) | (V4, V1) => function.access_index(expr, 0),
230 |             (V3, V2) | (V4, V2) => function.emit(expr_swizzle!(expr, Bi, [x, y, z, w])),
231 |             (V4, V3) => function.emit(expr_swizzle!(expr, Tri, [x, y, z, w])),
232 |         })
233 |     }
234 | }
235 | 


--------------------------------------------------------------------------------
/src/workspace/builtin.wgsl:
--------------------------------------------------------------------------------
  1 | fn builtin_blackbody(temperature: f32) -> vec3<f32> {
  2 |     var color = vec3<f32>(
  3 |         56100000.0 * pow(temperature, -1.5) + 148.0,
  4 |         100.04 * log(temperature) - 623.6,
  5 |         194.18 * log(temperature) - 1448.6,
  6 |     );
  7 | 
  8 |     if (temperature > 6500.0) {
  9 |         color.y = 35200000.0 * pow(temperature, -1.5) + 184.0;
 10 |     }
 11 | 
 12 |     color = clamp(color, vec3<f32>(0.0, 0.0, 0.0), vec3<f32>(255.0, 255.0, 255.0)) / vec3<f32>(255.0, 255.0, 255.0);
 13 | 
 14 |     if (temperature < 1000.0) {
 15 |         color = color * temperature / 1000.0;
 16 |     }
 17 | 
 18 |     return color;
 19 | }
 20 | 
 21 | fn builtin_inverse_lerp_1(a: f32, b: f32, t: f32) -> f32 {
 22 |     return (t - a)/(b - a);
 23 | }
 24 | fn builtin_inverse_lerp_2(a: vec2<f32>, b: vec2<f32>, t: vec2<f32>) -> vec2<f32> {
 25 |     return (t - a)/(b - a);
 26 | }
 27 | fn builtin_inverse_lerp_3(a: vec3<f32>, b: vec3<f32>, t: vec3<f32>) -> vec3<f32> {
 28 |     return (t - a)/(b - a);
 29 | }
 30 | fn builtin_inverse_lerp_4(a: vec4<f32>, b: vec4<f32>, t: vec4<f32>) -> vec4<f32> {
 31 |     return (t - a)/(b - a);
 32 | }
 33 | 
 34 | fn builtin_lerp_1(a: f32, b: f32, t: f32) -> f32 {
 35 |     return a + (b - a) * t;
 36 | }
 37 | fn builtin_lerp_2(a: vec2<f32>, b: vec2<f32>, t: vec2<f32>) -> vec2<f32> {
 38 |     return a + (b - a) * t;
 39 | }
 40 | fn builtin_lerp_3(a: vec3<f32>, b: vec3<f32>, t: vec3<f32>) -> vec3<f32> {
 41 |     return a + (b - a) * t;
 42 | }
 43 | fn builtin_lerp_4(a: vec4<f32>, b: vec4<f32>, t: vec4<f32>) -> vec4<f32> {
 44 |     return a + (b - a) * t;
 45 | }
 46 | 
 47 | fn builtin_random_range(seed: vec2<f32>, min: f32, max: f32) -> f32 {
 48 |     let rand = fract(sin(dot(seed, vec2<f32>(12.9898, 78.233))) * 43758.5453);
 49 |     return mix(min, max, rand);
 50 | }
 51 | 
 52 | 
 53 | fn builtin_remap_1(input: f32, in_range: vec2<f32>, out_range: vec2<f32>) -> f32 {
 54 |     return out_range.x + (input - in_range.x) * (out_range.y - out_range.x) / (in_range.y - in_range.x);
 55 | }
 56 | fn builtin_remap_2(input: vec2<f32>, in_range: vec2<f32>, out_range: vec2<f32>) -> vec2<f32> {
 57 |     return out_range.x + (input - in_range.x) * (out_range.y - out_range.x) / (in_range.y - in_range.x);
 58 | }
 59 | fn builtin_remap_3(input: vec3<f32>, in_range: vec2<f32>, out_range: vec2<f32>) -> vec3<f32> {
 60 |     return out_range.x + (input - in_range.x) * (out_range.y - out_range.x) / (in_range.y - in_range.x);
 61 | }
 62 | fn builtin_remap_4(input: vec4<f32>, in_range: vec2<f32>, out_range: vec2<f32>) -> vec4<f32> {
 63 |     return out_range.x + (input - in_range.x) * (out_range.y - out_range.x) / (in_range.y - in_range.x);
 64 | }
 65 | 
 66 | fn _gradient_noise_dir(p: vec2<f32>) -> vec2<f32> {
 67 |     let p = p % vec2<f32>(289.0);
 68 |     let x = (34.0 * p.x + 1.0) * p.x % 289.0 + p.y;
 69 |     let x = (34.0 * x + 1.0) * x % 289.0;
 70 |     let x = fract(x / 41.0) * 2.0 - 1.0;
 71 |     return normalize(vec2<f32>(x - floor(x + 0.5), abs(x) - 0.5));
 72 | }
 73 | 
 74 | fn _gradient_noise(p: vec2<f32>) -> f32 {
 75 |     let ip = floor(p);
 76 |     let fp = fract(p);
 77 |     let d00 = dot(_gradient_noise_dir(ip), fp);
 78 |     let d01 = dot(_gradient_noise_dir(ip + vec2<f32>(0.0, 1.0)), fp - vec2<f32>(0.0, 1.0));
 79 |     let d10 = dot(_gradient_noise_dir(ip + vec2<f32>(1.0, 0.0)), fp - vec2<f32>(1.0, 0.0));
 80 |     let d11 = dot(_gradient_noise_dir(ip + vec2<f32>(1.0, 1.0)), fp - vec2<f32>(1.0, 1.0));
 81 |     let fp = fp * fp * fp * (fp * (fp * 6.0 - 15.0) + 10.0);
 82 |     return mix(mix(d00, d01, fp.y), mix(d10, d11, fp.y), fp.x);
 83 | }
 84 | 
 85 | fn builtin_gradient_noise(uv: vec2<f32>, scale: f32) -> f32 {
 86 |     return _gradient_noise(uv * scale) + 0.5;
 87 | }
 88 | 
 89 | fn _random_01(uv: vec2<f32>) -> f32 {
 90 |     return fract(sin(dot(uv, vec2<f32>(12.9898, 78.233)))*43758.5453);
 91 | }
 92 | 
 93 | fn _value_noise(uv: vec2<f32>) -> f32 {
 94 |     let i = floor(uv);
 95 |     let f = fract(uv);
 96 |     let f = f * f * (3.0 - 2.0 * f);
 97 | 
 98 |     //let uv = abs(fract(uv) - 0.5);
 99 | 
100 |     let r0 = _random_01(i + vec2<f32>(0.0, 0.0));
101 |     let r1 = _random_01(i + vec2<f32>(1.0, 0.0));
102 |     let r2 = _random_01(i + vec2<f32>(0.0, 1.0));
103 |     let r3 = _random_01(i + vec2<f32>(1.0, 1.0));
104 | 
105 |     return mix(mix(r0, r1, f.x), mix(r2, r3, f.x), f.y);
106 | }
107 | 
108 | fn builtin_simple_noise(uv: vec2<f32>, scale: f32) -> f32 {
109 |     let t = 0.0;
110 |     let t = t + _value_noise(vec2<f32>(uv.x * scale    , uv.y * scale    )) * 0.125;
111 |     let t = t + _value_noise(vec2<f32>(uv.x * scale/2.0, uv.y * scale/2.0)) * 0.25;
112 |     let t = t + _value_noise(vec2<f32>(uv.x * scale/4.0, uv.y * scale/4.0)) * 0.5;
113 |     return t;
114 | }
115 | 
116 | 
117 | //  fn color_conv_rgb_rgb(input: vec3<f32>) -> vec3<f32> {
118 | //      return input;
119 | //  }
120 | //  fn color_conv_linear_linear(input: vec3<f32>) -> vec3<f32> {
121 | //      return input;
122 | //  }
123 | //  fn color_conv_hsv_hsv(input: vec3<f32>) -> vec3<f32> {
124 | //      return input;
125 | //  }
126 | 
127 | 
128 | //  fn color_conv_rgb_linear(input: vec3<f32>) -> vec3<f32> {
129 | //      let lo = input / 12.92;
130 | //      let hi = pow(max(abs((input + 0.055) / 1.055), vec3<f32>(0.0000001192092896)), vec3<f32>(2.4));
131 | //      return select(hi, lo, vec3<bool>(input.x <= 0.04045, input.y <= 0.04045, input.y <= 0.04045));
132 | //  }
133 | 
134 | //  fn color_conv_rgb_hsv(input: vec3<f32>) -> vec3<f32> {
135 | //      let k = vec4<f32>(0.0, -1.0 / 3.0, 2.0 / 3.0, -1.0);
136 | //      let p = mix(vec4<f32>(input.bg, k.wz), vec4<f32>(input.gb, k.xy), step(input.b, input.g));
137 | //      let q = mix(vec4<f32>(p.xyw, input.r), vec4<f32>(input.r, p.yzx), step(p.x, input.r));
138 | //      let d = q.x - min(q.w, q.y);
139 | //      let e = 0.0000000001;
140 | //      return vec3<f32>(abs(q.z + (q.w - q.y)/(6.0 * d + e)), d / (q.x + e), q.x);
141 | //  }
142 | 
143 | //  fn color_conv_linear_rgb(input: vec3<f32>) -> vec3<f32> {
144 | //      let lo = input * 12.92;
145 | //      let hi = (pow(max(abs(input), vec3<f32>(0.0000001192092896)), vec3<f32>(1.0 / 2.4, 1.0 / 2.4, 1.0 / 2.4)) * 1.055) - 0.055;
146 | //      return select(hi, lo, vec3<bool>(input.x <= 0.0031308, input.y <= 0.0031308, input.y <= 0.0031308));
147 | //  }
148 | 
149 | //  fn color_conv_linear_hls(input: vec3<f32>) -> vec3<f32> {
150 | //      let lo = input * 12.92;
151 | //      let hi = (pow(max(abs(input), vec3<f32>(0.0000001192092896)), vec3<f32>(1.0 / 2.4, 1.0 / 2.4, 1.0 / 2.4)) * 1.055) - 0.055;
152 | //      let linear = select(hi, lo, vec3<bool>(input.x <= 0.0031308, input.y <= 0.0031308, input.y <= 0.0031308));
153 | //      let k = vec4<f32>(0.0, -1.0 / 3.0, 2.0 / 3.0, -1.0);
154 | //      let p = mix(vec4<f32>(linear.bg, k.wz), vec4<f32>(linear.gb, k.xy), step(linear.b, linear.g));
155 | //      let q = mix(vec4<f32>(p.xyw, linear.r), vec4<f32>(linear.r, p.yzx), step(p.x, linear.r));
156 | //      let d = q.x - min(q.w, q.y);
157 | //      let e = 0.0000000001;
158 | //      return vec3<f32>(abs(q.z + (q.w - q.y)/(6.0 * d + e)), d / (q.x + e), q.x);
159 | //  }
160 | 
161 | //  fn color_conv_hsv_rgb(input: vec3<f32>) -> vec3<f32> {
162 | //      let k = vec4<f32>(1.0, 2.0 / 3.0, 1.0 / 3.0, 3.0);
163 | //      let p = abs(fract(input.xxx + k.xyz) * 6.0 - k.www);
164 | //      return input.z * mix(k.xxx, clamp(p - k.xxx, vec3<f32>(0.0), vec3<f32>(1.0)), input.y);
165 | //  }
166 | 
167 | //  fn color_conv_hsv_linear(input: vec3<f32>) -> vec3<f32> {
168 | //      let k = vec4<f32>(1.0, 2.0 / 3.0, 1.0 / 3.0, 3.0);
169 | //      let p = abs(fract(input.xxx + k.xyz) * 6.0 - k.www);
170 | //      let rgb = input.z * mix(k.xxx, clamp(p - k.xxx, vec3<f32>(0.0), vec3<f32>(1.0)), input.y);
171 | //      let lo = rgb / 12.92;
172 | //      let hi = pow(max(abs((rgb + 0.055) / 1.055), vec3<f32>(1.192092896e-07)), vec3<f32>(2.4, 2.4, 2.4));
173 | //      return select(hi, lo, vec3<bool>(input.x <= 0.04045, input.y <= 0.04045, input.y <= 0.04045));
174 | //  }
175 | 


--------------------------------------------------------------------------------
/src/workspace/graph.rs:
--------------------------------------------------------------------------------
  1 | use ahash::{AHashMap, AHashSet};
  2 | use std::collections::VecDeque;
  3 | 
  4 | #[derive(Default, Clone)]
  5 | pub struct Graph<Key: Default + Copy + Eq + std::hash::Hash> {
  6 |     adjacenty_list: AHashMap<Key, AHashSet<Key>>,
  7 |     queue: VecDeque<Key>,
  8 |     visited: AHashSet<Key>,
  9 | }
 10 | 
 11 | impl<Key: Default + Copy + Eq + std::hash::Hash> Graph<Key> {
 12 |     /// Add edge from `src` to `dst`.
 13 |     pub fn add_edge(&mut self, src: Key, dst: Key) {
 14 |         self.adjacenty_list
 15 |             .entry(src)
 16 |             .or_insert_with(AHashSet::default)
 17 |             .insert(dst);
 18 | 
 19 |         self.adjacenty_list
 20 |             .entry(dst)
 21 |             .or_insert_with(AHashSet::default);
 22 |     }
 23 | 
 24 |     pub fn clear(&mut self) {
 25 |         self.adjacenty_list.clear();
 26 |         self.queue.clear();
 27 |         self.visited.clear();
 28 |     }
 29 | 
 30 |     /// A BFS based function to check whether `dst` is reachable from `src`.
 31 |     pub fn reachable(&mut self, src: Key, dst: Key) -> bool {
 32 |         // Base case
 33 |         if src == dst {
 34 |             return true;
 35 |         }
 36 | 
 37 |         // Mark all the vertices as not visited
 38 |         self.visited.clear();
 39 | 
 40 |         // Create a queue for BFS
 41 |         self.queue.clear();
 42 | 
 43 |         // Mark the current node as visited and enqueue it
 44 |         self.visited.insert(src);
 45 |         self.queue.push_back(src);
 46 | 
 47 |         // Dequeue a vertex from queue and print it
 48 |         while let Some(n) = self.queue.pop_front() {
 49 |             // Get all adjacent vertices of the dequeued vertex s
 50 |             // If a adjacent has not been visited, then mark it visited and enqueue it
 51 |             for &adjacent_node in self.adjacenty_list[&n].iter() {
 52 |                 // If this adjacent node is the destination node, then return true
 53 |                 if adjacent_node == dst {
 54 |                     return true;
 55 |                 }
 56 | 
 57 |                 // Else, continue to do BFS
 58 |                 if !self.visited.contains(&adjacent_node) {
 59 |                     self.visited.insert(adjacent_node);
 60 |                     self.queue.push_back(adjacent_node);
 61 |                 }
 62 |             }
 63 |         }
 64 | 
 65 |         // If BFS is complete without visiting d
 66 |         false
 67 |     }
 68 | 
 69 |     // prints all not yet visited vertices reachable from s
 70 |     pub fn _dfs<E>(&self, s: Key, mut handle: impl FnMut(Key) -> Result<(), E>) -> Result<(), E> {
 71 |         // Initially mark all verices as not visited
 72 |         let mut visited: AHashSet<Key> = AHashSet::default();
 73 | 
 74 |         // Create a stack for DFS and push the current source node.
 75 |         let mut stack = vec![s];
 76 | 
 77 |         // Pop a vertex from stack and print it
 78 |         while let Some(s) = stack.pop() {
 79 |             // Stack may contain same vertex twice.
 80 |             // So we need to print the popped item only if it is not visited.
 81 |             if !visited.contains(&s) {
 82 |                 handle(s)?;
 83 |                 visited.insert(s);
 84 |             }
 85 | 
 86 |             // Get all adjacent vertices of the popped vertex s
 87 |             // If a adjacent has not been visited, then push it
 88 |             // to the stack.
 89 |             if let Some(list) = self.adjacenty_list.get(&s) {
 90 |                 for item in list.iter() {
 91 |                     if !visited.contains(item) {
 92 |                         stack.push(*item);
 93 |                     }
 94 |                 }
 95 |             }
 96 |         }
 97 |         Ok(())
 98 |     }
 99 | }
100 | 
101 | #[test]
102 | fn test_detect_cyclic() {
103 |     // Driver program to test methods of graph class
104 |     // Create a graph given in the above diagram
105 |     let mut g = Graph::<i8>::default();
106 | 
107 |     g.add_edge(0, 1);
108 |     g.add_edge(0, 2);
109 |     g.add_edge(1, 2);
110 |     g.add_edge(2, 0);
111 |     g.add_edge(2, 3);
112 |     g.add_edge(3, 3);
113 | 
114 |     assert!(g.reachable(1, 3));
115 |     assert!(!g.reachable(3, 1));
116 |     assert!(g.reachable(3, 3));
117 | }
118 | 


--------------------------------------------------------------------------------
/src/workspace/link.rs:
--------------------------------------------------------------------------------
  1 | use crate::workspace::{Data, Node, Port};
  2 | 
  3 | slotmap::new_key_type! {
  4 |     pub struct Link;
  5 | }
  6 | 
  7 | #[derive(Clone, Copy, Debug)]
  8 | pub struct Slot {
  9 |     pub node: Node,
 10 |     pub port: Port,
 11 | }
 12 | 
 13 | impl Slot {
 14 |     pub const fn new(node: Node, port: Port) -> Self {
 15 |         Self { node, port }
 16 |     }
 17 | }
 18 | 
 19 | pub struct LinkData {
 20 |     pub min: Slot, // output
 21 |     pub max: Slot, // input
 22 | 
 23 |     pub shape: Option<egui::layers::ShapeIdx>,
 24 | }
 25 | 
 26 | impl LinkData {
 27 |     pub fn has(&self, port: Port) -> bool {
 28 |         self.min.port == port || self.max.port == port
 29 |     }
 30 | 
 31 |     pub fn output_for(&self, input: Port) -> Option<Port> {
 32 |         self.has_input(input).then(|| self.min.port)
 33 |     }
 34 |     pub fn has_output(&self, port: Port) -> bool {
 35 |         self.min.port == port
 36 |     }
 37 | 
 38 |     pub fn has_input(&self, port: Port) -> bool {
 39 |         self.max.port == port
 40 |     }
 41 | }
 42 | 
 43 | #[derive(Debug)]
 44 | pub struct LinkBezier(pub [egui::Pos2; 4]);
 45 | 
 46 | impl LinkBezier {
 47 |     #[inline]
 48 |     pub fn new(min: egui::Pos2, max: egui::Pos2) -> Self {
 49 |         let x = (min.distance(max) / 2.0).min(150.0);
 50 |         Self([min, min + egui::vec2(x, 0.0), max - egui::vec2(x, 0.0), max])
 51 |     }
 52 | 
 53 |     pub fn validate(self) -> Option<Self> {
 54 |         let Self([a, b, c, d]) = self;
 55 | 
 56 |         if !a.is_finite() || !b.is_finite() || !c.is_finite() || !d.is_finite() {
 57 |             return None;
 58 |         }
 59 | 
 60 |         if a.distance(d) > 2.0 {
 61 |             Some(Self([a, b, c, d]))
 62 |         } else {
 63 |             None
 64 |         }
 65 |     }
 66 | 
 67 |     #[inline]
 68 |     pub fn eval(&self, t: f32) -> egui::Pos2 {
 69 |         let (a, b, c, d) = (
 70 |             self.0[0].to_vec2(),
 71 |             self.0[1].to_vec2(),
 72 |             self.0[2].to_vec2(),
 73 |             self.0[3].to_vec2(),
 74 |         );
 75 | 
 76 |         let pt = (1.0 - t).powi(3) * a
 77 |             + 3.0 * (1.0 - t).powi(2) * t * b
 78 |             + 3.0 * (1.0 - t) * t.powi(2) * c
 79 |             + t.powi(3) * d;
 80 | 
 81 |         <[f32; 2]>::from(pt).into()
 82 |     }
 83 | 
 84 |     #[inline]
 85 |     pub fn containing_rect_for_bezier_curve(&self, hover_distance: f32) -> egui::Rect {
 86 |         let min = self.0[0].min(self.0[3]);
 87 |         let max = self.0[0].max(self.0[3]);
 88 | 
 89 |         let mut rect = egui::Rect::from_min_max(min, max);
 90 |         rect.extend_with(self.0[1]);
 91 |         rect.extend_with(self.0[2]);
 92 |         rect.expand(hover_distance)
 93 |     }
 94 | 
 95 |     fn to_egui(&self, stroke: impl Into<egui::Stroke>) -> egui::epaint::CubicBezierShape {
 96 |         let fill = egui::Color32::TRANSPARENT;
 97 |         egui::epaint::CubicBezierShape::from_points_stroke(self.0, false, fill, stroke)
 98 |     }
 99 | 
100 |     pub fn draw(&self, stroke: impl Into<egui::Stroke>) -> egui::Shape {
101 |         egui::Shape::CubicBezier(self.to_egui(stroke))
102 |     }
103 | 
104 |     #[inline]
105 |     pub fn distance_to_cubic_bezier(&self, pos: egui::Pos2) -> f32 {
106 |         let segments = 0.1;
107 |         let link_length = self.0[0].distance(self.0[3]);
108 |         let num_segments = 1.max((link_length * segments) as usize);
109 | 
110 |         let mut last = self.0[0];
111 |         let mut closest = self.0[0];
112 |         let mut distance = f32::MAX;
113 |         let t_step = 1.0 / num_segments as f32;
114 |         for i in 1..num_segments {
115 |             let current = self.eval(t_step * i as f32);
116 |             let line = line_closest_point(last, current, pos);
117 |             let dist = pos.distance_sq(line);
118 |             if dist < distance {
119 |                 closest = line;
120 |                 distance = dist;
121 |             }
122 |             last = current;
123 |         }
124 | 
125 |         pos.distance(closest)
126 |     }
127 | }
128 | 
129 | #[inline]
130 | fn line_closest_point(a: egui::Pos2, b: egui::Pos2, p: egui::Pos2) -> egui::Pos2 {
131 |     let ap = p - a;
132 |     let ab_dir = b - a;
133 |     let dot = ap.x * ab_dir.x + ap.y * ab_dir.y;
134 |     let ab_len_sqr = ab_dir.x * ab_dir.x + ab_dir.y * ab_dir.y;
135 |     if dot < 0.0 {
136 |         a
137 |     } else if dot <= ab_len_sqr {
138 |         a + ab_dir * dot / ab_len_sqr
139 |     } else {
140 |         b
141 |     }
142 | }
143 | 
144 | impl Data {
145 |     pub fn color(self) -> egui::Color32 {
146 |         use Data::*;
147 |         match self {
148 |             Boolean => PORT_BOOL,
149 |             Float | FloatOrVector | VectorAny => PORT_VECTOR_1,
150 |             Vector2 => PORT_VECTOR_2,
151 |             Vector3 => PORT_VECTOR_3,
152 |             Vector4 => PORT_VECTOR_4,
153 |             FloatOrVectorOrMatrix | VectorOrMatrix => PORT_MATRIX,
154 |             Matrix2 | Matrix3 | Matrix4 | MatrixAny => PORT_MATRIX,
155 |             Image(_) => PORT_IMAGE,
156 |             VirtualTexture | Gradient | Sampler => PORT_STRUCT,
157 |         }
158 |     }
159 | }
160 | 
161 | use egui::Color32;
162 | 
163 | pub const PORT_BOOL: Color32 = Color32::from_rgb(0x94, 0x81, 0xe6);
164 | pub const PORT_STRUCT: Color32 = Color32::from_rgb(0xc8, 0xc8, 0xc8);
165 | pub const PORT_IMAGE: Color32 = Color32::from_rgb(0xff, 0x8b, 0x8b);
166 | pub const PORT_MATRIX: Color32 = Color32::from_rgb(0x8f, 0xc1, 0xdf);
167 | 
168 | pub const PORT_VECTOR_1: Color32 = Color32::from_rgb(0x84, 0xe4, 0xe7);
169 | pub const PORT_VECTOR_2: Color32 = Color32::from_rgb(0x9a, 0xef, 0x92);
170 | pub const PORT_VECTOR_3: Color32 = Color32::from_rgb(0xf6, 0xff, 0x9a);
171 | pub const PORT_VECTOR_4: Color32 = Color32::from_rgb(0xfb, 0xcb, 0xf4);
172 | 
173 | /*
174 | pub const WORKSPACE_BG: Color32 = Color32::from_rgb(0x20, 0x20, 0x20);
175 | //pub const WORKSPACE_GRID: Color32 = Color32::from_rgb(0x1C, 0x1C, 0x1C);
176 | pub const WORKSPACE_GRID: Color32 = Color32::from_rgb(0x20, 0x20, 0x20);
177 | 
178 | //pub const NODE_BACKGROUND: Color32 = rgba(0x333333, 0.95);
179 | pub const NODE_TEXT: Color32 = Color32::from_rgb(0xCC, 0xCC, 0xCC);
180 | pub const NODE_BASE: Color32 = Color32::from_rgba_premultiplied(0x33, 0x33, 0x33, 0xEE); // 0xE6
181 | pub const NODE_ACTIVE: Color32 = Color32::from_rgba_premultiplied(0x44, 0x44, 0x44, 0xEE);
182 | pub const NODE_BORDER: Color32 = Color32::from_rgba_premultiplied(0x18, 0x18, 0x18, 0xEE);
183 | pub const NODE_BORDER_THICKNESS: f32 = 2.0;
184 | pub const NODE_SEPARATOR_THICKNESS: f32 = 1.0;
185 | 
186 | pub const TITLE_PADDING: egui::Vec2 = egui::vec2(8.0, 4.0);
187 | pub const NODE_PADDING: egui::Vec2 = egui::vec2(16.0, 4.0);
188 | 
189 | pub const SLIDER_RAIL: Color32 = Color32::from_rgb(0x5e, 0x5e, 0x5e);
190 | pub const SLIDER_HANDLE_ACTIVE: Color32 = Color32::from_rgb(0x99, 0x99, 0x99);
191 | pub const SLIDER_HANDLE_HOVER: Color32 = Color32::from_rgb(0xEA, 0xEA, 0xEA);
192 | 
193 | pub const FONT_SIZE: u16 = 14;
194 | 
195 | pub const PORT_BACKGROUND: Color32 = Color32::from_rgba_premultiplied(0x33, 0x33, 0x33, 0xe6);
196 | 
197 | pub const SELECTION: Color32 = Color32::from_rgb(0x44, 0xc0, 0xff);
198 | 
199 | pub const SIDEBAR_BG: Color32 = Color32::from_rgb(39, 39, 39);
200 | 
201 | */
202 | 


--------------------------------------------------------------------------------
/src/workspace/nodes/builtin.rs:
--------------------------------------------------------------------------------
 1 | use super::super::builder::{expr::*, *};
 2 | use crate::workspace::{Data, Fragment, Node, Port, PreviewBuilder, Storage};
 3 | 
 4 | macro_rules! call_node {
 5 |     (
 6 |         $name:ident => $builtin:ident(
 7 |             $( $arg:ident : $arg_ty:ident ),+
 8 |         ) -> $ret_ty:ident
 9 | 
10 |     ) => {
11 | 
12 |         pub struct $name {
13 |             $($arg: Port,)+
14 |             result: Port,
15 |         }
16 | 
17 |         impl $name {
18 |             pub fn spawn(storage: &mut Storage) -> Node {
19 |                 storage.spawn(stringify!($name), 150.0, |ctx, node| {
20 |                     Self {
21 |                         $( $arg: ctx.input(node, stringify!($arg), Fragment, Data::$arg_ty, None), )+
22 |                         result: ctx.output(node, "out", Fragment, Data::$ret_ty, None),
23 |                     }
24 |                 })
25 |             }
26 |         }
27 | 
28 |         impl PreviewBuilder for $name {
29 |             fn output_expr(&self, _: Node, function: &mut FnBuilder, output: Port) -> EmitResult {
30 |                 assert_eq!(self.result, output);
31 |                 let args = [
32 |                     $( call_node!(@ self $arg $arg_ty function)? ),+
33 |                 ];
34 |                 function.call(stringify!($builtin), args)
35 |             }
36 |         }
37 | 
38 |     };
39 | 
40 |     (@ $self:ident $arg:ident Float   $function:ident) => { $function.for_input_resolve($self.$arg, VectorKind::V1) };
41 |     (@ $self:ident $arg:ident Vector2 $function:ident) => { $function.for_input_resolve($self.$arg, VectorKind::V2) };
42 |     (@ $self:ident $arg:ident Vector3 $function:ident) => { $function.for_input_resolve($self.$arg, VectorKind::V3) };
43 |     (@ $self:ident $arg:ident Vector4 $function:ident) => { $function.for_input_resolve($self.$arg, VectorKind::V4) };
44 |     (@ $self:ident $arg:ident $_x:ident $function:ident) => { $function.for_input($self.$arg) };
45 | }
46 | 
47 | call_node!(Blackbody => builtin_blackbody(k: Float) -> Vector3);
48 | call_node!(SimpleNoise => builtin_simple_noise(uv: Vector2, scale: Float) -> Float);
49 | call_node!(GradientNoise => builtin_gradient_noise(uv: Vector2, scale: Float) -> Float);
50 | 


--------------------------------------------------------------------------------
/src/workspace/nodes/channel.rs:
--------------------------------------------------------------------------------
  1 | use super::super::builder::{expr::*, *};
  2 | use crate::workspace::{Data, Fragment, Node, Port, PreviewBuilder, Storage};
  3 | 
  4 | pub struct Combine {
  5 |     r: Port,
  6 |     g: Port,
  7 |     b: Port,
  8 |     a: Port,
  9 |     rgba: Port,
 10 |     rgb: Port,
 11 |     rg: Port,
 12 | }
 13 | 
 14 | impl Combine {
 15 |     pub fn spawn(storage: &mut Storage) -> Node {
 16 |         storage.spawn("Combine", 100.0, |ctx, node| Self {
 17 |             r: ctx.input(node, "r", Fragment, Data::Float, None),
 18 |             g: ctx.input(node, "g", Fragment, Data::Float, None),
 19 |             b: ctx.input(node, "b", Fragment, Data::Float, None),
 20 |             a: ctx.input(node, "a", Fragment, Data::Float, None),
 21 |             rgba: ctx.output(node, "rgba", Fragment, Data::Vector4, None),
 22 |             rgb: ctx.output(node, "rgb", Fragment, Data::Vector3, None),
 23 |             rg: ctx.output(node, "rg", Fragment, Data::Vector2, None),
 24 |         })
 25 |     }
 26 | }
 27 | 
 28 | impl PreviewBuilder for Combine {
 29 |     fn output_expr(&self, _node: Node, function: &mut FnBuilder, output: Port) -> EmitResult {
 30 |         let r = function.for_input_float(self.r)?;
 31 |         let g = function.for_input_float(self.g)?;
 32 |         if output == self.rg {
 33 |             return [r, g].emit(function);
 34 |         }
 35 | 
 36 |         let b = function.for_input_float(self.b)?;
 37 |         if output == self.rgb {
 38 |             return [r, g, b].emit(function);
 39 |         }
 40 | 
 41 |         let a = function.for_input_float(self.a)?;
 42 |         if output == self.rgba {
 43 |             return [r, g, b, a].emit(function);
 44 |         }
 45 | 
 46 |         Err(EmitError::PortNotFound)
 47 |     }
 48 | }
 49 | 
 50 | pub struct Split {
 51 |     port: Port,
 52 |     r: Port,
 53 |     g: Port,
 54 |     b: Port,
 55 |     a: Port,
 56 | }
 57 | 
 58 | impl Split {
 59 |     pub fn spawn(storage: &mut Storage) -> Node {
 60 |         storage.spawn("Split", 100.0, |ctx, node| Self {
 61 |             port: ctx.input(node, "in", Fragment, Data::VectorAny, None),
 62 |             r: ctx.output(node, "r", Fragment, Data::Float, None),
 63 |             g: ctx.output(node, "g", Fragment, Data::Float, None),
 64 |             b: ctx.output(node, "b", Fragment, Data::Float, None),
 65 |             a: ctx.output(node, "a", Fragment, Data::Float, None),
 66 |         })
 67 |     }
 68 | }
 69 | 
 70 | impl PreviewBuilder for Split {
 71 |     fn show_preview(&self) -> bool {
 72 |         false
 73 |     }
 74 | 
 75 |     fn output_expr(&self, _: Node, function: &mut FnBuilder, output: Port) -> EmitResult {
 76 |         let input = function.for_input_vector4(self.port)?;
 77 | 
 78 |         let mut rgba = [self.r, self.g, self.b, self.a].into_iter();
 79 |         let index = rgba.position(|p| p == output);
 80 |         let index = index.ok_or(EmitError::PortNotFound)? as u32;
 81 | 
 82 |         Ok(function.emit(naga::Expression::AccessIndex { base: input, index }))
 83 |     }
 84 | }
 85 | 
 86 | pub struct Swizzle {
 87 |     input: Port,
 88 |     output: Port,
 89 | 
 90 |     x: naga::SwizzleComponent,
 91 |     y: naga::SwizzleComponent,
 92 |     z: naga::SwizzleComponent,
 93 |     w: naga::SwizzleComponent,
 94 | }
 95 | 
 96 | impl Swizzle {
 97 |     pub fn spawn(storage: &mut Storage) -> Node {
 98 |         storage.spawn("Swizzle", 160.0, |ctx, node| Self {
 99 |             input: ctx.input(node, "in", Fragment, Data::VectorAny, None),
100 |             output: ctx.output(node, "out", Fragment, Data::VectorAny, None),
101 |             x: naga::SwizzleComponent::X,
102 |             y: naga::SwizzleComponent::Y,
103 |             z: naga::SwizzleComponent::Z,
104 |             w: naga::SwizzleComponent::W,
105 |         })
106 |     }
107 | }
108 | 
109 | impl PreviewBuilder for Swizzle {
110 |     fn ui(&mut self, ui: &mut egui::Ui) {
111 |         fn sel(ui: &mut egui::Ui, id: &str, value: &mut naga::SwizzleComponent) {
112 |             egui::ComboBox::from_id_source(ui.id().with(id))
113 |                 .selected_text(format!("{:?}", value))
114 |                 .width(15.0)
115 |                 .show_ui(ui, |ui| {
116 |                     ui.selectable_value(value, naga::SwizzleComponent::X, "X");
117 |                     ui.selectable_value(value, naga::SwizzleComponent::Y, "Y");
118 |                     ui.selectable_value(value, naga::SwizzleComponent::Z, "Z");
119 |                     ui.selectable_value(value, naga::SwizzleComponent::W, "W");
120 |                 });
121 |         }
122 | 
123 |         ui.horizontal(|ui| {
124 |             sel(ui, "_x", &mut self.x);
125 |             sel(ui, "_y", &mut self.y);
126 |             sel(ui, "_z", &mut self.z);
127 |             sel(ui, "_w", &mut self.w);
128 |         });
129 |     }
130 | 
131 |     fn output_expr(&self, _: Node, function: &mut FnBuilder, output: Port) -> EmitResult {
132 |         assert_eq!(self.output, output);
133 | 
134 |         let vector = function.for_input(self.input)?;
135 |         let size = match function.extract_type(vector)? {
136 |             naga::TypeInner::Vector { size, .. } => *size,
137 |             _ => unreachable!(),
138 |         };
139 | 
140 |         Ok(function.emit(naga::Expression::Swizzle {
141 |             vector,
142 |             size,
143 |             pattern: [self.x, self.y, self.z, self.w],
144 |         }))
145 |     }
146 | }
147 | 


--------------------------------------------------------------------------------
/src/workspace/nodes/input.rs:
--------------------------------------------------------------------------------
  1 | use super::super::builder::{expr::*, *};
  2 | use crate::workspace::{Data, Fragment, Node, Port, PreviewBuilder, Storage};
  3 | use egui::widgets::color_picker::color_edit_button_hsva;
  4 | use egui::Rgba;
  5 | 
  6 | pub struct InputFloat {
  7 |     x: Port,
  8 |     output: Port,
  9 | }
 10 | 
 11 | impl InputFloat {
 12 |     pub fn spawn(storage: &mut Storage) -> Node {
 13 |         storage.spawn("Float", 80.0, |ctx, node| Self {
 14 |             x: ctx.input(node, "x", Fragment, Data::Float, None),
 15 |             output: ctx.output(node, "out", Fragment, Data::Float, None),
 16 |         })
 17 |     }
 18 | }
 19 | 
 20 | impl PreviewBuilder for InputFloat {
 21 |     fn output_expr(&self, _: Node, function: &mut FnBuilder, output: Port) -> EmitResult {
 22 |         assert_eq!(self.output, output);
 23 |         let x = function.for_input_float(self.x)?;
 24 |         x.emit(function)
 25 |     }
 26 | }
 27 | 
 28 | pub struct InputVector2 {
 29 |     x: Port,
 30 |     y: Port,
 31 |     output: Port,
 32 | }
 33 | 
 34 | impl InputVector2 {
 35 |     pub fn spawn(storage: &mut Storage) -> Node {
 36 |         storage.spawn("Vector2", 80.0, |ctx, node| Self {
 37 |             x: ctx.input(node, "x", Fragment, Data::Float, None),
 38 |             y: ctx.input(node, "y", Fragment, Data::Float, None),
 39 |             output: ctx.output(node, "out", Fragment, Data::Vector2, None),
 40 |         })
 41 |     }
 42 | }
 43 | 
 44 | impl PreviewBuilder for InputVector2 {
 45 |     fn output_expr(&self, _: Node, function: &mut FnBuilder, output: Port) -> EmitResult {
 46 |         assert_eq!(self.output, output);
 47 |         let x = function.for_input_float(self.x)?;
 48 |         let y = function.for_input_float(self.y)?;
 49 |         [x, y].emit(function)
 50 |     }
 51 | }
 52 | 
 53 | pub struct InputVector3 {
 54 |     x: Port,
 55 |     y: Port,
 56 |     z: Port,
 57 |     output: Port,
 58 | }
 59 | 
 60 | impl InputVector3 {
 61 |     pub fn spawn(storage: &mut Storage) -> Node {
 62 |         storage.spawn("Vector3", 80.0, |ctx, node| Self {
 63 |             x: ctx.input(node, "x", Fragment, Data::Float, None),
 64 |             y: ctx.input(node, "y", Fragment, Data::Float, None),
 65 |             z: ctx.input(node, "z", Fragment, Data::Float, None),
 66 |             output: ctx.output(node, "out", Fragment, Data::Vector3, None),
 67 |         })
 68 |     }
 69 | }
 70 | 
 71 | impl PreviewBuilder for InputVector3 {
 72 |     fn output_expr(&self, _: Node, function: &mut FnBuilder, output: Port) -> EmitResult {
 73 |         assert_eq!(self.output, output);
 74 |         let x = function.for_input_float(self.x)?;
 75 |         let y = function.for_input_float(self.y)?;
 76 |         let z = function.for_input_float(self.z)?;
 77 |         [x, y, z].emit(function)
 78 |     }
 79 | }
 80 | 
 81 | pub struct InputVector4 {
 82 |     x: Port,
 83 |     y: Port,
 84 |     z: Port,
 85 |     w: Port,
 86 |     output: Port,
 87 | }
 88 | 
 89 | impl InputVector4 {
 90 |     pub fn spawn(storage: &mut Storage) -> Node {
 91 |         storage.spawn("Vector4", 80.0, |ctx, node| Self {
 92 |             x: ctx.input(node, "x", Fragment, Data::Float, None),
 93 |             y: ctx.input(node, "y", Fragment, Data::Float, None),
 94 |             z: ctx.input(node, "z", Fragment, Data::Float, None),
 95 |             w: ctx.input(node, "w", Fragment, Data::Float, None),
 96 |             output: ctx.output(node, "out", Fragment, Data::Vector4, None),
 97 |         })
 98 |     }
 99 | }
100 | 
101 | impl PreviewBuilder for InputVector4 {
102 |     fn output_expr(&self, _: Node, function: &mut FnBuilder, output: Port) -> EmitResult {
103 |         assert_eq!(self.output, output);
104 |         let x = function.for_input_float(self.x)?;
105 |         let y = function.for_input_float(self.y)?;
106 |         let z = function.for_input_float(self.z)?;
107 |         let w = function.for_input_float(self.w)?;
108 |         [x, y, z, w].emit(function)
109 |     }
110 | }
111 | 
112 | pub struct Color {
113 |     rgba: Rgba,
114 |     port: Port,
115 | }
116 | 
117 | impl Color {
118 |     pub fn spawn(storage: &mut Storage) -> Node {
119 |         storage.spawn("Color", 80.0, |ctx, node| {
120 |             let rgba = Rgba::WHITE;
121 |             let port = ctx.output(node, "color", Fragment, Data::Vector4, None);
122 |             Self { rgba, port }
123 |         })
124 |     }
125 | }
126 | 
127 | impl PreviewBuilder for Color {
128 |     fn ui(&mut self, ui: &mut egui::Ui) {
129 |         let alpha = egui::widgets::color_picker::Alpha::OnlyBlend;
130 |         let mut hsva = self.rgba.into();
131 |         ui.vertical_centered_justified(|ui| {
132 |             color_edit_button_hsva(ui, &mut hsva, alpha);
133 |         });
134 |         self.rgba = hsva.into();
135 |     }
136 | 
137 |     fn show_preview(&self) -> bool {
138 |         false
139 |     }
140 | 
141 |     fn output_expr(&self, _: Node, function: &mut FnBuilder, output: Port) -> EmitResult {
142 |         assert_eq!(self.port, output);
143 | 
144 |         let rgba = [
145 |             Float(self.rgba.r() as f64),
146 |             Float(self.rgba.g() as f64),
147 |             Float(self.rgba.b() as f64),
148 |             Float(self.rgba.a() as f64),
149 |         ];
150 | 
151 |         rgba.emit(function)
152 |     }
153 | }
154 | 
155 | pub struct Slider {
156 |     port: Port,
157 |     value: f64,
158 |     min: f64,
159 |     max: f64,
160 | }
161 | 
162 | impl Slider {
163 |     pub fn spawn(storage: &mut Storage) -> Node {
164 |         storage.spawn("Slider", 140.0, |ctx, node| Self {
165 |             port: ctx.output(node, "out", Fragment, Data::Float, None),
166 |             value: 0.0,
167 |             min: 0.0,
168 |             max: 1.0,
169 |         })
170 |     }
171 | }
172 | 
173 | impl PreviewBuilder for Slider {
174 |     fn ui(&mut self, ui: &mut egui::Ui) {
175 |         let align = egui::Align::Min;
176 |         let layout = egui::Layout::top_down(align).with_cross_justify(true);
177 |         ui.with_layout(layout, |ui| {
178 |             let range = self.min..=self.max;
179 |             ui.add(egui::Slider::new(&mut self.value, range).fixed_decimals(4));
180 | 
181 |             let min = egui::DragValue::new(&mut self.min).clamp_range(f64::NEG_INFINITY..=self.max);
182 |             ui.add(min.speed(0.01).prefix("min "));
183 | 
184 |             let max = egui::DragValue::new(&mut self.max).clamp_range(self.min..=f64::INFINITY);
185 |             ui.add(max.speed(0.01).prefix("max "));
186 |         });
187 |     }
188 | 
189 |     fn show_preview(&self) -> bool {
190 |         false
191 |     }
192 | 
193 |     fn output_expr(&self, _: Node, function: &mut FnBuilder, output: Port) -> EmitResult {
194 |         assert_eq!(self.port, output);
195 |         Float(self.value).emit(function)
196 |     }
197 | }
198 | 
199 | #[allow(clippy::upper_case_acronyms)]
200 | #[derive(Clone, Copy, Debug, PartialEq)]
201 | enum ConstantValue {
202 |     PI,
203 |     TAU,
204 |     PHI,
205 |     E,
206 |     SQRT2,
207 | }
208 | 
209 | pub struct Constant {
210 |     selected: ConstantValue,
211 |     port: Port,
212 | }
213 | 
214 | impl Constant {
215 |     pub fn spawn(storage: &mut Storage) -> Node {
216 |         storage.spawn("Const", 70.0, |ctx, node| Self {
217 |             selected: ConstantValue::PI,
218 |             port: ctx.output(node, "out", Fragment, Data::Float, None),
219 |         })
220 |     }
221 | }
222 | 
223 | impl PreviewBuilder for Constant {
224 |     fn ui(&mut self, ui: &mut egui::Ui) {
225 |         egui::ComboBox::from_id_source("Constant selector")
226 |             .selected_text(format!("{:?}", self.selected))
227 |             .width(62.0)
228 |             .show_ui(ui, |ui| {
229 |                 ui.selectable_value(&mut self.selected, ConstantValue::PI, "PI");
230 |                 ui.selectable_value(&mut self.selected, ConstantValue::TAU, "TAU");
231 |                 ui.selectable_value(&mut self.selected, ConstantValue::PHI, "PHI");
232 |                 ui.selectable_value(&mut self.selected, ConstantValue::E, "E");
233 |                 ui.selectable_value(&mut self.selected, ConstantValue::SQRT2, "SQRT2");
234 |             });
235 |     }
236 | 
237 |     fn show_preview(&self) -> bool {
238 |         false
239 |     }
240 | 
241 |     fn output_expr(&self, _: Node, function: &mut FnBuilder, output: Port) -> EmitResult {
242 |         assert_eq!(self.port, output);
243 | 
244 |         let value = match self.selected {
245 |             ConstantValue::PI => std::f64::consts::PI,
246 |             ConstantValue::TAU => std::f64::consts::TAU,
247 |             ConstantValue::PHI => (1.0 + f64::sqrt(5.0)) / 2.0,
248 |             ConstantValue::E => std::f64::consts::E,
249 |             ConstantValue::SQRT2 => std::f64::consts::SQRT_2,
250 |         };
251 | 
252 |         Float(value).emit(function)
253 |     }
254 | }
255 | 


--------------------------------------------------------------------------------
/src/workspace/nodes/logic.rs:
--------------------------------------------------------------------------------
  1 | use super::super::builder::{expr::*, *};
  2 | use super::util::*;
  3 | use crate::workspace::{Data, Fragment, Node, Port, PreviewBuilder, Storage};
  4 | use naga::{BinaryOperator, Expression};
  5 | 
  6 | pub struct InputBoolean {
  7 |     value: bool,
  8 |     output: Port,
  9 | }
 10 | 
 11 | impl InputBoolean {
 12 |     pub fn spawn(storage: &mut Storage) -> Node {
 13 |         storage.spawn("Boolean", 80.0, |ctx, node| Self {
 14 |             value: false,
 15 |             output: ctx.output(node, "out", Fragment, Data::Boolean, None),
 16 |         })
 17 |     }
 18 | }
 19 | 
 20 | impl PreviewBuilder for InputBoolean {
 21 |     fn ui(&mut self, ui: &mut egui::Ui) {
 22 |         ui.checkbox(&mut self.value, "value");
 23 |     }
 24 | 
 25 |     fn output_expr(&self, _: Node, function: &mut FnBuilder, output: Port) -> EmitResult {
 26 |         assert_eq!(self.output, output);
 27 |         Bool(self.value).emit(function)
 28 |     }
 29 | 
 30 |     fn show_preview(&self) -> bool {
 31 |         false
 32 |     }
 33 | }
 34 | 
 35 | pub struct Comparison {
 36 |     op: BinaryOperator,
 37 |     left: Port,
 38 |     right: Port,
 39 |     result: Port,
 40 | }
 41 | 
 42 | impl Comparison {
 43 |     pub fn spawn(storage: &mut Storage) -> Node {
 44 |         storage.spawn("Comparison", 100.0, |ctx, node| Self {
 45 |             op: BinaryOperator::Equal,
 46 |             result: ctx.output(node, "out", Fragment, Data::Boolean, None),
 47 |             left: ctx.input(node, "a", Fragment, Data::FloatOrVector, None),
 48 |             right: ctx.input(node, "b", Fragment, Data::FloatOrVector, None),
 49 |         })
 50 |     }
 51 | }
 52 | 
 53 | impl PreviewBuilder for Comparison {
 54 |     fn ui(&mut self, ui: &mut egui::Ui) {
 55 |         ui.vertical_centered_justified(|ui| {
 56 |             ui.columns(3, |ui| {
 57 |                 ui[0].selectable_value(&mut self.op, naga::BinaryOperator::LessEqual, "<=");
 58 |                 ui[1].selectable_value(&mut self.op, naga::BinaryOperator::Equal, "==");
 59 |                 ui[2].selectable_value(&mut self.op, naga::BinaryOperator::GreaterEqual, ">=");
 60 |             });
 61 |             ui.columns(3, |ui| {
 62 |                 ui[0].selectable_value(&mut self.op, naga::BinaryOperator::Less, "<");
 63 |                 ui[1].selectable_value(&mut self.op, naga::BinaryOperator::NotEqual, "!=");
 64 |                 ui[2].selectable_value(&mut self.op, naga::BinaryOperator::Greater, ">");
 65 |             });
 66 |         });
 67 |     }
 68 | 
 69 |     fn output_expr(&self, _: Node, function: &mut FnBuilder, output: Port) -> EmitResult {
 70 |         assert_eq!(self.result, output);
 71 |         let (_, left, right) = resolve_pair_min(function, self.left, self.right)?;
 72 |         let op = self.op;
 73 |         Ok(function.emit(Expression::Binary { left, op, right }))
 74 |     }
 75 | 
 76 |     fn show_preview(&self) -> bool {
 77 |         false
 78 |     }
 79 | }
 80 | 
 81 | pub struct Select {
 82 |     condition: Port,
 83 |     accept: Port,
 84 |     reject: Port,
 85 |     result: Port,
 86 | }
 87 | 
 88 | impl Select {
 89 |     pub fn spawn(storage: &mut Storage) -> Node {
 90 |         storage.spawn("Select", 120.0, |ctx, node| Self {
 91 |             result: ctx.output(node, "out", Fragment, Data::FloatOrVector, None),
 92 |             condition: ctx.input(node, "cond", Fragment, Data::Boolean, None),
 93 |             accept: ctx.input(node, "accept", Fragment, Data::FloatOrVector, None),
 94 |             reject: ctx.input(node, "reject", Fragment, Data::FloatOrVector, None),
 95 |         })
 96 |     }
 97 | }
 98 | 
 99 | impl PreviewBuilder for Select {
100 |     fn output_expr(&self, _: Node, function: &mut FnBuilder, output: Port) -> EmitResult {
101 |         assert_eq!(self.result, output);
102 | 
103 |         let condition = function.for_input(self.condition)?;
104 |         let (_, accept, reject) = resolve_pair_min(function, self.accept, self.reject)?;
105 | 
106 |         Ok(function.emit(Expression::Select {
107 |             condition,
108 |             accept,
109 |             reject,
110 |         }))
111 |     }
112 | }
113 | 


--------------------------------------------------------------------------------
/src/workspace/nodes/master.rs:
--------------------------------------------------------------------------------
  1 | use super::super::builder::{expr::*, *};
  2 | use crate::workspace::{Data, Fragment, Node, Port, PreviewBuilder, Storage, Vertex};
  3 | 
  4 | pub struct FragmentInputs {
  5 |     builtin_position: Port,    // vec4<f32>
  6 |     builtin_font_facing: Port, // bool
  7 | 
  8 |     position: Port,  // vec3
  9 |     normal: Port,    // vec3
 10 |     tangent: Port,   // vec3
 11 |     bitangent: Port, // vec3
 12 |     uv0: Port,       // vec2
 13 |     uv1: Port,       // vec2
 14 | }
 15 | 
 16 | impl FragmentInputs {
 17 |     pub fn spawn(storage: &mut Storage) -> Node {
 18 |         storage.spawn("Fragment Inputs", 150.0, |ctx, node| Self {
 19 |             builtin_position: ctx.output(node, "frag position", Fragment, Data::Vector4, None),
 20 |             builtin_font_facing: ctx.output(
 21 |                 node,
 22 |                 "frag font facing",
 23 |                 Fragment,
 24 |                 Data::Boolean,
 25 |                 None,
 26 |             ),
 27 |             position: ctx.output(node, "position", Fragment, Data::Vector3, None),
 28 |             normal: ctx.output(node, "normal", Fragment, Data::Vector3, None),
 29 |             tangent: ctx.output(node, "tangent", Fragment, Data::Vector3, None),
 30 |             bitangent: ctx.output(node, "bitangent", Fragment, Data::Vector3, None),
 31 |             uv0: ctx.output(node, "uv0", Fragment, Data::Vector2, None),
 32 |             uv1: ctx.output(node, "uv1", Fragment, Data::Vector2, None),
 33 |         })
 34 |     }
 35 | }
 36 | 
 37 | impl PreviewBuilder for FragmentInputs {
 38 |     fn show_preview(&self) -> bool {
 39 |         false
 40 |     }
 41 | 
 42 |     fn output_expr(&self, _node: Node, function: &mut FnBuilder, output: Port) -> EmitResult {
 43 |         let input = FunctionArgument(0).emit(function)?;
 44 |         match output {
 45 |             port if port == self.builtin_position => AccessIndex(input, 0).emit(function),
 46 |             port if port == self.builtin_font_facing => AccessIndex(input, 1).emit(function),
 47 | 
 48 |             port if port == self.position => todo!(),
 49 |             port if port == self.normal => todo!(),
 50 |             port if port == self.tangent => todo!(),
 51 |             port if port == self.bitangent => todo!(),
 52 |             port if port == self.uv0 => todo!(),
 53 |             port if port == self.uv1 => todo!(),
 54 | 
 55 |             _ => Err(EmitError::PortNotFound),
 56 |         }
 57 |     }
 58 | }
 59 | 
 60 | pub struct Master {
 61 |     position: Port,
 62 |     color: Port,
 63 | }
 64 | 
 65 | impl Master {
 66 |     pub fn spawn(storage: &mut Storage) -> Node {
 67 |         storage.spawn("Master", 100.0, |ctx, node| Self {
 68 |             position: ctx.input(node, "position", Vertex, Data::Vector3, None),
 69 |             color: ctx.input(node, "color", Fragment, Data::Vector4, None),
 70 |         })
 71 |     }
 72 | }
 73 | 
 74 | impl PreviewBuilder for Master {
 75 |     fn output_expr(&self, _node: Node, _: &mut FnBuilder, _: Port) -> EmitResult {
 76 |         Err(EmitError::PortNotFound)
 77 |     }
 78 | 
 79 |     fn vertex(&self, _: Node, function: &mut FnBuilder) -> EmitResult {
 80 |         function.for_input_vector4(self.position)
 81 |     }
 82 | 
 83 |     fn fragment(&self, _: Node, function: &mut FnBuilder) -> EmitResult {
 84 |         function
 85 |             .for_input(self.color)
 86 |             .or_else(|_| expr_fill_white(function))
 87 |     }
 88 | }
 89 | 
 90 | pub struct Triangle {
 91 |     position: Port,
 92 | }
 93 | 
 94 | impl Triangle {
 95 |     pub fn spawn(storage: &mut Storage) -> Node {
 96 |         storage.spawn("Triangle", 100.0, |ctx, node| Self {
 97 |             position: ctx.output(node, "position", Vertex, Data::Vector3, None),
 98 |         })
 99 |     }
100 | }
101 | 
102 | impl PreviewBuilder for Triangle {
103 |     fn output_expr(&self, _: Node, function: &mut FnBuilder, output: Port) -> EmitResult {
104 |         assert_eq!(self.position, output);
105 |         expr_triangle(function)
106 |     }
107 | 
108 |     fn vertex(&self, node: Node, function: &mut FnBuilder) -> EmitResult {
109 |         self.output_expr(node, function, self.position)
110 |     }
111 | 
112 |     fn fragment(&self, _: Node, function: &mut FnBuilder) -> EmitResult {
113 |         expr_fill_white(function)
114 |     }
115 | }
116 | 
117 | pub struct Fullscreen {
118 |     position: Port,
119 | }
120 | 
121 | impl Fullscreen {
122 |     pub fn spawn(storage: &mut Storage) -> Node {
123 |         storage.spawn("Fullscreen", 100.0, |ctx, node| Self {
124 |             position: ctx.output(node, "position", Vertex, Data::Vector3, None),
125 |         })
126 |     }
127 | }
128 | 
129 | impl PreviewBuilder for Fullscreen {
130 |     fn output_expr(&self, _: Node, function: &mut FnBuilder, output: Port) -> EmitResult {
131 |         assert_eq!(self.position, output);
132 |         expr_fullscreen(function)
133 |     }
134 | 
135 |     fn vertex(&self, node: Node, function: &mut FnBuilder) -> EmitResult {
136 |         self.output_expr(node, function, self.position)
137 |     }
138 | 
139 |     fn fragment(&self, _: Node, function: &mut FnBuilder) -> EmitResult {
140 |         expr_fill_white(function)
141 |     }
142 | }
143 | 
144 | pub fn expr_fill_white(function: &mut FnBuilder) -> EmitResult {
145 |     [Float(1.0); 4].emit(function)
146 | }
147 | 
148 | pub fn expr_fullscreen(function: &mut FnBuilder) -> EmitResult {
149 |     let vertex_index = AccessIndex(FunctionArgument(0).emit(function)?, 0);
150 | 
151 |     let u = (vertex_index << Uint(1)) & Uint(2);
152 |     let v = vertex_index & Uint(2);
153 |     let u = (u.sint() * Sint(2) + Sint(-1)).float();
154 |     let v = (v.sint() * Sint(-2) + Sint(1)).float();
155 |     let u = Let::new("u", u).emit(function)?;
156 |     let v = Let::new("v", v).emit(function)?;
157 | 
158 |     let zero = Float(0.0).emit(function)?;
159 |     let one = Float(1.0).emit(function)?;
160 | 
161 |     [u, v, zero, one].emit(function)
162 | }
163 | 
164 | pub fn expr_triangle(function: &mut FnBuilder) -> EmitResult {
165 |     let vertex_index = AccessIndex(FunctionArgument(0).emit(function)?, 0);
166 | 
167 |     let u = vertex_index - Uint(1);
168 |     let v = (vertex_index & Uint(1)) * Uint(2) - Uint(1);
169 |     let u = Let::new("x", u.sint().float()).emit(function)?;
170 |     let v = Let::new("y", v.sint().float()).emit(function)?;
171 | 
172 |     [u, v, Float(0.0).emit(function)?, Float(1.0).emit(function)?].emit(function)
173 | }
174 | 


--------------------------------------------------------------------------------
/src/workspace/nodes/util.rs:
--------------------------------------------------------------------------------
 1 | use super::super::builder::{expr::*, *};
 2 | use crate::workspace::Port;
 3 | use naga::Expression;
 4 | 
 5 | pub fn resolve_pair_min(
 6 |     function: &mut FnBuilder,
 7 |     a: Port,
 8 |     b: Port,
 9 | ) -> EmitResult<(
10 |     VectorKind,
11 |     naga::Handle<Expression>,
12 |     naga::Handle<Expression>,
13 | )> {
14 |     resolve_pair(function, a, b, VectorKind::min)
15 | }
16 | 
17 | pub fn resolve_pair(
18 |     function: &mut FnBuilder,
19 |     a: Port,
20 |     b: Port,
21 |     merge: impl FnOnce(VectorKind, VectorKind) -> VectorKind,
22 | ) -> EmitResult<(
23 |     VectorKind,
24 |     naga::Handle<Expression>,
25 |     naga::Handle<Expression>,
26 | )> {
27 |     let a = function.for_input(a)?;
28 |     let b = function.for_input(b)?;
29 | 
30 |     let a_src = VectorKind::parse(function.extract_type(a)?).unwrap();
31 |     let b_src = VectorKind::parse(function.extract_type(b)?).unwrap();
32 | 
33 |     let dst = merge(a_src, b_src);
34 | 
35 |     let a = function.resolve_vector(a, a_src, dst).unwrap();
36 |     let b = function.resolve_vector(b, b_src, dst).unwrap();
37 | 
38 |     Ok((dst, a, b))
39 | }
40 | 


--------------------------------------------------------------------------------
/src/workspace/nodes/uv.rs:
--------------------------------------------------------------------------------
  1 | use super::super::builder::{expr::*, *};
  2 | use crate::workspace::{Data, Fragment, Node, Port, PreviewBuilder, Storage};
  3 | use naga::{Expression, Handle, MathFunction};
  4 | 
  5 | pub struct Flipbook {
  6 |     output: Port,
  7 | 
  8 |     uv: Port,
  9 |     width: Port,
 10 |     height: Port,
 11 |     tile: Port,
 12 | 
 13 |     flip_x: bool,
 14 |     flip_y: bool,
 15 | }
 16 | 
 17 | impl Flipbook {
 18 |     pub fn spawn(storage: &mut Storage) -> Node {
 19 |         storage.spawn("Flipbook", 100.0, |ctx, node| Self {
 20 |             output: ctx.output(node, "out", Fragment, Data::Vector2, None),
 21 | 
 22 |             uv: ctx.output(node, "uv", Fragment, Data::Vector2, None),
 23 |             width: ctx.output(node, "width", Fragment, Data::Float, None),
 24 |             height: ctx.output(node, "height", Fragment, Data::Float, None),
 25 |             tile: ctx.output(node, "tile", Fragment, Data::Float, None),
 26 | 
 27 |             flip_x: false,
 28 |             flip_y: false,
 29 |         })
 30 |     }
 31 | }
 32 | 
 33 | impl PreviewBuilder for Flipbook {
 34 |     fn ui(&mut self, ui: &mut egui::Ui) {
 35 |         ui.checkbox(&mut self.flip_x, "invert x");
 36 |         ui.checkbox(&mut self.flip_y, "invert y");
 37 |     }
 38 | 
 39 |     fn output_expr(&self, _: Node, function: &mut FnBuilder, output: Port) -> EmitResult {
 40 |         assert_eq!(self.output, output);
 41 | 
 42 |         let flip_x = Float(if self.flip_x { 1.0 } else { 0.0 });
 43 |         let flip_y = Float(if self.flip_y { 1.0 } else { 0.0 });
 44 | 
 45 |         let uv = Wrap(function.for_input_vector2(self.uv)?);
 46 |         let tile = Wrap(function.for_input_float(self.tile)?);
 47 |         let width = Wrap(function.for_input_float(self.width)?);
 48 |         let height = Wrap(function.for_input_float(self.height)?);
 49 | 
 50 |         let tile = call_math_2(MathFunction::Modf, tile.0, (width * height).emit(function)?);
 51 | 
 52 |         let one = Float(1.0);
 53 | 
 54 |         let tile_count = Wrap([one; 2].emit(function)?) / Wrap([width, height].emit(function)?);
 55 | 
 56 |         let tile_count_x = AccessIndex(tile_count.emit(function)?, 0);
 57 | 
 58 |         let floor_tile_count = (tile.clone() * tile_count_x).emit(function)?;
 59 |         let floor_tile_count = call_math_1(MathFunction::Floor, floor_tile_count);
 60 | 
 61 |         let tile_y = flip_y * height - (floor_tile_count.clone() + flip_y);
 62 |         let tile_y = call_math_1(MathFunction::Abs, tile_y.emit(function)?);
 63 | 
 64 |         let tile_x = flip_x * width - ((tile - width * floor_tile_count) + flip_x);
 65 |         let tile_x = call_math_1(MathFunction::Abs, tile_x.emit(function)?);
 66 | 
 67 |         let out = (uv + Wrap([tile_x, tile_y].emit(function)?)) * tile_count;
 68 | 
 69 |         out.emit(function)
 70 |     }
 71 | }
 72 | 
 73 | fn call_math_1(fun: MathFunction, arg0: Handle<Expression>) -> Expr {
 74 |     call_math(fun, arg0, None, None, None)
 75 | }
 76 | 
 77 | fn call_math_2(fun: MathFunction, arg0: Handle<Expression>, arg1: Handle<Expression>) -> Expr {
 78 |     call_math(fun, arg0, arg1, None, None)
 79 | }
 80 | 
 81 | fn call_math_3(
 82 |     fun: MathFunction,
 83 |     arg0: Handle<Expression>,
 84 |     arg1: Handle<Expression>,
 85 |     arg2: Handle<Expression>,
 86 | ) -> Expr {
 87 |     call_math(fun, arg0, arg1, arg2, None)
 88 | }
 89 | 
 90 | fn call_math(
 91 |     fun: MathFunction,
 92 |     arg0: Handle<Expression>,
 93 |     arg1: impl Into<Option<Handle<Expression>>>,
 94 |     arg2: impl Into<Option<Handle<Expression>>>,
 95 |     arg3: impl Into<Option<Handle<Expression>>>,
 96 | ) -> Expr {
 97 |     Expr(Expression::Math {
 98 |         fun,
 99 |         arg: arg0,
100 |         arg1: arg1.into(),
101 |         arg2: arg2.into(),
102 |         arg3: arg3.into(),
103 |     })
104 | }
105 | 


--------------------------------------------------------------------------------