lisk77/comet
1
0
Fork 0
mirror of https://github.com/lisk77/comet.git synced 2025-12-12 09:08:49 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

chore(all): fix warnings

Browse source
This commit is contained in:
lisk77 2025-11-02 13:14:41 +01:00
parent c7f0412eff
commit 81bc1cb790
14 changed files with 471 additions and 513 deletions
Download patch file Download diff file Expand all files Collapse all files

3
crates/comet_app/src/app.rs
View file

@ -33,7 +33,6 @@ pub struct App {
game_state: Option<Box<dyn Any>>, game_state: Option<Box<dyn Any>>,
audio: Box<dyn Audio>, audio: Box<dyn Audio>,
scene: Scene, scene: Scene,
fullscreen: bool,
should_quit: bool, should_quit: bool,
} }
@ -51,7 +50,6 @@ impl App {
game_state: None, game_state: None,
audio: Box::new(KiraAudio::new()), audio: Box::new(KiraAudio::new()),
scene: Scene::new(), scene: Scene::new(),
fullscreen: false,
should_quit: false, should_quit: false,
} }
} }
@ -372,6 +370,7 @@ impl App {
} }
} }
#[allow(unused_variables)]
match event { match event {
Event::WindowEvent { Event::WindowEvent {
ref event, ref event,

49
crates/comet_ecs/component_derive/src/lib.rs
View file

@ -2,16 +2,12 @@ extern crate proc_macro;
use proc_macro::TokenStream; use proc_macro::TokenStream;
use quote::quote; use quote::quote;
use syn::{parse_macro_input, DeriveInput, Data, Fields}; use syn::{parse_macro_input, Data, DeriveInput, Fields};
// This is the procedural macro for `derive(MyTrait)`
#[proc_macro_derive(Component)] #[proc_macro_derive(Component)]
pub fn my_trait_derive(input: TokenStream) -> TokenStream { pub fn component_derive(input: TokenStream) -> TokenStream {
// Parse the input tokens into a syntax tree (AST)
let input = parse_macro_input!(input as DeriveInput); let input = parse_macro_input!(input as DeriveInput);
// Get the name of the struct
let name = &input.ident;
let name = &input.ident; let name = &input.ident;
let fields = if let Data::Struct(data) = &input.data { let fields = if let Data::Struct(data) = &input.data {
@ -33,19 +29,21 @@ pub fn my_trait_derive(input: TokenStream) -> TokenStream {
let default_fields = if let Data::Struct(data) = &input.data { let default_fields = if let Data::Struct(data) = &input.data {
match &data.fields { match &data.fields {
Fields::Named(fields) => { Fields::Named(fields) => fields
// Generate code to assign each field a default value .named
fields.named.iter().map(|field| { .iter()
.map(|field| {
let field_name = &field.ident; let field_name = &field.ident;
quote! { #field_name: Default::default() } quote! { #field_name: Default::default() }
}).collect::<Vec<_>>() })
}, .collect::<Vec<_>>(),
Fields::Unnamed(fields) => { Fields::Unnamed(fields) => fields
// Generate default values for tuple structs .unnamed
fields.unnamed.iter().map(|_field| { .iter()
.map(|_field| {
quote! { Default::default() } quote! { Default::default() }
}).collect::<Vec<_>>() })
}, .collect::<Vec<_>>(),
Fields::Unit => Vec::new(), Fields::Unit => Vec::new(),
} }
} else { } else {
@ -59,13 +57,6 @@ pub fn my_trait_derive(input: TokenStream) -> TokenStream {
} }
}); });
for field in &fields {
if !is_copy_field(&field) {
panic!("All fields in the struct must implement Copy");
}
}
// Generate the implementation of MyTrait for the given struct
let expanded = quote! { let expanded = quote! {
impl Component for #name { impl Component for #name {
fn new() -> Self { fn new() -> Self {
@ -83,7 +74,6 @@ pub fn my_trait_derive(input: TokenStream) -> TokenStream {
impl Default for #name { impl Default for #name {
fn default() -> Self { fn default() -> Self {
// Construct the struct with default values
Self { Self {
#(#default_fields),* #(#default_fields),*
} }
@ -115,16 +105,5 @@ pub fn my_trait_derive(input: TokenStream) -> TokenStream {
} }
}; };
// Convert the generated code into a TokenStream and return it
TokenStream::from(expanded) TokenStream::from(expanded)
} }
fn is_copy_field(field: &syn::Field) -> bool {
// Logic to check if the field type implements Copy (this is simplified)
// You might need more sophisticated logic to check the actual type of the field.
let field_type = &field.ty;
// Implement a check for Copy trait for the field type if needed
// Return true if it implements Copy; false otherwise
true // Assuming it does, just for simplicity
}

76
crates/comet_ecs/src/archetypes.rs
View file

@ -1,59 +1,47 @@
use std::collections::{HashMap, HashSet};
use comet_structs::ComponentSet; use comet_structs::ComponentSet;
use std::collections::{HashMap, HashSet};
#[derive(Debug, Clone)] #[derive(Debug, Clone)]
pub struct Archetypes { pub struct Archetypes {
archetypes: HashMap<ComponentSet, HashSet<u32>> archetypes: HashMap<ComponentSet, HashSet<u32>>,
} }
impl Archetypes { impl Archetypes {
pub fn new() -> Self { pub fn new() -> Self {
Self { Self {
archetypes: HashMap::new() archetypes: HashMap::new(),
} }
} }
pub fn component_sets(&self) -> Vec<ComponentSet> { pub fn component_sets(&self) -> Vec<ComponentSet> {
self.archetypes.keys().cloned().collect() self.archetypes.keys().cloned().collect()
} }
pub fn create_archetype(&mut self, components: ComponentSet) { pub fn create_archetype(&mut self, components: ComponentSet) {
self.archetypes.insert(components, HashSet::new()); self.archetypes.insert(components, HashSet::new());
} }
pub fn get_archetype(&self, components: &ComponentSet) -> Option<&HashSet<u32>> { pub fn get_archetype(&self, components: &ComponentSet) -> Option<&HashSet<u32>> {
self.archetypes.get(components) self.archetypes.get(components)
} }
pub fn get_archetype_mut(&mut self, components: &ComponentSet) -> Option<&mut HashSet<u32>> { pub fn add_entity_to_archetype(&mut self, components: &ComponentSet, entity: u32) {
self.archetypes.get_mut(components) if let Some(archetype) = self.archetypes.get_mut(components) {
} archetype.insert(entity);
}
}
pub fn add_entity_to_archetype(&mut self, components: &ComponentSet, entity: u32) { pub fn remove_entity_from_archetype(&mut self, components: &ComponentSet, entity: u32) {
if let Some(archetype) = self.archetypes.get_mut(components) { if let Some(archetype) = self.archetypes.get_mut(components) {
archetype.insert(entity); archetype.retain(|&id| id != entity);
} }
} }
pub fn remove_entity_from_archetype(&mut self, components: &ComponentSet, entity: u32) { pub fn remove_archetype(&mut self, components: &ComponentSet) {
if let Some(archetype) = self.archetypes.get_mut(components) { self.archetypes.remove(components);
archetype.retain(|&id| id != entity); }
}
}
pub fn remove_archetype(&mut self, components: &ComponentSet) { pub fn contains_archetype(&self, components: &ComponentSet) -> bool {
self.archetypes.remove(components); self.archetypes.contains_key(components)
} }
pub fn contains_archetype(&self, components: &ComponentSet) -> bool {
self.archetypes.contains_key(components)
}
pub fn archetype_contains_entity(&self, entity_id: u32, components: &ComponentSet) -> bool {
if self.contains_archetype(components) {
let archetype = self.get_archetype(components).unwrap();
return archetype.contains(&entity_id);
}
false
}
} }

130
crates/comet_input/src/input_handler.rs
View file

@ -1,73 +1,81 @@
use winit::event::{ElementState, WindowEvent, KeyEvent, Event};
use std::collections::HashSet;
use winit::event::WindowEvent::KeyboardInput;
use winit::keyboard::PhysicalKey;
use crate::keyboard::Key; use crate::keyboard::Key;
use winit::event::{ElementState, Event, KeyEvent, WindowEvent};
use winit::keyboard::PhysicalKey;
#[derive(Debug)] #[derive(Debug)]
pub struct InputHandler { pub struct InputHandler {
keys_pressed: Vec<PhysicalKey>, keys_pressed: Vec<PhysicalKey>,
keys_held: Vec<PhysicalKey>, keys_held: Vec<PhysicalKey>,
keys_released: Vec<PhysicalKey> keys_released: Vec<PhysicalKey>,
} }
impl InputHandler { impl InputHandler {
pub fn new() -> Self { pub fn new() -> Self {
Self { Self {
keys_pressed: Vec::new(), keys_pressed: Vec::new(),
keys_held: Vec::new(), keys_held: Vec::new(),
keys_released: Vec::new() keys_released: Vec::new(),
} }
} }
pub fn update<T>(&mut self, event: &Event<T>) { pub fn update<T>(&mut self, event: &Event<T>) {
match event { match event {
Event::WindowEvent { Event::WindowEvent {
event: WindowEvent::KeyboardInput { event:
event: KeyEvent { WindowEvent::KeyboardInput {
state, event:
physical_key: PhysicalKey::Code(keycode), KeyEvent {
.. state,
}, physical_key: PhysicalKey::Code(keycode),
.. ..
}, },
.. ..
} => },
{ ..
match state { } => match state {
ElementState::Pressed => { ElementState::Pressed => {
if self.keys_pressed.contains(&PhysicalKey::Code(keycode.clone())) { if self
self.keys_held.push(PhysicalKey::Code(keycode.clone())); .keys_pressed
} else { .contains(&PhysicalKey::Code(keycode.clone()))
self.keys_pressed.push(PhysicalKey::Code(keycode.clone())); {
} self.keys_held.push(PhysicalKey::Code(keycode.clone()));
self.keys_pressed.push(PhysicalKey::Code(keycode.clone())); } else {
} self.keys_pressed.push(PhysicalKey::Code(keycode.clone()));
ElementState::Released => { }
self.keys_released = vec![]; self.keys_pressed.push(PhysicalKey::Code(keycode.clone()));
if let Some(index) = self.keys_pressed.iter().position(|&x| x == PhysicalKey::Code(keycode.clone())) { }
self.keys_pressed.remove(index); ElementState::Released => {
} self.keys_released = vec![];
if let Some(index) = self.keys_held.iter().position(|&x| x == PhysicalKey::Code(keycode.clone())) { if let Some(index) = self
self.keys_held.remove(index); .keys_pressed
} .iter()
self.keys_released.push(PhysicalKey::Code(keycode.clone())); .position(|&x| x == PhysicalKey::Code(keycode.clone()))
} {
} self.keys_pressed.remove(index);
} }
_ => {} if let Some(index) = self
} .keys_held
} .iter()
.position(|&x| x == PhysicalKey::Code(keycode.clone()))
{
self.keys_held.remove(index);
}
self.keys_released.push(PhysicalKey::Code(keycode.clone()));
}
},
_ => {}
}
}
pub fn key_pressed(&self, key: Key) -> bool { pub fn key_pressed(&self, key: Key) -> bool {
self.keys_pressed.contains(&PhysicalKey::Code(key)) self.keys_pressed.contains(&PhysicalKey::Code(key))
} }
pub fn key_held(&self, key: Key) -> bool { pub fn key_held(&self, key: Key) -> bool {
self.keys_held.contains(&PhysicalKey::Code(key)) self.keys_held.contains(&PhysicalKey::Code(key))
} }
pub fn key_released(&self, key: Key) -> bool { pub fn key_released(&self, key: Key) -> bool {
self.keys_released.contains(&PhysicalKey::Code(key)) self.keys_released.contains(&PhysicalKey::Code(key))
} }
} }

11
crates/comet_renderer/src/camera.rs
View file

@ -1,5 +1,4 @@
use comet_ecs::{Camera2D, Transform2D}; use comet_ecs::{Camera2D, Transform2D};
use comet_log::fatal;
use comet_math::{m4, v2, v3}; use comet_math::{m4, v2, v3};
pub struct CameraManager { pub struct CameraManager {
@ -15,16 +14,6 @@ impl CameraManager {
} }
} }
pub fn set_cameras(&mut self, cameras: Vec<RenderCamera>) {
self.cameras = cameras
}
pub fn set_active(&mut self, active: usize) {
if active >= self.cameras.len() {
fatal!("Active camera index is out of range of the RenderCamera array!")
}
}
pub fn get_camera(&self) -> &RenderCamera { pub fn get_camera(&self) -> &RenderCamera {
self.cameras.get(self.active_camera).unwrap() self.cameras.get(self.active_camera).unwrap()
} }

186
crates/comet_resources/src/font.rs
View file

@ -1,120 +1,120 @@
use image::{DynamicImage, Rgba, RgbaImage};
use ab_glyph::{FontArc, PxScale, ScaleFont, Glyph, point, Font as AbFont};
use comet_log::debug;
use crate::texture_atlas::{TextureAtlas, TextureRegion}; use crate::texture_atlas::{TextureAtlas, TextureRegion};
use ab_glyph::{point, Font as AbFont, FontArc, Glyph, PxScale, ScaleFont};
use image::{DynamicImage, Rgba, RgbaImage};
pub struct GlyphData { pub struct GlyphData {
pub name: String, pub name: String,
pub render: DynamicImage, pub render: DynamicImage,
pub advance: f32, pub advance: f32,
pub offset_x: f32, pub offset_x: f32,
pub offset_y: f32, pub offset_y: f32,
} }
pub struct Font { pub struct Font {
name: String, name: String,
size: f32, size: f32,
line_height: f32, line_height: f32,
glyphs: TextureAtlas, glyphs: TextureAtlas,
} }
impl Font { impl Font {
pub fn new(path: &str, size: f32) -> Self { pub fn new(path: &str, size: f32) -> Self {
let (glyphs, line_height) = Self::generate_atlas(path, size); let (glyphs, line_height) = Self::generate_atlas(path, size);
Font { Font {
name: path.to_string(), name: path.to_string(),
size, size,
line_height, line_height,
glyphs glyphs,
} }
} }
pub fn name(&self) -> &str { pub fn name(&self) -> &str {
&self.name &self.name
} }
pub fn size(&self) -> f32 { pub fn size(&self) -> f32 {
self.size self.size
} }
pub fn line_height(&self) -> f32 { pub fn line_height(&self) -> f32 {
self.line_height self.line_height
} }
pub fn glyphs(&self) -> &TextureAtlas { pub fn glyphs(&self) -> &TextureAtlas {
&self.glyphs &self.glyphs
} }
pub fn get_glyph(&self, ch: char) -> Option<&TextureRegion> { pub fn get_glyph(&self, ch: char) -> Option<&TextureRegion> {
self.glyphs.textures().get(&ch.to_string()) self.glyphs.textures().get(&ch.to_string())
} }
fn generate_atlas(path: &str, size: f32) -> (TextureAtlas, f32) { fn generate_atlas(path: &str, size: f32) -> (TextureAtlas, f32) {
let font_data = std::fs::read(path).expect("Failed to read font file"); let font_data = std::fs::read(path).expect("Failed to read font file");
let font = FontArc::try_from_vec(font_data).expect("Failed to load font"); let font = FontArc::try_from_vec(font_data).expect("Failed to load font");
let scale = PxScale::from(size); let scale = PxScale::from(size);
let scaled_font = font.as_scaled(scale); let scaled_font = font.as_scaled(scale);
let mut glyphs: Vec<GlyphData> = Vec::new(); let mut glyphs: Vec<GlyphData> = Vec::new();
for code_point in 0x0020..=0x007E { for code_point in 0x0020..=0x007E {
if let Some(ch) = std::char::from_u32(code_point) { if let Some(ch) = std::char::from_u32(code_point) {
let glyph_id = font.glyph_id(ch); let glyph_id = font.glyph_id(ch);
if glyph_id.0 == 0 { if glyph_id.0 == 0 {
continue; continue;
} }
if ch == ' ' { if ch == ' ' {
let advance = scaled_font.h_advance(glyph_id); let advance = scaled_font.h_advance(glyph_id);
glyphs.push(GlyphData { glyphs.push(GlyphData {
name: ch.to_string(), name: ch.to_string(),
render: DynamicImage::new_rgba8(0, 0), // no bitmap render: DynamicImage::new_rgba8(0, 0), // no bitmap
advance, advance,
offset_x: 0.0, offset_x: 0.0,
offset_y: 0.0, offset_y: 0.0,
}); });
continue; continue;
} }
let glyph = Glyph { let glyph = Glyph {
id: glyph_id, id: glyph_id,
scale, scale,
position: point(0.0, 0.0), position: point(0.0, 0.0),
}; };
if let Some(outline) = scaled_font.outline_glyph(glyph.clone()) { if let Some(outline) = scaled_font.outline_glyph(glyph.clone()) {
let bounds = outline.px_bounds(); let bounds = outline.px_bounds();
let width = bounds.width().ceil() as u32; let width = bounds.width().ceil() as u32;
let height = bounds.height().ceil() as u32; let height = bounds.height().ceil() as u32;
if width == 0 || height == 0 { if width == 0 || height == 0 {
continue; continue;
} }
let mut image = RgbaImage::new(width, height); let mut image = RgbaImage::new(width, height);
for pixel in image.pixels_mut() { for pixel in image.pixels_mut() {
*pixel = Rgba([0, 0, 0, 0]); *pixel = Rgba([0, 0, 0, 0]);
} }
outline.draw(|x, y, v| { outline.draw(|x, y, v| {
let alpha = (v * 255.0) as u8; let alpha = (v * 255.0) as u8;
image.put_pixel(x, y, Rgba([255, 255, 255, alpha])); image.put_pixel(x, y, Rgba([255, 255, 255, alpha]));
}); });
glyphs.push( glyphs.push(GlyphData {
GlyphData { name: ch.to_string(),
name: ch.to_string(), render: DynamicImage::ImageRgba8(image),
render: DynamicImage::ImageRgba8(image), advance: scaled_font.h_advance(glyph_id),
advance: scaled_font.h_advance(glyph_id), offset_x: bounds.min.x,
offset_x: bounds.min.x, offset_y: bounds.min.y,
offset_y: bounds.min.y, })
} }
) }
} }
}
}
(TextureAtlas::from_glyphs(glyphs), scaled_font.ascent() - scaled_font.descent()) (
} TextureAtlas::from_glyphs(glyphs),
scaled_font.ascent() - scaled_font.descent(),
)
}
} }

311
crates/comet_resources/src/resources.rs
View file

@ -1,182 +1,181 @@
use std::{ use std::{collections::HashMap, path::Path};
collections::HashMap, path::Path
use crate::{
texture,
texture_atlas::{TextureAtlas, TextureRegion},
}; };
use wgpu::{Device, FilterMode, Queue, TextureFormat, TextureUsages};
use crate::{texture, Texture};
use crate::texture_atlas::{TextureAtlas, TextureRegion};
pub struct ResourceManager { pub struct ResourceManager {
texture_atlas: TextureAtlas, texture_atlas: TextureAtlas,
data_files: HashMap<String, String> data_files: HashMap<String, String>,
} }
impl ResourceManager { impl ResourceManager {
pub fn new() -> Self { pub fn new() -> Self {
Self { Self {
texture_atlas: TextureAtlas::empty(), texture_atlas: TextureAtlas::empty(),
data_files: HashMap::new() data_files: HashMap::new(),
} }
} }
pub fn texture_atlas(&self) -> &TextureAtlas { pub fn texture_atlas(&self) -> &TextureAtlas {
&self.texture_atlas &self.texture_atlas
} }
pub fn texture_locations(&self) -> &HashMap<String, TextureRegion> { pub fn texture_locations(&self) -> &HashMap<String, TextureRegion> {
&self.texture_atlas.textures() &self.texture_atlas.textures()
} }
pub fn data_files(&self) -> &HashMap<String, String> { pub fn data_files(&self) -> &HashMap<String, String> {
&self.data_files &self.data_files
} }
pub fn set_texture_atlas(&mut self, texture_atlas: TextureAtlas) { pub fn set_texture_atlas(&mut self, texture_atlas: TextureAtlas) {
self.texture_atlas = texture_atlas; self.texture_atlas = texture_atlas;
// This is just for testing purposes // This is just for testing purposes
//self.texture_locations.insert("normal_comet.png".to_string(), ([0,0], [15,15])); //self.texture_locations.insert("normal_comet.png".to_string(), ([0,0], [15,15]));
//self.texture_locations.insert("green_comet.png".to_string(), ([0,15], [15,31])); //self.texture_locations.insert("green_comet.png".to_string(), ([0,15], [15,31]));
} }
pub fn create_texture_atlas(&mut self, paths: Vec<String>) { pub fn create_texture_atlas(&mut self, paths: Vec<String>) {
self.texture_atlas = TextureAtlas::from_texture_paths(paths) self.texture_atlas = TextureAtlas::from_texture_paths(paths)
} }
pub async fn load_string(&self, file_name: &str) -> anyhow::Result<String> { pub async fn load_string(&self, file_name: &str) -> anyhow::Result<String> {
let path = Path::new(std::env::var("OUT_DIR")?.as_str()) let path = Path::new(std::env::var("OUT_DIR")?.as_str())
.join("res") .join("res")
.join(file_name); .join(file_name);
let txt = std::fs::read_to_string(path)?; let txt = std::fs::read_to_string(path)?;
Ok(txt) Ok(txt)
} }
pub async fn load_binary(&self, file_name: &str) -> anyhow::Result<Vec<u8>> { pub async fn load_binary(&self, file_name: &str) -> anyhow::Result<Vec<u8>> {
let path = Path::new(std::env::var("OUT_DIR").unwrap().as_str()) let path = Path::new(std::env::var("OUT_DIR").unwrap().as_str())
.join("res") .join("res")
.join(file_name); .join(file_name);
let data = std::fs::read(path)?; let data = std::fs::read(path)?;
Ok(data) Ok(data)
} }
pub async fn load_texture( pub async fn load_texture(
&self, &self,
file_name: &str, file_name: &str,
is_normal_map: bool, is_normal_map: bool,
device: &wgpu::Device, device: &wgpu::Device,
queue: &wgpu::Queue, queue: &wgpu::Queue,
) -> anyhow::Result<texture::Texture> { ) -> anyhow::Result<texture::Texture> {
let data = self.load_binary(file_name).await?; let data = self.load_binary(file_name).await?;
texture::Texture::from_bytes(device, queue, &data, file_name, is_normal_map) texture::Texture::from_bytes(device, queue, &data, file_name, is_normal_map)
} }
/*pub async fn load_model( /*pub async fn load_model(
&self, &self,
file_name: &str, file_name: &str,
device: &wgpu::Device, device: &wgpu::Device,
queue: &wgpu::Queue, queue: &wgpu::Queue,
layout: &wgpu::BindGroupLayout, layout: &wgpu::BindGroupLayout,
) -> anyhow::Result<model::Model> { ) -> anyhow::Result<model::Model> {
let obj_text = self.load_string(file_name).await?; let obj_text = self.load_string(file_name).await?;
let obj_cursor = Cursor::new(obj_text); let obj_cursor = Cursor::new(obj_text);
let mut obj_reader = BufReader::new(obj_cursor); let mut obj_reader = BufReader::new(obj_cursor);
let (models, obj_materials) = tobj::load_obj_buf_async( let (models, obj_materials) = tobj::load_obj_buf_async(
&mut obj_reader, &mut obj_reader,
&tobj::LoadOptions { &tobj::LoadOptions {
triangulate: true, triangulate: true,
single_index: true, single_index: true,
..Default::default() ..Default::default()
}, },
|p| async move { |p| async move {
let mat_text = self.load_string(&p).await.unwrap(); let mat_text = self.load_string(&p).await.unwrap();
tobj::load_mtl_buf(&mut BufReader::new(Cursor::new(mat_text))) tobj::load_mtl_buf(&mut BufReader::new(Cursor::new(mat_text)))
}, },
) )
.await?; .await?;
let mut materials = Vec::new(); let mut materials = Vec::new();
for m in obj_materials? { for m in obj_materials? {
let diffuse_texture = self.load_texture(&m.diffuse_texture, false, device, queue).await?; let diffuse_texture = self.load_texture(&m.diffuse_texture, false, device, queue).await?;
let normal_texture = self.load_texture(&m.normal_texture, true, device, queue).await?; let normal_texture = self.load_texture(&m.normal_texture, true, device, queue).await?;
let bind_group = device.create_bind_group(&wgpu::BindGroupDescriptor { let bind_group = device.create_bind_group(&wgpu::BindGroupDescriptor {
layout, layout,
entries: &[ entries: &[
wgpu::BindGroupEntry { wgpu::BindGroupEntry {
binding: 0, binding: 0,
resource: wgpu::BindingResource::TextureView(&diffuse_texture.view), resource: wgpu::BindingResource::TextureView(&diffuse_texture.view),
}, },
wgpu::BindGroupEntry { wgpu::BindGroupEntry {
binding: 1, binding: 1,
resource: wgpu::BindingResource::Sampler(&diffuse_texture.sampler), resource: wgpu::BindingResource::Sampler(&diffuse_texture.sampler),
}, },
], ],
label: None, label: None,
}); });
materials.push(model::Material { materials.push(model::Material {
name: m.name, name: m.name,
diffuse_texture, diffuse_texture,
bind_group, bind_group,
}); });
} }
let meshes = models let meshes = models
.into_iter() .into_iter()
.map(|m| { .map(|m| {
let vertices = (0..m.mesh.positions.len() / 3) let vertices = (0..m.mesh.positions.len() / 3)
.map(|i| { .map(|i| {
if m.mesh.normals.is_empty() { if m.mesh.normals.is_empty() {
model::ModelVertex { model::ModelVertex {
position: [ position: [
m.mesh.positions[i * 3], m.mesh.positions[i * 3],
m.mesh.positions[i * 3 + 1], m.mesh.positions[i * 3 + 1],
m.mesh.positions[i * 3 + 2], m.mesh.positions[i * 3 + 2],
], ],
tex_coords: [m.mesh.texcoords[i * 2], 1.0 - m.mesh.texcoords[i * 2 + 1]], tex_coords: [m.mesh.texcoords[i * 2], 1.0 - m.mesh.texcoords[i * 2 + 1]],
normal: [0.0, 0.0, 0.0], normal: [0.0, 0.0, 0.0],
} }
} else { } else {
model::ModelVertex { model::ModelVertex {
position: [ position: [
m.mesh.positions[i * 3], m.mesh.positions[i * 3],
m.mesh.positions[i * 3 + 1], m.mesh.positions[i * 3 + 1],
m.mesh.positions[i * 3 + 2], m.mesh.positions[i * 3 + 2],
], ],
tex_coords: [m.mesh.texcoords[i * 2], 1.0 - m.mesh.texcoords[i * 2 + 1]], tex_coords: [m.mesh.texcoords[i * 2], 1.0 - m.mesh.texcoords[i * 2 + 1]],
normal: [ normal: [
m.mesh.normals[i * 3], m.mesh.normals[i * 3],
m.mesh.normals[i * 3 + 1], m.mesh.normals[i * 3 + 1],
m.mesh.normals[i * 3 + 2], m.mesh.normals[i * 3 + 2],
], ],
} }
} }
}) })
.collect::<Vec<_>>(); .collect::<Vec<_>>();
let vertex_buffer = device.create_buffer_init(&wgpu::util::BufferInitDescriptor { let vertex_buffer = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
label: Some(&format!("{:?} Vertex Buffer", file_name)), label: Some(&format!("{:?} Vertex Buffer", file_name)),
contents: bytemuck::cast_slice(&vertices), contents: bytemuck::cast_slice(&vertices),
usage: wgpu::BufferUsages::VERTEX, usage: wgpu::BufferUsages::VERTEX,
}); });
let index_buffer = device.create_buffer_init(&wgpu::util::BufferInitDescriptor { let index_buffer = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
label: Some(&format!("{:?} Index Buffer", file_name)), label: Some(&format!("{:?} Index Buffer", file_name)),
contents: bytemuck::cast_slice(&m.mesh.indices), contents: bytemuck::cast_slice(&m.mesh.indices),
usage: wgpu::BufferUsages::INDEX, usage: wgpu::BufferUsages::INDEX,
}); });
model::Mesh { model::Mesh {
name: file_name.to_string(), name: file_name.to_string(),
vertex_buffer, vertex_buffer,
index_buffer, index_buffer,
num_elements: m.mesh.indices.len() as u32, num_elements: m.mesh.indices.len() as u32,
material: m.mesh.material_id.unwrap_or(0), material: m.mesh.material_id.unwrap_or(0),
} }
}) })
.collect::<Vec<_>>(); .collect::<Vec<_>>();
Ok(model::Model { meshes, materials }) Ok(model::Model { meshes, materials })
}*/ }*/
} }

2
crates/comet_resources/src/texture_atlas.rs
View file

@ -334,7 +334,7 @@ impl TextureAtlas {
for glyph_name in glyph_names { for glyph_name in glyph_names {
let region = font.glyphs().textures().get(&glyph_name).unwrap(); let region = font.glyphs().textures().get(&glyph_name).unwrap();
let (u0, v0, u1, v1) = (region.u0(), region.v0(), region.u1(), region.v1()); let (u0, v0) = (region.u0(), region.v0());
let (width, height) = region.dimensions(); let (width, height) = region.dimensions();
let src_x = (u0 * font.glyphs().atlas().width() as f32) as u32; let src_x = (u0 * font.glyphs().atlas().width() as f32) as u32;

86
crates/comet_resources/src/vertex.rs
View file

@ -1,55 +1,53 @@
use wgpu::Color;
#[repr(C)] #[repr(C)]
#[derive(Copy, Clone, Debug, bytemuck::Pod, bytemuck::Zeroable, PartialEq)] #[derive(Copy, Clone, Debug, bytemuck::Pod, bytemuck::Zeroable, PartialEq)]
pub struct Vertex { pub struct Vertex {
position: [f32; 3], position: [f32; 3],
tex_coords: [f32; 2], tex_coords: [f32; 2],
color: [f32; 4] color: [f32; 4],
} }
impl Vertex { impl Vertex {
pub fn new(position: [f32; 3], tex_coords: [f32; 2], color: [f32; 4]) -> Self { pub fn new(position: [f32; 3], tex_coords: [f32; 2], color: [f32; 4]) -> Self {
Self { Self {
position, position,
tex_coords, tex_coords,
color color,
} }
} }
pub fn set_position(&mut self, new_position: [f32;3]) { pub fn set_position(&mut self, new_position: [f32; 3]) {
self.position = new_position self.position = new_position
} }
pub fn set_tex_coords(&mut self, new_tex_coords: [f32; 2]) { pub fn set_tex_coords(&mut self, new_tex_coords: [f32; 2]) {
self.tex_coords = new_tex_coords self.tex_coords = new_tex_coords
} }
pub fn set_color(&mut self, new_color: [f32; 4]) { pub fn set_color(&mut self, new_color: [f32; 4]) {
self.color = new_color self.color = new_color
} }
pub fn desc() -> wgpu::VertexBufferLayout<'static> { pub fn desc() -> wgpu::VertexBufferLayout<'static> {
wgpu::VertexBufferLayout { wgpu::VertexBufferLayout {
array_stride: std::mem::size_of::<Vertex>() as wgpu::BufferAddress, array_stride: std::mem::size_of::<Vertex>() as wgpu::BufferAddress,
step_mode: wgpu::VertexStepMode::Vertex, step_mode: wgpu::VertexStepMode::Vertex,
attributes: &[ attributes: &[
wgpu::VertexAttribute { wgpu::VertexAttribute {
offset: 0, offset: 0,
shader_location: 0, shader_location: 0,
format: wgpu::VertexFormat::Float32x3, format: wgpu::VertexFormat::Float32x3,
}, },
wgpu::VertexAttribute { wgpu::VertexAttribute {
offset: std::mem::size_of::<[f32; 3]>() as wgpu::BufferAddress, offset: std::mem::size_of::<[f32; 3]>() as wgpu::BufferAddress,
shader_location: 1, shader_location: 1,
format: wgpu::VertexFormat::Float32x2, format: wgpu::VertexFormat::Float32x2,
}, },
wgpu::VertexAttribute { wgpu::VertexAttribute {
offset: std::mem::size_of::<[f32; 5]>() as wgpu::BufferAddress, offset: std::mem::size_of::<[f32; 5]>() as wgpu::BufferAddress,
shader_location: 2, shader_location: 2,
format: wgpu::VertexFormat::Float32x4, format: wgpu::VertexFormat::Float32x4,
} },
] ],
} }
} }
} }

101
crates/comet_structs/src/component_storage.rs
View file

@ -1,65 +1,58 @@
use std::any::{Any, TypeId};
use comet_log::*;
use crate::{FlatMap, SparseSet}; use crate::{FlatMap, SparseSet};
use comet_log::*;
use std::any::TypeId;
pub type ComponentStorage = FlatMap<TypeId, SparseSet>; pub type ComponentStorage = FlatMap<TypeId, SparseSet>;
impl ComponentStorage { impl ComponentStorage {
pub fn register_component<T: 'static>(&mut self, capacity: usize) {
if !self.contains(&TypeId::of::<T>()) {
self.insert(TypeId::of::<T>(), SparseSet::new::<T>(capacity, 1000));
} else {
error!("Component {:?} already exists", TypeId::of::<T>());
}
}
pub fn register_component<T: 'static>(&mut self, capacity: usize) { pub fn deregister_component<T: 'static>(&mut self) {
if !self.contains(&TypeId::of::<T>()) { if self.contains(&TypeId::of::<T>()) {
self.insert(TypeId::of::<T>(), SparseSet::new::<T>(capacity, 1000)); self.remove(&TypeId::of::<T>());
} } else {
else { error!("Component {:?} does not exist", TypeId::of::<T>());
error!("Component {:?} already exists", TypeId::of::<T>()); }
} }
}
pub fn deregister_component<T: 'static>(&mut self) { pub fn set_component<T: 'static>(&mut self, index: usize, element: T) {
if self.contains(&TypeId::of::<T>()) { if let Some(sparse_set) = self.get_mut(&TypeId::of::<T>()) {
self.remove(&TypeId::of::<T>()); sparse_set.insert(index, element);
} } else {
else { error!("Component {:?} is not registered", TypeId::of::<T>());
error!("Component {:?} does not exist", TypeId::of::<T>()); }
} }
}
pub fn set_component<T: 'static>(&mut self, index: usize, element: T) { pub fn remove_component<T: 'static>(&mut self, index: usize) -> Option<T> {
if let Some(sparse_set) = self.get_mut(&TypeId::of::<T>()) { if let Some(sparse_set) = self.get_mut(&TypeId::of::<T>()) {
sparse_set.insert(index, element); sparse_set.remove(index)
} } else {
else { error!("Component {:?} is not registered", TypeId::of::<T>());
error!("Component {:?} is not registered", TypeId::of::<T>()); None
} }
} }
pub fn remove_component<T: 'static>(&mut self, index: usize) -> Option<T> { pub fn get_component<T: 'static>(&self, index: usize) -> Option<&T> {
if let Some(sparse_set) = self.get_mut(&TypeId::of::<T>()) { if let Some(sparse_set) = self.get(&TypeId::of::<T>()) {
sparse_set.remove(index) sparse_set.get(index)
} } else {
else { error!("Component {:?} is not registered", TypeId::of::<T>());
error!("Component {:?} is not registered", TypeId::of::<T>()); None
None }
} }
}
pub fn get_component<T: 'static>(&self, index: usize) -> Option<&T> { pub fn get_component_mut<T: 'static>(&mut self, index: usize) -> Option<&mut T> {
if let Some(sparse_set) = self.get(&TypeId::of::<T>()) { if let Some(sparse_set) = self.get_mut(&TypeId::of::<T>()) {
sparse_set.get(index) sparse_set.get_mut(index)
} } else {
else { error!("Component {:?} is not registered", TypeId::of::<T>());
error!("Component {:?} is not registered", TypeId::of::<T>()); None
None }
} }
}
pub fn get_component_mut<T: 'static>(&mut self, index: usize) -> Option<&mut T> {
if let Some(sparse_set) = self.get_mut(&TypeId::of::<T>()) {
sparse_set.get_mut(index)
}
else {
error!("Component {:?} is not registered", TypeId::of::<T>());
None
}
}
} }

16
examples/hello_world.rs
View file

@ -1,17 +1,19 @@
use comet::prelude::*; use comet::prelude::*;
// This function will only be called once before the event loop starts. // This function will only be called once before the event loop starts.
#[allow(unused_variables)]
fn setup(app: &mut App, renderer: &mut Renderer2D) {} fn setup(app: &mut App, renderer: &mut Renderer2D) {}
// This function will be called on every tick after the event loop starts. // This function will be called on every tick after the event loop starts.
#[allow(unused_variables)]
fn update(app: &mut App, renderer: &mut Renderer2D, dt: f32) {} fn update(app: &mut App, renderer: &mut Renderer2D, dt: f32) {}
fn main() { fn main() {
// This creates a window with the title "Hello world". // This creates a window with the title "Hello world".
// Note: You can call your functions differently if you want to though it is advised to use // Note: You can call your functions differently if you want to though it is advised to use
// `setup` and `update` as the names. // `setup` and `update` as the names.
// You can also replace `Renderer2D` with any other struct that implements the `Renderer` trait. // You can also replace `Renderer2D` with any other struct that implements the `Renderer` trait.
App::new() App::new()
.with_title("Hello world") .with_title("Hello world")
.run::<Renderer2D>(setup, update); .run::<Renderer2D>(setup, update);
} }

1
examples/prefabs.rs
View file

@ -43,6 +43,7 @@ fn setup(app: &mut App, renderer: &mut Renderer2D) {
} }
} }
#[allow(unused_variables)]
fn update(app: &mut App, renderer: &mut Renderer2D, dt: f32) {} fn update(app: &mut App, renderer: &mut Renderer2D, dt: f32) {}
fn main() { fn main() {

1
examples/simple_text.rs
View file

@ -26,6 +26,7 @@ fn setup(app: &mut App, renderer: &mut Renderer2D) {
); );
} }
#[allow(unused_variables)]
fn update(app: &mut App, renderer: &mut Renderer2D, dt: f32) { fn update(app: &mut App, renderer: &mut Renderer2D, dt: f32) {
// Getting the windows size // Getting the windows size
let size = renderer.size(); let size = renderer.size();

1
examples/textured_entity.rs
View file

@ -18,6 +18,7 @@ fn setup(app: &mut App, renderer: &mut Renderer2D) {
app.add_component(e0, render); app.add_component(e0, render);
} }
#[allow(unused_variables)]
fn update(app: &mut App, renderer: &mut Renderer2D, dt: f32) { fn update(app: &mut App, renderer: &mut Renderer2D, dt: f32) {
renderer.render_scene_2d(app.scene_mut()) renderer.render_scene_2d(app.scene_mut())
} }