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 crate::canvas_frame::CanvasFrame;
use std::hash::Hash;
use crate::canvas_text::{CanvasText};
use crate::canvas_text::{CanvasText, CanvasTextHandle};
use crate::canvas_shader::{CanvasShader, CanvasShaderHandle};
use crate::canvas_buffer::{CanvasImage, CanvasTexture, CanvasTextCache};
use crate::vertex_3d::Vertex3D;
@@ -203,37 +203,37 @@ impl CanvasState {
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 text = CanvasText {
handle: handle.clone(),
buffer: 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().0,
size: dimensions,
};
let text_cache = CanvasTextCache {
handle: handle.clone(),
buffer: CpuAccessibleBuffer::<[u8]>::from_iter(
self.device.clone(),
BufferUsage::all(),
cache_pixel_buffer.iter().cloned()
).unwrap(),
size: dimensions,
};
self.text_buffers.push(Arc::new((text, text_cache)));
//
// let text = CanvasText {
// handle: handle.clone(),
// buffer: 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().0,
// size: dimensions,
// };
//
// let text_cache = CanvasTextCache {
// handle: handle.clone(),
// buffer: CpuAccessibleBuffer::<[u8]>::from_iter(
// self.device.clone(),
// BufferUsage::all(),
// cache_pixel_buffer.iter().cloned()
// ).unwrap(),
// size: dimensions,
// };
//
// self.text_buffers.push(Arc::new((text, text_cache)));
//
handle
}

5
src/canvas_buffer.rs
View File

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

7
src/canvas_shader.rs
View File

@@ -122,9 +122,9 @@ impl CanvasShader {
pass_op: StencilOp::Invert,
fail_op: StencilOp::Keep,
depth_fail_op: StencilOp::Keep,
compare_mask: Some(u32::MAX),
write_mask: Some(u32::MAX),
reference: Some(u32::MAX),
compare_mask: Some(u32::max_value()),
write_mask: Some(u32::max_value()),
reference: Some(u32::max_value()),
},
stencil_back: Default::default()
};
@@ -151,7 +151,6 @@ impl CanvasShader {
})
.depth_stencil(stencil)
.depth_stencil_simple_depth()
// 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.

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)
#[derive(Clone, Debug, Default, PartialEq, Eq, Hash)]
pub struct CanvasShaderHandle {
pub struct CanvasTextHandle {
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
/// I then use a CanvasFrame which accumulates lists of handles and vertices.
pub struct CanvasText {
@@ -27,27 +33,27 @@ pub struct CanvasText {
font: Font<'static>,
cache: Cache<'static>,
cache_pixel_buffer: Vec<u8>,
texts: Vec<TextData>,
texts: Vec<u8>,
}
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_pixel_buffer = vec!(0; CACHE_WIDTH * CACHE_HEIGHT);
// let font_data = include_bytes!("DejaVuSans.ttf");
// let font = Font::from_bytes(font_data as &[u8]).unwrap();
let font_data = include_bytes!("../resources/fonts/sansation.ttf");
let font = Font::from_bytes(font_data as &[u8]).unwrap();
CanvasText {
device: (),
queue: (),
font: (),
cache: (),
cache_pixel_buffer: (),
texts: ()
device: device.clone(),
queue: queue.clone(),
font: font,
cache: cache,
cache_pixel_buffer: vec![],
texts: vec![]
}
}
@@ -60,132 +66,132 @@ impl CanvasText {
for glyph in &glyphs {
self.cache.queue_glyph(0, glyph.clone());
}
self.texts.push(TextData {
glyphs: glyphs.clone(),
color: color,
});
// self.texts.push(TextData {
// glyphs: glyphs.clone(),
// color: color,
// });
}
pub fn draw_text(&mut self,
command_buffer: AutoCommandBufferBuilder,
image_num: usize
) -> 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 {
// 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 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 {
//// 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 = command_buffer.draw(self.pipeline.clone(), &DynamicState::none(), vertex_buffer.clone(), set.clone(), ()).unwrap();
}
command_buffer.end_render_pass().unwrap()
command_buffer//.end_render_pass().unwrap()
}
}