mitchellhansen/Trac3r-rust
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

more refactoring, compiles.

Browse Source
This commit is contained in:
mitchellhansen
2019-08-29 22:22:10 -07:00
parent 1737319fc5
commit 0357296771
12 changed files with 361 additions and 275 deletions
Download Patch File Download Diff File Expand all files Collapse all files

124
src/canvas.rs
View File

@@ -21,6 +21,7 @@ use winit::Window;
use vulkano::pipeline::viewport::Viewport;
use vulkano::descriptor::descriptor::DescriptorDescTy::TexelBuffer;
use crate::canvas_frame::CanvasFrame;
use std::hash::Hash;
// Canvas is the accumulator of Sprites for drawing
@@ -74,8 +75,8 @@ impl Vertex for ColoredVertex2D {
pub trait Drawable {
fn get_vertices(&self) -> Vec<(f32, f32)>;
fn get_color(&self) -> (f32, f32, f32, f32);
fn get_texture_handle(&self) -> Option<Arc<u32>>;
fn get_image_handle(&self) -> Option<Arc<u32>>;
fn get_texture_handle(&self) -> Option<Arc<CanvasTextureHandle>>;
fn get_image_handle(&self) -> Option<Arc<CanvasImageHandle>>;
}
// Need three types of shaders. Solid, Textured, Image
@@ -87,24 +88,24 @@ pub enum ShaderType {
}
#[derive(Clone)]
pub struct TextureHandle {
handle: u32
#[derive(Clone, Debug, Default, PartialEq, Eq, Hash)]
pub struct CanvasTextureHandle {
pub handle: u32
}
#[derive(Clone)]
pub struct ImageHandle {
handle: u32
#[derive(Clone, Debug, Default, PartialEq, Eq, Hash)]
pub struct CanvasImageHandle {
pub handle: u32
}
#[derive(Clone)]
pub struct ShaderHandle {
handle: u32
#[derive(Clone, Debug, Default, PartialEq, Eq, Hash)]
pub struct CanvasShaderHandle {
pub handle: u32
}
#[derive(Clone)]
pub struct CanvasTexture {
handle: Arc<TextureHandle>,
handle: Arc<CanvasTextureHandle>,
buffer: Arc<ImmutableImage<Format>>,
name: String,
size: (u32, u32),
@@ -126,7 +127,7 @@ impl CanvasTexture {
#[derive(Clone)]
pub struct CanvasImage {
handle: Arc<ImageHandle>,
handle: Arc<CanvasImageHandle>,
buffer: Arc<AttachmentImage>,
size: (u32, u32),
}
@@ -159,11 +160,11 @@ pub struct CanvasState {
colored_drawables: Vec<ColoredVertex2D>,
colored_vertex_buffer: Vec<Arc<(dyn BufferAccess + std::marker::Send + std::marker::Sync)>>,
textured_drawables: HashMap<Arc<u32>, Vec<Vec<Vertex2D>>>,
textured_vertex_buffer: HashMap<Arc<u32>, Arc<(dyn BufferAccess + std::marker::Send + std::marker::Sync)>>,
textured_drawables: HashMap<Arc<CanvasTextureHandle>, Vec<Vec<Vertex2D>>>,
textured_vertex_buffer: HashMap<Arc<CanvasTextureHandle>, Arc<(dyn BufferAccess + std::marker::Send + std::marker::Sync)>>,
image_drawables: HashMap<Arc<u32>, Vec<Vec<Vertex2D>>>,
image_vertex_buffer: HashMap<Arc<u32>, Arc<(dyn BufferAccess + std::marker::Send + std::marker::Sync)>>,
image_drawables: HashMap<Arc<CanvasImageHandle>, Vec<Vec<Vertex2D>>>,
image_vertex_buffer: HashMap<Arc<CanvasImageHandle>, Arc<(dyn BufferAccess + std::marker::Send + std::marker::Sync)>>,
// Looks like we gotta hold onto the queue for managing textures
queue: Arc<Queue>,
@@ -186,7 +187,7 @@ impl CanvasState {
images.iter().map(|image| {
Arc::new(
Framebuffer::start(self.shader_kernels.get(String::from("color-passthrough")).unwrap().render_pass.clone())
Framebuffer::start(self.shader_buffers.get("color-passthrough").unwrap().render_pass.clone())
.add(image.clone()).unwrap()
.build().unwrap()
) as Arc<dyn FramebufferAbstract + Send + Sync>
@@ -198,15 +199,10 @@ impl CanvasState {
device: Arc<Device>,
physical: PhysicalDevice,
capabilities: Capabilities) -> CanvasState {
let solid_color_kernel = String::from("color-passthrough");
let texture_kernel = String::from("simple_texture");
let shader_kernels: HashMap<ShaderType, ShaderKernels> = HashMap::from_iter(vec![
(ShaderType::SOLID, ShaderKernels::new(solid_color_kernel, capabilities.clone(), queue.clone(), physical.clone(), device.clone())),
(ShaderType::TEXTURED, ShaderKernels::new(texture_kernel, capabilities.clone(), queue.clone(), physical.clone(), device.clone()))
]);
CanvasState {
dynamic_state: DynamicState { line_width: None, viewports: None, scissors: None },
sampler: Sampler::new(device.clone(), Filter::Linear, Filter::Linear,
@@ -214,11 +210,24 @@ impl CanvasState {
SamplerAddressMode::Repeat, 0.0, 1.0, 0.0, 0.0).unwrap(),
image_buffers: vec![],
texture_buffers: vec![],
shader_buffers: Default::default(),
shader_buffers: HashMap::from_iter(vec![
(solid_color_kernel.clone(), ShaderKernels::new(solid_color_kernel.clone(),
capabilities.clone(),
queue.clone(),
physical.clone(),
device.clone())
),
(texture_kernel.clone(), ShaderKernels::new(texture_kernel.clone(),
capabilities.clone(),
queue.clone(),
physical.clone(),
device.clone())
),
]),
colored_drawables: vec![],
colored_vertex_buffer: vec![],
textured_drawables: Default::default(),
textured_drawables: HashMap::default(),
textured_vertex_buffer: Default::default(),
image_drawables: Default::default(),
image_vertex_buffer: Default::default(),
@@ -228,9 +237,9 @@ impl CanvasState {
}
}
pub fn create_image(&mut self, dimensions: (u32, u32), usage: ImageUsage) -> Arc<ImageHandle> {
pub fn create_image(&mut self, dimensions: (u32, u32), usage: ImageUsage) -> Arc<CanvasImageHandle> {
let image = CanvasImage {
handle: Arc::new(ImageHandle { handle: self.image_buffers.len() as u32 + 1 }),
handle: Arc::new(CanvasImageHandle { handle: self.image_buffers.len() as u32 + 1 }),
buffer: AttachmentImage::with_usage(
self.device.clone(),
[dimensions.0, dimensions.1],
@@ -243,8 +252,8 @@ impl CanvasState {
handle
}
pub fn get_image(&self, image_handle: Arc<ImageHandle>) -> Arc<AttachmentImage> {
self.image_buffers.get((*image_handle).clone() as usize).unwrap()
pub fn get_image(&self, image_handle: Arc<CanvasImageHandle>) -> Arc<AttachmentImage> {
self.image_buffers.get((*image_handle).clone().handle as usize).unwrap()
.clone().buffer.clone()
}
@@ -290,10 +299,10 @@ impl CanvasState {
texture
}
pub fn load_texture(&mut self, filename: String) -> Option<Arc<TextureHandle>> {
pub fn load_texture(&mut self, filename: String) -> Option<Arc<CanvasTextureHandle>> {
let texture_buffer = self.get_texture_from_file(filename.clone());
let handle = Arc::new(TextureHandle {
let handle = Arc::new(CanvasTextureHandle {
handle: self.texture_buffers.len() as u32 + 1
});
@@ -309,6 +318,18 @@ impl CanvasState {
Some(handle)
}
fn get_texture(&self, texture_handle: Arc<CanvasTextureHandle>)
-> Arc<ImmutableImage<Format>> {
let handle = texture_handle.handle as usize;
if let Some(i) = self.texture_buffers.get(handle) {
return i.clone().buffer.clone();
} else {
panic!("{} : Texture not loaded", handle);
}
}
// After done using this, need to call allocated vertex buffers
pub fn draw(&mut self, canvas_frame: CanvasFrame) {
self.textured_drawables = canvas_frame.textured_drawables;
@@ -353,15 +374,6 @@ impl CanvasState {
}
}
fn get_texture(&self, texture_id: String) -> Arc<ImmutableImage<Format>> {
if let Some(i) = self.texture_store.get(&texture_id) {
return i.clone();
} else {
panic!("{} : Texture not loaded", texture_id);
}
}
fn get_solid_color_descriptor_set(&self, kernel: Arc<ShaderKernels>) -> Box<dyn DescriptorSet + Send + Sync> {
let o: Box<dyn DescriptorSet + Send + Sync> = Box::new(
@@ -383,27 +395,31 @@ impl CanvasState {
framebuffers[image_num].clone(), false, clear_values.clone(),
).unwrap();
// Solid colors
let mut shader = self.shader_buffers.get("color-passthrough").unwrap().clone();
for (shader_type, kernel) in self.shader_kernels.clone().iter() {
command_buffer = command_buffer.draw(
shader.get_pipeline().clone(),
&self.dynamic_state.clone(),
self.colored_vertex_buffer.clone(),
(), (),
).unwrap();
/*for (shader_type, kernel) in self.shader_kernels.clone().iter() {
match shader_type {
ShaderType::SOLID => {
command_buffer = command_buffer.draw(
kernel.clone().get_pipeline().clone(),
&self.dynamic_state.clone(),
self.colored_vertex_buffer.clone(),
(), (),
).unwrap();
}
ShaderType::TEXTURED => {
// command_buffer = command_buffer.draw(
// kernel.clone().get_pipeline().clone(),
// &dynamic_state.clone(), self.textured_vertex_buffer.clone(),
// vec![self.get_textured_descriptor_set(String::from("funky-bird.jpg"))], ()
// ).unwrap();
command_buffer = command_buffer.draw(
kernel.clone().get_pipeline().clone(),
&dynamic_state.clone(), self.textured_vertex_buffer.clone(),
vec![self.get_textured_descriptor_set(String::from("funky-bird.jpg"))], ()
).unwrap();
}
ShaderType::IMAGE => {}
}
}
}*/
command_buffer
.end_render_pass()