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

feat(graphics_resource_manager): added font atlas and a way to load a shader directly from a source string (wgsl only right now)

Browse source
This commit is contained in:
lisk77 2025-11-02 02:11:17 +01:00
parent 8831c46b4c
commit 86392d4c05
1 changed files with 41 additions and 118 deletions
Download patch file Download diff file Expand all files Collapse all files

159
crates/comet_resources/src/graphic_resource_manager.rs
View file

@ -1,14 +1,19 @@
use std::{collections::HashMap, path::Path};
use crate::font::Font;
use crate::texture_atlas::{TextureAtlas, TextureRegion};
use crate::{font, texture, Texture};
use crate::{
font::Font,
texture_atlas::{TextureAtlas, TextureRegion},
Texture,
};
use comet_log::info;
use wgpu::naga::ShaderStage;
use wgpu::{naga, Device, FilterMode, Queue, ShaderModule, TextureFormat, TextureUsages};
use wgpu::{
naga::{self, ShaderStage},
Device, Queue, ShaderModule,
};
pub struct GraphicResourceManager {
texture_atlas: TextureAtlas,
font_atlas: TextureAtlas,
fonts: Vec<Font>,
data_files: HashMap<String, String>,
shaders: HashMap<String, ShaderModule>,
@ -18,6 +23,7 @@ impl GraphicResourceManager {
pub fn new() -> Self {
Self {
texture_atlas: TextureAtlas::empty(),
font_atlas: TextureAtlas::empty(),
fonts: Vec::new(),
data_files: HashMap::new(),
shaders: HashMap::new(),
@ -28,6 +34,14 @@ impl GraphicResourceManager {
&self.texture_atlas
}
pub fn font_atlas(&self) -> &TextureAtlas {
&self.font_atlas
}
pub fn set_font_atlas(&mut self, font_atlas: TextureAtlas) {
self.font_atlas = font_atlas
}
pub fn texture_locations(&self) -> &HashMap<String, TextureRegion> {
&self.texture_atlas.textures()
}
@ -40,6 +54,10 @@ impl GraphicResourceManager {
&self.fonts
}
pub fn fonts_mut(&mut self) -> &mut Vec<Font> {
&mut self.fonts
}
pub fn get_glyph(&self, font: &str, ch: char) -> Option<&TextureRegion> {
self.fonts
.iter()
@ -49,10 +67,6 @@ impl GraphicResourceManager {
pub fn set_texture_atlas(&mut self, texture_atlas: TextureAtlas) {
self.texture_atlas = texture_atlas;
// This is just for testing purposes
//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]));
}
pub fn create_texture_atlas(&mut self, paths: Vec<String>) {
@ -95,9 +109,9 @@ impl GraphicResourceManager {
/// `shader_stage` is only needed if it is a GLSL shader, so default to None if it isn't GLSL
pub fn load_shader(
&mut self,
device: &Device,
shader_stage: Option<ShaderStage>,
file_name: &str,
device: &Device,
) -> anyhow::Result<()> {
let shader_source = self.load_string(file_name)?;
@ -127,6 +141,23 @@ impl GraphicResourceManager {
Ok(())
}
/// Loads the shader from a source code string
/// Right now only works with wgsl
pub fn load_shader_from_string(
&mut self,
device: &Device,
shader_name: &str,
shader_src: &str,
) -> anyhow::Result<()> {
let module = device.create_shader_module(wgpu::ShaderModuleDescriptor {
label: Some(shader_name),
source: wgpu::ShaderSource::Wgsl(shader_src.into()),
});
self.shaders.insert(shader_name.to_string(), module);
Ok(())
}
pub fn get_shader(&self, shader: &str) -> Option<&ShaderModule> {
self.shaders.get(shader)
}
@ -137,112 +168,4 @@ impl GraphicResourceManager {
info!("Font {} loaded!", font.name());
self.fonts.push(font);
}
/*pub async fn load_model(
&self,
file_name: &str,
device: &wgpu::Device,
queue: &wgpu::Queue,
layout: &wgpu::BindGroupLayout,
) -> anyhow::Result<model::Model> {
let obj_text = self.load_string(file_name).await?;
let obj_cursor = Cursor::new(obj_text);
let mut obj_reader = BufReader::new(obj_cursor);
let (models, obj_materials) = tobj::load_obj_buf_async(
&mut obj_reader,
&tobj::LoadOptions {
triangulate: true,
single_index: true,
..Default::default()
},
|p| async move {
let mat_text = self.load_string(&p).await.unwrap();
tobj::load_mtl_buf(&mut BufReader::new(Cursor::new(mat_text)))
},
)
.await?;
let mut materials = Vec::new();
for m in obj_materials? {
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 bind_group = device.create_bind_group(&wgpu::BindGroupDescriptor {
layout,
entries: &[
wgpu::BindGroupEntry {
binding: 0,
resource: wgpu::BindingResource::TextureView(&diffuse_texture.view),
},
wgpu::BindGroupEntry {
binding: 1,
resource: wgpu::BindingResource::Sampler(&diffuse_texture.sampler),
},
],
label: None,
});
materials.push(model::Material {
name: m.name,
diffuse_texture,
bind_group,
});
}
let meshes = models
.into_iter()
.map(|m| {
let vertices = (0..m.mesh.positions.len() / 3)
.map(|i| {
if m.mesh.normals.is_empty() {
model::ModelVertex {
position: [
m.mesh.positions[i * 3],
m.mesh.positions[i * 3 + 1],
m.mesh.positions[i * 3 + 2],
],
tex_coords: [m.mesh.texcoords[i * 2], 1.0 - m.mesh.texcoords[i * 2 + 1]],
normal: [0.0, 0.0, 0.0],
}
} else {
model::ModelVertex {
position: [
m.mesh.positions[i * 3],
m.mesh.positions[i * 3 + 1],
m.mesh.positions[i * 3 + 2],
],
tex_coords: [m.mesh.texcoords[i * 2], 1.0 - m.mesh.texcoords[i * 2 + 1]],
normal: [
m.mesh.normals[i * 3],
m.mesh.normals[i * 3 + 1],
m.mesh.normals[i * 3 + 2],
],
}
}
})
.collect::<Vec<_>>();
let vertex_buffer = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
label: Some(&format!("{:?} Vertex Buffer", file_name)),
contents: bytemuck::cast_slice(&vertices),
usage: wgpu::BufferUsages::VERTEX,
});
let index_buffer = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
label: Some(&format!("{:?} Index Buffer", file_name)),
contents: bytemuck::cast_slice(&m.mesh.indices),
usage: wgpu::BufferUsages::INDEX,
});
model::Mesh {
name: file_name.to_string(),
vertex_buffer,
index_buffer,
num_elements: m.mesh.indices.len() as u32,
material: m.mesh.material_id.unwrap_or(0),
}
})
.collect::<Vec<_>>();
Ok(model::Model { meshes, materials })
}*/
}