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

brought back to a compiling state

Browse Source
This commit is contained in:
mitchellhansen
2019-09-17 20:28:16 -07:00
parent 89fc974d3c
commit 038eedeb97
4 changed files with 173 additions and 167 deletions
Download Patch File Download Diff File Expand all files Collapse all files

64
src/canvas.rs
View File

@@ -20,7 +20,7 @@ use vulkano::pipeline::viewport::Viewport;
use vulkano::descriptor::descriptor::DescriptorDescTy::TexelBuffer; use vulkano::descriptor::descriptor::DescriptorDescTy::TexelBuffer;
use crate::canvas_frame::CanvasFrame; use crate::canvas_frame::CanvasFrame;
use std::hash::Hash; use std::hash::Hash;
use crate::canvas_text::{CanvasText}; use crate::canvas_text::{CanvasText, CanvasTextHandle};
use crate::canvas_shader::{CanvasShader, CanvasShaderHandle}; use crate::canvas_shader::{CanvasShader, CanvasShaderHandle};
use crate::canvas_buffer::{CanvasImage, CanvasTexture, CanvasTextCache}; use crate::canvas_buffer::{CanvasImage, CanvasTexture, CanvasTextCache};
use crate::vertex_3d::Vertex3D; use crate::vertex_3d::Vertex3D;
@@ -203,37 +203,37 @@ impl CanvasState {
pub fn create_text_buffers(&mut self, dimensions: (u32, u32)) -> Arc<CanvasTextHandle> { pub fn create_text_buffers(&mut self, dimensions: (u32, u32)) -> Arc<CanvasTextHandle> {
let handle = Arc::new(CanvasTextHandle { handle: self.text_buffers.len() as u32 }); let handle = Arc::new(CanvasTextHandle { handle: self.text_buffers.len() as u32 });
//
let text = CanvasText { // let text = CanvasText {
handle: handle.clone(), // handle: handle.clone(),
buffer: ImmutableImage::uninitialized( // buffer: ImmutableImage::uninitialized(
self.device.clone(), // self.device.clone(),
Dimensions::Dim2d { width: CACHE_WIDTH as u32, height: CACHE_HEIGHT as u32 }, // Dimensions::Dim2d { width: CACHE_WIDTH as u32, height: CACHE_HEIGHT as u32 },
R8Unorm, // R8Unorm,
1, // 1,
ImageUsage { // ImageUsage {
sampled: true, // sampled: true,
transfer_destination: true, // transfer_destination: true,
.. ImageUsage::none() // .. ImageUsage::none()
}, // },
ImageLayout::General, // ImageLayout::General,
Some(self.queue.family()) // Some(self.queue.family())
).unwrap().0, // ).unwrap().0,
size: dimensions, // size: dimensions,
}; // };
//
let text_cache = CanvasTextCache { // let text_cache = CanvasTextCache {
handle: handle.clone(), // handle: handle.clone(),
buffer: CpuAccessibleBuffer::<[u8]>::from_iter( // buffer: CpuAccessibleBuffer::<[u8]>::from_iter(
self.device.clone(), // self.device.clone(),
BufferUsage::all(), // BufferUsage::all(),
cache_pixel_buffer.iter().cloned() // cache_pixel_buffer.iter().cloned()
).unwrap(), // ).unwrap(),
size: dimensions, // size: dimensions,
}; // };
//
self.text_buffers.push(Arc::new((text, text_cache))); // self.text_buffers.push(Arc::new((text, text_cache)));
//
handle handle
} }

5
src/canvas_buffer.rs
View File

@@ -7,6 +7,7 @@ use vulkano::sampler::Sampler;
use vulkano::descriptor::DescriptorSet; use vulkano::descriptor::DescriptorSet;
use vulkano::descriptor::descriptor_set::PersistentDescriptorSet; use vulkano::descriptor::descriptor_set::PersistentDescriptorSet;
use vulkano::buffer::CpuAccessibleBuffer; use vulkano::buffer::CpuAccessibleBuffer;
use crate::canvas_text::{CanvasTextCacheHandle, CanvasTextHandle};
#[derive(Clone)] #[derive(Clone)]
pub struct CanvasTexture { pub struct CanvasTexture {
@@ -53,7 +54,7 @@ impl CanvasImage {
#[derive(Clone)] #[derive(Clone)]
pub struct CanvasTextCache { pub struct CanvasTextCache {
pub(crate) handle: Arc<CanvasTextCacheHandle>, pub(crate) handle: Arc<CanvasTextCacheHandle>,
pub(crate) buffer: Arc<CpuAccessibleBuffer<[u8]>>, pub(crate) buffer: Arc<CpuAccessibleBuffer<u8>>,
pub(crate) size: (u32, u32), pub(crate) size: (u32, u32),
} }
@@ -65,7 +66,7 @@ impl CanvasTextCache {
PersistentDescriptorSet::start( PersistentDescriptorSet::start(
shader.clone().get_pipeline().clone(), 0, shader.clone().get_pipeline().clone(), 0,
) )
.add_sampled_image(self.buffer.clone(), sampler.clone()).unwrap() .add_buffer(self.buffer.clone()).unwrap()
.build().unwrap()); .build().unwrap());
o o
} }

7
src/canvas_shader.rs
View File

@@ -122,9 +122,9 @@ impl CanvasShader {
pass_op: StencilOp::Invert, pass_op: StencilOp::Invert,
fail_op: StencilOp::Keep, fail_op: StencilOp::Keep,
depth_fail_op: StencilOp::Keep, depth_fail_op: StencilOp::Keep,
compare_mask: Some(u32::MAX), compare_mask: Some(u32::max_value()),
write_mask: Some(u32::MAX), write_mask: Some(u32::max_value()),
reference: Some(u32::MAX), reference: Some(u32::max_value()),
}, },
stencil_back: Default::default() stencil_back: Default::default()
}; };
@@ -151,7 +151,6 @@ impl CanvasShader {
}) })
.depth_stencil(stencil) .depth_stencil(stencil)
.depth_stencil_simple_depth()
// We have to indicate which subpass of which render pass this pipeline is going to be used // We have to indicate which subpass of which render pass this pipeline is going to be used
// in. The pipeline will only be usable from this particular subpass. // in. The pipeline will only be usable from this particular subpass.

