1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190
use crate::{ composite_renderer::Renderable, math::{mul_mat, Scalar, Vec2}, }; use core::ecs::{Component, DenseVecStorage, HashMapStorage, VecStorage}; use std::borrow::Cow; #[derive(Debug, Clone)] pub struct CompositeRenderable(pub Renderable<'static>); impl Component for CompositeRenderable { type Storage = DenseVecStorage<Self>; } impl From<Renderable<'static>> for CompositeRenderable { fn from(value: Renderable<'static>) -> Self { Self(value) } } #[derive(Debug, Clone)] pub struct CompositeRenderableStroke(pub Scalar); impl Component for CompositeRenderableStroke { type Storage = VecStorage<Self>; } #[derive(Debug, Clone, PartialEq)] pub struct CompositeTransform { translation: Vec2, rotation: Scalar, scale: Vec2, cached: [Scalar; 6], } impl Component for CompositeTransform { type Storage = DenseVecStorage<Self>; } impl Default for CompositeTransform { fn default() -> Self { Self { translation: Vec2::zero(), rotation: 0.0, scale: Vec2::one(), cached: [1.0, 0.0, 0.0, 1.0, 0.0, 0.0], } } } impl CompositeTransform { pub fn new(translation: Vec2, rotation: Scalar, scale: Vec2) -> Self { let mut result = Self { translation, rotation, scale, cached: [1.0, 0.0, 0.0, 1.0, 0.0, 0.0], }; result.rebuild(); result } pub fn translation(v: Vec2) -> Self { Self::default().with_translation(v) } pub fn rotation(v: Scalar) -> Self { Self::default().with_rotation(v) } pub fn scale(v: Vec2) -> Self { Self::default().with_scale(v) } pub fn with_translation(mut self, v: Vec2) -> Self { self.translation = v; self.rebuild(); self } pub fn with_rotation(mut self, v: Scalar) -> Self { self.rotation = v; self.rebuild(); self } pub fn with_scale(mut self, v: Vec2) -> Self { self.scale = v; self.rebuild(); self } pub fn get_translation(&self) -> Vec2 { self.translation } pub fn get_rotation(&self) -> Scalar { self.rotation } pub fn get_scale(&self) -> Vec2 { self.scale } pub fn set_translation(&mut self, v: Vec2) { self.translation = v; self.rebuild(); } pub fn set_rotation(&mut self, v: Scalar) { self.rotation = v; self.rebuild(); } pub fn set_scale(&mut self, v: Vec2) { self.scale = v; self.rebuild(); } pub fn matrix(&self) -> [Scalar; 6] { self.cached.clone() } fn rebuild(&mut self) { let (sin, cos) = self.rotation.sin_cos(); self.cached = mul_mat( mul_mat( [1.0, 0.0, 0.0, 1.0, self.translation.x, self.translation.y], [cos, sin, -sin, cos, 0.0, 0.0], ), [self.scale.x, 0.0, 0.0, self.scale.y, 0.0, 0.0], ); } } #[derive(Debug, Default, Clone, PartialEq, PartialOrd)] pub struct CompositeRenderDepth(pub Scalar); impl Component for CompositeRenderDepth { type Storage = VecStorage<Self>; } #[derive(Debug, Clone)] pub enum CompositeScalingMode { None, Center, Aspect, CenterAspect, } impl Default for CompositeScalingMode { fn default() -> Self { CompositeScalingMode::None } } #[derive(Debug, Clone)] pub struct CompositeCamera { pub scaling: CompositeScalingMode, pub tags: Vec<Cow<'static, str>>, } impl Component for CompositeCamera { type Storage = HashMapStorage<Self>; } impl Default for CompositeCamera { fn default() -> Self { Self { scaling: CompositeScalingMode::None, tags: vec![], } } } impl CompositeCamera { pub fn new(scaling: CompositeScalingMode) -> Self { Self { scaling, tags: vec![], } } } #[derive(Debug, Clone)] pub struct CompositeTag(pub Cow<'static, str>); impl Component for CompositeTag { type Storage = VecStorage<Self>; }