.gitignore

@@ -1,6 +1,3 @@
 /target
 *.log
 *.bkp
-*.perf
-*.data
-*.html

Cargo.lock

@@ -147,7 +147,6 @@ dependencies = [
  "cgmath",
  "chrono",
  "fern",
- "fontdue",
  "image",
  "log",
  "pollster",
@@ -505,16 +504,6 @@ version = "1.0.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1"
 
-[[package]]
-name = "fontdue"
-version = "0.7.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6a62391ecb864cf12ed06b2af4eda2e609b97657950d6a8f06841b17726ab253"
-dependencies = [
- "hashbrown 0.11.2",
- "ttf-parser",
-]
-
 [[package]]
 name = "foreign-types"
 version = "0.3.2"
@@ -589,7 +578,7 @@ checksum = "0b0c02e1ba0bdb14e965058ca34e09c020f8e507a760df1121728e0aef68d57a"
 dependencies = [
  "bitflags",
  "gpu-descriptor-types",
- "hashbrown 0.12.3",
+ "hashbrown",
 ]
 
 [[package]]
@@ -601,15 +590,6 @@ dependencies = [
  "bitflags",
 ]
 
-[[package]]
-name = "hashbrown"
-version = "0.11.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ab5ef0d4909ef3724cc8cce6ccc8572c5c817592e9285f5464f8e86f8bd3726e"
-dependencies = [
- "ahash",
-]
-
 [[package]]
 name = "hashbrown"
 version = "0.12.3"
@@ -686,7 +666,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "10a35a97730320ffe8e2d410b5d3b69279b98d2c14bdb8b70ea89ecf7888d41e"
 dependencies = [
  "autocfg",
- "hashbrown 0.12.3",
+ "hashbrown",
 ]
 
 [[package]]
@@ -1339,12 +1319,6 @@ dependencies = [
  "serde",
 ]
 
-[[package]]
-name = "ttf-parser"
-version = "0.15.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7b3e06c9b9d80ed6b745c7159c40b311ad2916abb34a49e9be2653b90db0d8dd"
-
 [[package]]
 name = "unicode-ident"
 version = "1.0.5"

Cargo.toml

@@ -13,7 +13,6 @@ fern = { version = "^0.6.1", features = ["colored"] }
 bitflags = "^1.3.2"
 cgmath = { version = "^0.18.0", features = ["bytemuck"] }
 pollster = "^0.2.5"
-fontdue = "0.7.2"
 
 # surface creation
 winit = "^0.26.1"
@@ -34,6 +33,3 @@ features = ["png", "jpeg"]
 [patch.crates-io]
 cgmath = { path = "cgmath" }
 
-[profile.release]
-debug = 1
-

src/canvas.rs

@@ -80,14 +80,8 @@ impl Canvas {
         )
     }
 
-    pub fn create_text_sprite(&mut self, text: &'static str, size: Size, text_size: f32)
+    pub fn create_text_sprite(&mut self, _size: Size, _scale: f32) -> TextSprite {
-        -> TextSprite {
+        unimplemented!();
-        TextSprite::new(
-            text,
-            size,
-            text_size,
-            &self.renderer,
-        )
     }
 
     pub fn create_shape_sprite(&mut self) -> ShapeSprite {

src/lib.rs

@@ -106,7 +106,7 @@ mod tests {
                     message
                 ))
             })
-            .level(log::LevelFilter::Debug)
+            .level(log::LevelFilter::Trace)
             .chain(std::io::stdout())
             .chain(fern::log_file("output.log")?)
             .apply()?;

src/main.rs

@@ -5,7 +5,7 @@ use canvas::{
     Application,
     Canvas,
     texture::TextureHandle,
-    sprite::{TextureSprite, TextSprite},
+    sprite::TextureSprite,
     utils::Position,
 };
 