264
src/canvas_text.rs
View File

@@ -15,10 +15,16 @@ const CACHE_HEIGHT: usize = 1000;
/// Typed wrapper for a u32 shader handle (index id) /// Typed wrapper for a u32 shader handle (index id)
#[derive(Clone, Debug, Default, PartialEq, Eq, Hash)] #[derive(Clone, Debug, Default, PartialEq, Eq, Hash)]
pub struct CanvasShaderHandle { pub struct CanvasTextHandle {
pub handle: u32 pub handle: u32
} }
#[derive(Clone, Debug, Default, PartialEq, Eq, Hash)]
pub struct CanvasTextCacheHandle {
pub handle: u32
}
/// So currently, I'm using these as container classes which vkprocessor owns /// So currently, I'm using these as container classes which vkprocessor owns
/// I then use a CanvasFrame which accumulates lists of handles and vertices. /// I then use a CanvasFrame which accumulates lists of handles and vertices.
pub struct CanvasText { pub struct CanvasText {
@@ -27,27 +33,27 @@ pub struct CanvasText {
font: Font<'static>, font: Font<'static>,
cache: Cache<'static>, cache: Cache<'static>,
cache_pixel_buffer: Vec<u8>, cache_pixel_buffer: Vec<u8>,
texts: Vec<TextData>, texts: Vec<u8>,
} }
impl CanvasText { impl CanvasText {
pub fn new() -> CanvasText { pub fn new(device: Arc<Device>, queue: Arc<Queue>) -> CanvasText {
let cache = Cache::builder().dimensions(CACHE_WIDTH as u32, CACHE_HEIGHT as u32).build(); let cache = Cache::builder().dimensions(CACHE_WIDTH as u32, CACHE_HEIGHT as u32).build();
let cache_pixel_buffer = vec!(0; CACHE_WIDTH * CACHE_HEIGHT); let cache_pixel_buffer = vec!(0; CACHE_WIDTH * CACHE_HEIGHT);
// let font_data = include_bytes!("DejaVuSans.ttf"); let font_data = include_bytes!("../resources/fonts/sansation.ttf");
// let font = Font::from_bytes(font_data as &[u8]).unwrap(); let font = Font::from_bytes(font_data as &[u8]).unwrap();
CanvasText { CanvasText {
device: (), device: device.clone(),
queue: (), queue: queue.clone(),
font: (), font: font,
cache: (), cache: cache,
cache_pixel_buffer: (), cache_pixel_buffer: vec![],
texts: () texts: vec![]
} }
} }
@@ -60,132 +66,132 @@ impl CanvasText {
for glyph in &glyphs { for glyph in &glyphs {
self.cache.queue_glyph(0, glyph.clone()); self.cache.queue_glyph(0, glyph.clone());
} }
self.texts.push(TextData { // self.texts.push(TextData {
glyphs: glyphs.clone(), // glyphs: glyphs.clone(),
color: color, // color: color,
}); // });
} }
pub fn draw_text(&mut self, pub fn draw_text(&mut self,
command_buffer: AutoCommandBufferBuilder, command_buffer: AutoCommandBufferBuilder,
image_num: usize image_num: usize
) -> AutoCommandBufferBuilder { ) -> AutoCommandBufferBuilder {
let screen_width = 0;
let screen_height = 0;
let cache_pixel_buffer = &mut self.cache_pixel_buffer;
let cache = &mut self.cache;
// update texture cache
cache.cache_queued(
|rect, src_data| {
let width = (rect.max.x - rect.min.x) as usize;
let height = (rect.max.y - rect.min.y) as usize;
let mut dst_index = rect.min.y as usize * CACHE_WIDTH + rect.min.x as usize;
let mut src_index = 0;
for _ in 0..height {
let dst_slice = &mut cache_pixel_buffer[dst_index..dst_index+width];
let src_slice = &src_data[src_index..src_index+width];
dst_slice.copy_from_slice(src_slice);
dst_index += CACHE_WIDTH;
src_index += width;
}
}
).unwrap();
// need to get a hold of the cache buffer handle after I create it
// will then get swapped into this texture buffer
// Hmmm so this uninit call returns the texture and then a handle for whatever fills it up
let (cache_texture, cache_texture_write) = ImmutableImage::uninitialized(
self.device.clone(),
Dimensions::Dim2d { width: CACHE_WIDTH as u32, height: CACHE_HEIGHT as u32 },
R8Unorm,
1,
ImageUsage {
sampled: true,
transfer_destination: true,
.. ImageUsage::none()
},
ImageLayout::General,
Some(self.queue.family())
).unwrap();
let set = Arc::new(
PersistentDescriptorSet::start(self.pipeline.clone(), 0)
.add_sampled_image(cache_texture.clone(), sampler).unwrap()
.build().unwrap()
);
let mut command_buffer = command_buffer
.copy_buffer_to_image(
buffer.clone(),
cache_texture_write,
).unwrap()
.begin_render_pass(self.framebuffers[image_num].clone(), false, vec!(ClearValue::None)).unwrap();
// draw
for text in &mut self.texts.drain(..) {
let vertices: Vec<Vertex2D> = text.glyphs.iter().flat_map(|g| {
if let Ok(Some((uv_rect, screen_rect))) = cache.rect_for(0, g) {
let gl_rect = Rect {
min: point(
(screen_rect.min.x as f32 / screen_width as f32 - 0.5) * 2.0,
(screen_rect.min.y as f32 / screen_height as f32 - 0.5) * 2.0
),
max: point(
(screen_rect.max.x as f32 / screen_width as f32 - 0.5) * 2.0,
(screen_rect.max.y as f32 / screen_height as f32 - 0.5) * 2.0
)
};
vec!(
// Vertex {
// position: [gl_rect.min.x, gl_rect.max.y],
// tex_position: [uv_rect.min.x, uv_rect.max.y],
// color: text.color,
// },
// Vertex {
// position: [gl_rect.min.x, gl_rect.min.y],
// tex_position: [uv_rect.min.x, uv_rect.min.y],
// color: text.color,
// },
// Vertex {
// position: [gl_rect.max.x, gl_rect.min.y],
// tex_position: [uv_rect.max.x, uv_rect.min.y],
// color: text.color,
// },
// //
// Vertex { // let screen_width = 0;
// position: [gl_rect.max.x, gl_rect.min.y], // let screen_height = 0;
// tex_position: [uv_rect.max.x, uv_rect.min.y], //
// color: text.color, // let cache_pixel_buffer = &mut self.cache_pixel_buffer;
// }, // let cache = &mut self.cache;
// Vertex { //
// position: [gl_rect.max.x, gl_rect.max.y], // // update texture cache
// tex_position: [uv_rect.max.x, uv_rect.max.y], // cache.cache_queued(
// color: text.color, // |rect, src_data| {
// }, // let width = (rect.max.x - rect.min.x) as usize;
// Vertex { // let height = (rect.max.y - rect.min.y) as usize;
// position: [gl_rect.min.x, gl_rect.max.y], // let mut dst_index = rect.min.y as usize * CACHE_WIDTH + rect.min.x as usize;
// tex_position: [uv_rect.min.x, uv_rect.max.y], // let mut src_index = 0;
// color: text.color, //
// }, // for _ in 0..height {
).into_iter() // let dst_slice = &mut cache_pixel_buffer[dst_index..dst_index+width];
} // let src_slice = &src_data[src_index..src_index+width];
else { // dst_slice.copy_from_slice(src_slice);
vec!().into_iter() //
} // dst_index += CACHE_WIDTH;
}).collect(); // src_index += width;
// }
// }
// ).unwrap();
//
// // need to get a hold of the cache buffer handle after I create it
// // will then get swapped into this texture buffer
// // Hmmm so this uninit call returns the texture and then a handle for whatever fills it up
// let (cache_texture, cache_texture_write) = ImmutableImage::uninitialized(
// self.device.clone(),
// Dimensions::Dim2d { width: CACHE_WIDTH as u32, height: CACHE_HEIGHT as u32 },
// R8Unorm,
// 1,
// ImageUsage {
// sampled: true,
// transfer_destination: true,
// .. ImageUsage::none()
// },
// ImageLayout::General,
// Some(self.queue.family())
// ).unwrap();
//
//
//
// let set = Arc::new(
// PersistentDescriptorSet::start(self.pipeline.clone(), 0)
// .add_sampled_image(cache_texture.clone(), sampler).unwrap()
// .build().unwrap()
// );
//
// let mut command_buffer = command_buffer
// .copy_buffer_to_image(
// buffer.clone(),
// cache_texture_write,
// ).unwrap()
// .begin_render_pass(self.framebuffers[image_num].clone(), false, vec!(ClearValue::None)).unwrap();
//
// // draw
// for text in &mut self.texts.drain(..) {
// let vertices: Vec<Vertex2D> = text.glyphs.iter().flat_map(|g| {
// if let Ok(Some((uv_rect, screen_rect))) = cache.rect_for(0, g) {
// let gl_rect = Rect {
// min: point(
// (screen_rect.min.x as f32 / screen_width as f32 - 0.5) * 2.0,
// (screen_rect.min.y as f32 / screen_height as f32 - 0.5) * 2.0
// ),
// max: point(
// (screen_rect.max.x as f32 / screen_width as f32 - 0.5) * 2.0,
// (screen_rect.max.y as f32 / screen_height as f32 - 0.5) * 2.0
// )
// };
// vec!(
//// Vertex {
//// position: [gl_rect.min.x, gl_rect.max.y],
//// tex_position: [uv_rect.min.x, uv_rect.max.y],
//// color: text.color,
//// },
//// Vertex {
//// position: [gl_rect.min.x, gl_rect.min.y],
//// tex_position: [uv_rect.min.x, uv_rect.min.y],
//// color: text.color,
//// },
//// Vertex {
//// position: [gl_rect.max.x, gl_rect.min.y],
//// tex_position: [uv_rect.max.x, uv_rect.min.y],
//// color: text.color,
//// },
////
//// Vertex {
//// position: [gl_rect.max.x, gl_rect.min.y],
//// tex_position: [uv_rect.max.x, uv_rect.min.y],
//// color: text.color,
//// },
//// Vertex {
//// position: [gl_rect.max.x, gl_rect.max.y],
//// tex_position: [uv_rect.max.x, uv_rect.max.y],
//// color: text.color,
//// },
//// Vertex {
//// position: [gl_rect.min.x, gl_rect.max.y],
//// tex_position: [uv_rect.min.x, uv_rect.max.y],
//// color: text.color,
//// },
// ).into_iter()
// }
// else {
// vec!().into_iter()
// }
// }).collect();
//
// let vertex_buffer = CpuAccessibleBuffer::from_iter(self.device.clone(), BufferUsage::all(), vertices.into_iter()).unwrap();
// command_buffer = command_buffer.draw(self.pipeline.clone(), &DynamicState::none(), vertex_buffer.clone(), set.clone(), ()).unwrap();
// }
let vertex_buffer = CpuAccessibleBuffer::from_iter(self.device.clone(), BufferUsage::all(), vertices.into_iter()).unwrap(); command_buffer//.end_render_pass().unwrap()
command_buffer = command_buffer.draw(self.pipeline.clone(), &DynamicState::none(), vertex_buffer.clone(), set.clone(), ()).unwrap();
}
command_buffer.end_render_pass().unwrap()
} }
} }