@@ -40,13 +40,10 @@ struct ExampleState {
     pub texture: TextureHandle,
     pub tex_sprite: TextureSprite,
     pub sub_sprite: TextureSprite,
-    pub sub_sprite2: TextureSprite,
-    pub txt_sprite: TextSprite,
     pub last_instant: Instant,
     pub last_offset: u32,
     pub last_pos: Position,
     pub last_rot: f32,
-    pub frame_counter: u8,
 }
 
 struct ExampleApp {}
@@ -54,34 +51,16 @@ struct ExampleApp {}
 impl Application<ExampleState> for ExampleApp {
 
     fn init(canvas: &mut Canvas) -> Result<ExampleState, &'static str> {
-        use canvas::{
+        use canvas::utils::Size;
-            utils::Size,
-            sprite::Sprite,
-        };
 
         //// 20 x 20 sprite of a picture
         let texture = canvas.create_texture_from_file("assets/camel.jpg", None, None, None)
             .unwrap();
         let mut tex_sprite = canvas.create_texture_sprite(Size {w: 1280, h: 720});
         tex_sprite.set_texture(texture.clone(), Some(Position {x: 0, y: 0}), 1.0);
-        tex_sprite.set_center(Position {x:-1280/2, y:-720/2});
-        tex_sprite.set_position(Position {x: 0, y: 0});
 
-        let mut sub_sprite = canvas.create_texture_sprite(Size {w: 100, h: 100});
+        let mut sub_sprite = canvas.create_texture_sprite(Size {w: 200, h: 200});
-        sub_sprite.set_texture(texture.clone(), Some(Position {x: 0, y: 0}), 1.0);
+        sub_sprite.set_texture(texture.clone(), Some(Position {x: 350, y: 0}), 1.0);
-        sub_sprite.set_position(Position {x: 0, y: 0});
-        sub_sprite.set_scale(2.0);
-
-        let mut sub_sprite2 = canvas.create_texture_sprite(Size {w: 200, h: 200});
-        sub_sprite2.set_texture(texture.clone(), Some(Position {x: 100, y: 0}), 1.0);
-        sub_sprite2.set_center(Position {x:100, y:100});
-        sub_sprite2.set_rotation(0.0);
-        sub_sprite2.set_position(Position {x: 0, y: 0});
-
-        let mut txt_sprite = canvas.create_text_sprite("00", Size {w: 100, h: 100}, 22.0);
-        txt_sprite.set_center(Position {x:0, y:0});
-        txt_sprite.set_position(Position {x:100, y:100});
-        txt_sprite.set_scale(1.0);
 
         canvas.clear();
         canvas.update();
@@ -92,54 +71,32 @@ impl Application<ExampleState> for ExampleApp {
             texture,
             tex_sprite,
             sub_sprite,
-            sub_sprite2,
-            txt_sprite,
             last_instant,
             last_offset: 0,
-            last_pos: Position {x: 0, y: 0},
+            last_pos: Position::origin(),
             last_rot: 0.0,
-            frame_counter: 0,
         })
     }
 
     fn tick(state: &mut ExampleState, canvas: &mut Canvas) -> Result<(), &'static str> {
-        use canvas::{
+        use canvas::sprite::Sprite;
-            sprite::Sprite,
-            utils::Color,
-        };
 
         let now = Instant::now();
         let elapsed = now.duration_since(state.last_instant).as_millis();
         state.last_instant = now;
         debug!("frame time: {}ms", elapsed);
-        state.frame_counter += 1;
+
-        if state.frame_counter >= 60 {
-            state.frame_counter = 0;
-//            state.txt_sprite.set_text(&format!("{}", elapsed));
-//            state.txt_sprite.set_text_size(elapsed as f32);
-        }
-        match state.frame_counter {
-            0 => state.txt_sprite.set_color(Color::RED),
-            20 => state.txt_sprite.set_color(Color::BLUE),
-            40 => state.txt_sprite.set_color(Color::GREEN),
-            _ => (),
-        }
         //state.sub_sprite.for_each(|pix| unsafe {pix.flat = pix.flat.wrapping_add(1);});
 
-       // state.last_offset += 1;
+        state.last_offset += 1;
-        //state.last_pos.x += 1;
+        state.last_pos.y += 1;
-        //state.last_pos.y += 1;
         state.last_rot += 1.0;
-        debug!("{:#?}", state.last_pos);
         state.tex_sprite.set_texture(state.texture.clone(), None, state.last_rot/100.0);
-       // state.sub_sprite.set_texture(state.texture.clone(),
+        state.sub_sprite.set_texture(state.texture.clone(),
-       //                             Some(Position {x: state.last_offset, y: 0}), 1.0);
+                                     Some(Position {x: state.last_offset, y: 0}), 1.0);
         state.sub_sprite.set_position(state.last_pos);
-        state.sub_sprite2.set_position(state.last_pos);
         state.sub_sprite.set_rotation(state.last_rot);
-        state.sub_sprite2.set_rotation(state.last_rot + 45.0);
 
-//		state.txt_sprite.set_rotation(state.last_rot);
         //state.sub_sprite.set_scale(state.last_rot/1000.0);
 
         // inputs
@@ -151,7 +108,6 @@ impl Application<ExampleState> for ExampleApp {
         //    unimplemented!();
         //}
         //
-        //
         //match canvas.get_key_presses() {
         //    Key::A => unimplemented!(),
         //    _ => (),
@@ -200,8 +156,6 @@ impl Application<ExampleState> for ExampleApp {
 
         canvas.draw(&mut state.tex_sprite);
         canvas.draw(&mut state.sub_sprite);
-        canvas.draw(&mut state.sub_sprite2);
-        canvas.draw(&mut state.txt_sprite);
         canvas.update();
 
         Ok(())

src/renderer.rs

@@ -96,10 +96,6 @@ impl WgpuRenderer {
         })
     }
 
-    pub fn get_surface_size(&self) -> Size {
-        self.surface_size
-    }
-
     pub fn clear(&mut self, color: Pixel) {
 
         let view = self.create_texture_view();

src/renderer/matrix.rs

@@ -16,10 +16,8 @@ pub const MATRIX_SIZE: usize = 48;//std::mem::size_of::<Matrix3<f32>>();
 //--ModelMatrix struct------------------------------------------------------------------------------
 pub struct ModelMatrix {
     position: Position,
-    center: Position,
     rotation: Deg<f32>,
     scale: f32,
-    aspect_matrix: Matrix3<f32>,
 
     uniform: Uniform<MATRIX_SIZE>,
     is_synced: bool,
@@ -28,27 +26,19 @@ pub struct ModelMatrix {
 impl ModelMatrix {
 
     pub fn new(renderer: &WgpuRenderer,
-               position: Position,
+               pos: Position,
-               rotation: f32,
+               rot: f32,
                scale: f32)
         -> Self
     {
-        let surface_size: Vector2<f32> = renderer.get_surface_size().into();
-        //A factor 2 is used since the gpu coords go from -1.0 to 1.0 while the engine coords only
-        //go from 0 to 1
-        let aspect_matrix = Matrix3::from_nonuniform_scale(2.0 / surface_size.x,
-														   2.0 / surface_size.y)
-			* Matrix3::from_translation(-surface_size / 2.0);
 
-        Self {
+       Self {
-            position,
+           position: pos,
-            center: Position::origin(),
+           rotation: Deg (rot),
-            rotation: Deg(rotation),
+           scale,
-            scale,
-            aspect_matrix,
 
-            uniform: Uniform::create(renderer, &renderer.matrix_layout),
+           uniform: Uniform::create(renderer, &renderer.matrix_layout),
-            is_synced: false,
+           is_synced: false,
        }
     }
 
@@ -56,8 +46,13 @@ impl ModelMatrix {
         Self::new(renderer, Position::origin(), 0.0, 1.0)
     }
 
-    pub fn set_position(&mut self, position: Position) {
+    pub fn set_position(&mut self, pos: Position) {
-        self.position = position;
+        self.position = pos;
+        self.is_synced = false;
+    }
+
+    pub fn set_rotation(&mut self, rot: f32) {
+        self.rotation = Deg (rot);
         self.is_synced = false;
     }
 
@@ -66,37 +61,22 @@ impl ModelMatrix {
         self.is_synced = false;
     }
 
-    pub fn set_rotation(&mut self, rotation: f32) {
-        self.rotation = Deg(rotation);
-        self.is_synced = false;
-    }
-
-    pub fn set_center(&mut self, center: Position) {
-        self.center = center;
-        self.is_synced = false;
-    }
-
     pub fn get_uniform(&mut self) -> &mut Uniform<MATRIX_SIZE> {
         use cgmath::{Basis3, Rotation3};
 
         if self.is_synced == false {
 
-            let position = Matrix3::from_translation(self.position.into());
+            let pos_vec = Vector2 {
-            let scale = Matrix3::from_scale(self.scale);
+                x: self.position.x as f32,
-            let center = Matrix3::from_translation((self.center * -1.0).into());
+                y: self.position.y as f32,
-            let rotation = Matrix3::from(Basis3::from_angle_z(self.rotation));
+            };
-
+            let rotation_mat = Matrix3::from(Basis3::from_angle_z(self.rotation));
-			//to be read in reverse: scale is applied first, then the center offset is applied in
+            let scale_mat = Matrix3::from_scale(self.scale);
-			//reverse, so that it lines up with the world's origin. The rotation is then applied
+            let translation_mat = Matrix3::from_translation(pos_vec);
-			//around the world's origin (and ence, the center). FInally, the translation is applied
+            let aspect_mat = Matrix3::from_nonuniform_scale(1.0/1280.0, 1.0/720.0);
-			//before the aspect matrix can move use from window-space (w x h) to normalized space
-			//(-1.0 to 1.0)
-            let matrix = self.aspect_matrix * position * rotation * center * scale;
 
+            let matrix = aspect_mat * translation_mat * rotation_mat * scale_mat;
             let mat_bytes: [u8; 36] = bytemuck::bytes_of(&matrix).try_into().unwrap();
-
-            //wgsl uses 16 bytes-aligned matrixes, but ours is 12 bytes-aligned. Fix that by adding
-            //4 paddings bytes after each 12 bytes
             let mut bytes = [0; 48];
             for i in 0..12 {
                 bytes[i] = mat_bytes[i];

src/renderer/utils.rs

@@ -123,8 +123,7 @@ where
             }
         );
 
-        let index_buffer = device.create_buffer(
+        let index_buffer = device.create_buffer( &wgpu_types::BufferDescriptor {
-			&wgpu_types::BufferDescriptor {
                 label: Some("Index Buffer"),
                 size: (I_NB * size_of::<u16>()) as u64,
                 usage: Usages::INDEX | Usages::COPY_DST,

src/sprite.rs

@@ -27,22 +27,19 @@ use crate::{
 /// well as the unique function necessary for it to be rendered
 pub trait Sprite {
 
-    /// Sets the position of the [`Sprite`] on the screen
+    /// Set the position of the [Sprite] on the screen
-    fn set_position(&mut self, position: Position);
+    fn set_position(&mut self, pos: Position);
 
-    /// Sets the center of the [`Sprite`] for rotations as well as translations
+    /// Set the rotation of the [Sprite] on the screen
-    fn set_center(&mut self, center: Position);
+    fn set_rotation(&mut self, rot: f32);
 
-    /// Sets the rotation of the [`Sprite`] on the screen
+    /// Set the alpha of the [Sprite] on the screen
-    fn set_rotation(&mut self, rotation: f32);
-
-    /// Sets the alpha of the [`Sprite`] on the screen
     fn set_alpha(&mut self, alpha: u8);
 
-    /// Sets the scale of the [`Sprite`] on the screen
+    /// Set the scale of the [Sprite] on the screen
     fn set_scale(&mut self, scale: f32);
 
-    /// Renders the [`Sprite`] using the given rendering context
+    /// Renders the [Sprite] using the given rendering context
     fn render(&mut self, renderer: &mut WgpuRenderer);
 }
 

src/sprite/shaders/texture.wgsl

@@ -14,12 +14,12 @@ struct VertexOutput {
 var<uniform> model_matrix: mat3x3<f32>;
 
 @vertex
-fn vs_main(vertex: VertexInput) -> VertexOutput {
+fn vs_main(model: VertexInput) -> VertexOutput {
 
     var out: VertexOutput;
-    out.tex_coords = vertex.tex_coords;
+    out.tex_coords = model.tex_coords;
-	out.clip_position
+	out.clip_position 
-		= vec4<f32>(model_matrix * vec3<f32>(vertex.position, 1.0), 1.0);
+		= vec4<f32>(model_matrix * vec3<f32>(model.position, 1.0), 1.0);
     return out;
 }
 

src/sprite/shape_sprite.rs

@@ -35,15 +35,11 @@ impl ShapeSprite {
 
 impl Sprite for ShapeSprite {
 
-    fn set_position(&mut self, _position: Position) {
+    fn set_position(&mut self, _pos: Position) {
         todo!();
     }
 
-    fn set_center(&mut self, _center: Position) {
+    fn set_rotation(&mut self, _rot: f32) {
-        todo!();
-    }
-
-    fn set_rotation(&mut self, _rotation: f32) {
         todo!();
     }
 

src/sprite/text_sprite.rs

@@ -6,174 +6,52 @@ use log::{debug, error, info, trace, warn};
 use crate::{
     renderer::WgpuRenderer,
     sprite::Sprite,
-    utils::{Pixel, Color, Position, Size},
+    utils::{Pixel, Position, Size},
 };
-use super::TextureSprite;
 
 //--External imports--------------------------------------------------------------------------------
 
+use cgmath::Matrix4;
+
 //--TextSprite struct-------------------------------------------------------------------------------
+#[allow(dead_code)]
 pub struct TextSprite {
-    texture_sprite: TextureSprite,
+    matrix: Matrix4<f32>,
-
+    size: Size,
-    text: String,
+    text: &'static str, //TODO: temporary
-    text_size: f32,
-    text_color: Pixel,
-
-    font: fontdue::Font,
-    layout: fontdue::layout::Layout,
-    text_generation_needed: bool,
 }
 
 impl TextSprite {
 
-    pub fn new(text: &'static str, size: Size, text_size: f32, renderer: &WgpuRenderer) -> Self {
+    pub fn set_text(&mut self, _text: &'static str) {
-        use crate::{
+        todo!();
-            renderer::Texture,
-            texture::TextureHandle,
-        };
-        use fontdue::layout::{CoordinateSystem, Layout, TextStyle};
-
-        let font = Self::configure_font(text_size);
-        let mut layout = Layout::new(CoordinateSystem::PositiveYDown);
-
-        //configure text layout to fit sprite size, keep default settings
-        layout.append(&[&font], &TextStyle::new(text, text_size, 0));
-
-        //draw text to the texture
-        let mut raw_texture : Vec::<Pixel>
-            = vec![Color::NONE; (size.h * size.w).try_into().unwrap()];
-
-        //draw each glyph at the corresponding position on the texture
-        for glyph in layout.glyphs() {
-            let (_metrics, bitmap) = font.rasterize_config(glyph.key);
-
-            let glyph_x = glyph.x as usize;
-            let glyph_y = glyph.y as usize;
-            let size_w = size.w as usize;
-            let size_h = size.h as usize;
-
-            //only try to draw a glyph if its origin fits in the texture
-            if glyph_x < size_w && glyph_y < size_h {
-                let origin = glyph_x + size_w * glyph_y;
-
-                //glyphs that do not fit on the texture are cropped at the edge of the latter
-                for x in 0..std::cmp::min(glyph.width, size_w - glyph_x) {
-                    for y in 0..std::cmp::min(glyph.height, size_h - glyph_y) {
-
-                        raw_texture[origin + x + y * size_w]
-                            = Color::BLACK.with_alpha(bitmap[x + y * glyph.width]);
-        } } } }
-
-        //create the texture
-        let texture = Texture::create(renderer, bytemuck::cast_slice(&raw_texture), size);
-        let texture_handle = TextureHandle::from_texture(texture);
-
-        let texture_sprite = TextureSprite::new(texture_handle, size, &renderer);
-
-        Self {
-            texture_sprite,
-            text: text.to_string(),
-            text_size,
-            text_color: Color::BLACK,
-            font,
-            layout,
-            text_generation_needed: false,
-        }
     }
 
-    pub fn set_text(&mut self, text: &str) {
+    pub fn set_color(&mut self, _color: Pixel) {
-        self.text = text.to_string();
+        todo!();
-        self.text_generation_needed = true;
-    }
-
-    pub fn set_text_size(&mut self, text_size: f32) {
-        self.text_size = text_size;
-        self.text_generation_needed = true;
-    }
-
-    pub fn set_color(&mut self, color: Pixel) {
-        self.text_color = color;
-        self.text_generation_needed = true;
-    }
-
-    fn generate_text(&mut self) {
-
-        self.layout.clear();
-        self.layout.append(&[&self.font],
-                           &fontdue::layout::TextStyle::new(&self.text, self.text_size, 0));
-
-        let size = self.texture_sprite.get_size();
-        self.texture_sprite.fill(Color::NONE);
-
-        //draw each glyph at the corresponding position on the texture
-        for glyph in self.layout.glyphs() {
-            let (_metrics, bitmap) = self.font.rasterize_config(glyph.key);
-
-            let glyph_x = glyph.x as usize;
-            let glyph_y = glyph.y as usize;
-            let size_w = size.w as usize;
-            let size_h = size.h as usize;
-
-            //only try to draw a glyph if its origin fits in the texture
-            if glyph_x < size_w && glyph_y < size_h {
-
-                //glyphs that do not fit on the texture are cropped at the edge of the latter
-                for x in 0..std::cmp::min(glyph.width, size_w - glyph_x) {
-                    for y in 0..std::cmp::min(glyph.height, size_h - glyph_y) {
-
-                        self.texture_sprite.set_pixel(
-                            Position {
-                                x: (glyph_x + x) as i32,
-                                y: (glyph_y + y) as i32,
-                            },
-                            self.text_color.with_alpha(bitmap[x + y * glyph.width])
-                        );
-            } } } }
-    }
-
-    fn configure_font(text_size: f32) -> fontdue::Font
-    {
-        let font = include_bytes!("../../assets/DejaVuSansMono.ttf");
-        let settings = fontdue::FontSettings {
-            scale: text_size,
-            ..fontdue::FontSettings::default()
-        };
-        fontdue::Font::from_bytes(&font[..], settings).unwrap()
     }
 }
 
 impl Sprite for TextSprite {
 
-    fn set_position(&mut self, position: Position) {
+    fn set_position(&mut self, _pos: Position) {
-        self.texture_sprite.set_position(position);
+        todo!();
     }
 
-    fn set_center(&mut self, center: Position) {
+    fn set_rotation(&mut self, _rot: f32) {
-        self.texture_sprite.set_center(center);
+        todo!();
     }
 
-    fn set_rotation(&mut self, rotation: f32) {
+    fn set_alpha(&mut self, _alpha: u8) {
-        self.texture_sprite.set_rotation(rotation);
+        todo!();
     }
 
-    fn set_alpha(&mut self, alpha: u8) {
+    fn set_scale(&mut self, _scale: f32) {
-        self.texture_sprite.set_alpha(alpha);
+        todo!();
     }
 
-    fn set_scale(&mut self, scale: f32) {
+    fn render(&mut self, _renderer: &mut WgpuRenderer) {
-        self.texture_sprite.set_scale(scale);
+        todo!();
-    }
-
-    fn render(&mut self, renderer: &mut WgpuRenderer) {
-
-        // generate text if any setting changed
-        if self.text_generation_needed == true {
-            self.generate_text();
-            self.text_generation_needed = false;
-        }
-
-        self.texture_sprite.render(renderer);
     }
 }
 

src/sprite/texture_sprite.rs

@@ -91,20 +91,11 @@ impl TextureSprite {
         self.texture.for_each_in_area(func, self.offset, self.inner_size);
     }
 
-    pub fn fill(&mut self, pixel: Pixel) {
-        self.texture.fill(pixel);
-    }
-
-    pub fn get_size(&self) -> Size {
-        self.texture.get_size()
-    }
-
     fn update_vertices(&mut self, renderer: &WgpuRenderer) {
 
         debug!("Updating vertices...");
         let size = self.texture.get_size();
 
-
         // compute normalized coordinates
         let x_size = self.inner_size.w as f32 / size.w as f32 * self.scale;
         let y_size = self.inner_size.h as f32 / size.h as f32 * self.scale;
@@ -112,10 +103,8 @@ impl TextureSprite {
         let y_offset = self.offset.y as f32 / size.h as f32;
 
         // compute mesh size
-
+        let w = self.inner_size.w as f32;
-		//divide by 2 since the quad's coords go from -0.5 to 0.5
+        let h = self.inner_size.h as f32;
-        let w = self.inner_size.w as f32 / 2.0;
-        let h = self.inner_size.h as f32 / 2.0;
 
         let mesh = [
             TextureVertex {
@@ -144,16 +133,12 @@ impl TextureSprite {
 
 impl Sprite for TextureSprite {
 
-    fn set_position(&mut self, position: Position) {
+    fn set_position(&mut self, pos: Position) {
-        self.matrix.set_position(position);
+        self.matrix.set_position(pos);
     }
 
-    fn set_center(&mut self, center: Position) {
+    fn set_rotation(&mut self, rot: f32) {
-        self.matrix.set_center(center);
+        self.matrix.set_rotation(rot);
-    }
-
-    fn set_rotation(&mut self, rotation: f32) {
-        self.matrix.set_rotation(rotation);
     }
 
     fn set_alpha(&mut self, _alpha: u8) {
@@ -250,7 +235,7 @@ fn initialize_pipeline(renderer: &WgpuRenderer) -> wgpu::RenderPipeline {
             entry_point: "fs_main",
             targets: &[Some(wgpu::ColorTargetState {
                 format: renderer.config.format,
-                blend: Some(wgpu::BlendState::ALPHA_BLENDING),
+                blend: Some(wgpu::BlendState::REPLACE),
                 write_mask: wgpu::ColorWrites::ALL,
             })],
         }),

src/texture.rs

@@ -30,7 +30,7 @@ impl TextureHandle {
 
         //TODO check pos ?
         let mut texture = self.texture.borrow_mut();
-        let width = texture.size.w as i32;
+        let width = texture.size.w;
         texture.buffer[(pos.x + pos.y*width) as usize] = pix;
         texture.is_synced = false;
     }
@@ -51,21 +51,15 @@ impl TextureHandle {
     {
         //TODO check offset and pos ?
         let mut texture = self.texture.borrow_mut();
-        let width = texture.size.w as i32;
+        let width = texture.size.w;
-        for x in offset.x..(offset.x + size.w as i32) {
+        for x in offset.x..(offset.x + size.w) {
-            for y in offset.y..(offset.y + size.h as i32) {
+            for y in offset.y..(offset.y + size.h) {
                 func(&mut texture.buffer[(x + y*width) as usize]);
             }
         }
         texture.is_synced = false;
     }
 
-    pub fn fill (&mut self, pixel: Pixel) {
-        let mut texture = self.texture.borrow_mut();
-        texture.buffer.fill(pixel);
-        texture.is_synced = false;
-    }
-
     pub fn texture(&self) -> &Rc<RefCell<Texture>> {
         //TODO improve that
         &self.texture
@@ -76,3 +70,4 @@ impl TextureHandle {
     }
 }
 
+

src/utils.rs

@@ -3,13 +3,13 @@ use log::{debug, error, info, trace, warn};
 
 use winit;
 
-use cgmath::{Vector3, Vector2};
+use cgmath::Vector3;
 
 //--Position struct---------------------------------------------------------------------------------
-#[derive(Copy, Clone, Debug)]
+#[derive(Copy, Clone)]
 pub struct Position {
-    pub x: i32,
+    pub x: u32, 
-    pub y: i32,
+    pub y: u32,
 }
 
 impl Position {
@@ -23,19 +23,12 @@ impl Position {
 }
 
 impl From<Position> for Vector3<f32> {
-
+    
     fn from(pos: Position) -> Self {
         Self::new(pos.x as f32, pos.y as f32, 0.0)
     }
 }
 
-impl From<Position> for Vector2<f32> {
-
-    fn from(pos: Position) -> Self {
-        Self::new(pos.x as f32, pos.y as f32)
-    }
-}
-
 impl std::ops::Add for Position {
     type Output = Self;
 
@@ -47,17 +40,6 @@ impl std::ops::Add for Position {
     }
 }
 
-impl std::ops::Mul<f32> for Position {
-    type Output = Self;
-
-    fn mul(self, rhs: f32) -> Self::Output {
-        Position {
-            x: ((self.x as f32) * rhs) as i32,
-            y: ((self.y as f32) * rhs) as i32,
-        }
-    }
-}
-
 //--Size struct-------------------------------------------------------------------------------------
 #[derive(Copy, Clone)]
 pub struct Size {
@@ -70,7 +52,7 @@ impl From<Size> for winit::dpi::Size {
     fn from(size: Size) -> Self {
         winit::dpi::Size::Physical (
             winit::dpi::PhysicalSize {
-                width: size.w,
+                width: size.w, 
                 height: size.h,
         })
     }
@@ -97,13 +79,6 @@ impl From<winit::dpi::PhysicalSize<u32>> for Size {
     }
 }
 
-impl From<Size> for Vector2<f32> {
-
-    fn from(size: Size) -> Self {
-        Self::new(size.w as f32, size.h as f32)
-    }
-}
-
 //--Pixel struct------------------------------------------------------------------------------------
 #[derive(Copy, Clone, bytemuck::Pod, bytemuck::Zeroable)]
 #[repr(C)]
@@ -123,23 +98,13 @@ pub union Pixel {
 unsafe impl bytemuck::Pod for Pixel {}
 
 impl Pixel {
-
+    
     pub fn rgb(r: u8, g: u8, b: u8) -> Pixel {
         Pixel {
             rgba: Rgba{r, g, b, a: 255},
         }
     }
 
-    pub fn rgba(r: u8, g: u8, b: u8, a: u8) -> Pixel {
-        Pixel {
-            rgba: Rgba{r, g, b, a},
-        }
-    }
-
-    pub fn with_alpha(self, a: u8) -> Pixel {
-        unsafe { Pixel::rgba(self.rgba.r, self.rgba.g, self.rgba.b, a) }
-    }
-
     pub fn to_rgba(&self) -> Rgba {
         unsafe { self.rgba }
     }
@@ -152,10 +117,10 @@ pub struct Color;
 impl Color {
     pub const NONE:  Pixel = Pixel {flat: 0x00000000};
     pub const WHITE: Pixel = Pixel {flat: 0xffffffff};
-    pub const BLACK: Pixel = Pixel {flat: 0xff000000};
+    pub const BLACK: Pixel = Pixel {flat: 0x000000ff};
     pub const RED:   Pixel = Pixel {flat: 0xff0000ff};
-    pub const GREEN: Pixel = Pixel {flat: 0xff00ff00};
+    pub const GREEN: Pixel = Pixel {flat: 0x00ff00ff};
-    pub const BLUE:  Pixel = Pixel {flat: 0xffff0000};
+    pub const BLUE:  Pixel = Pixel {flat: 0x0000ffff};
 }