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

moved over to the enum method of drawing. Not flexible, but type safe

Browse Source
This commit is contained in:
mitchellhansen
2020-02-12 00:42:30 -08:00
parent 80c0d323be
commit 659cd98a1f
23 changed files with 192 additions and 570 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
notes/Home.txt
View File

@@ -8,13 +8,13 @@ Creation-Date: 2020-02-03T22:11:42-08:00
Main Systems:
[[~/source/Trac3r-rust/doc/sfml_rust/sprite/index.html|Spri]][[~/source/Trac3r-rust/doc/sfml_rust/sprite/index.html|te]]
[[CanvasContainerClasses]]
[[VKProcessor:CanvasContainerClasses]]
Docs
[[VkProcessor]] [[~/source/Trac3r-rust/doc/sfml_rust/vkprocessor/struct.VkProcessor.html|===========]]
[[CanvasState]] [[~/source/Trac3r-rust/doc/sfml_rust/canvas/canvas_state/index.html|===========]]
[[DynamicVertex]]
[[CompuState]] [[~/source/Trac3r-rust/doc/sfml_rust/compute/compu_state/struct.CompuState.html|===========]]
[[VKProcessor:CanvasState]] [[~/source/Trac3r-rust/doc/sfml_rust/canvas/canvas_state/index.html|===========]]
[[VKProcessor:DynamicVertex]]
[[VKProcessor:CompuState]] [[~/source/Trac3r-rust/doc/sfml_rust/compute/compu_state/struct.CompuState.html|===========]]
--------------------

6
notes/VKProcessor.txt
View File

@@ -26,13 +26,13 @@ Vk Processors is a do_all class for interaction with the render window, vulkan s
queue
**Owns:**
[[CanvasState]]
[[CompuState]]
[[+CanvasState]]
[[+CompuState]]
--------------------
===== CanvasState =====
<[[CanvasState]]>:[[~/source/Trac3r-rust/doc/sfml_rust/canvas/canvas_state/index.html|docs]]
<[[+CanvasState]]>:[[~/source/Trac3r-rust/doc/sfml_rust/canvas/canvas_state/index.html|docs]]
* Is used for storage of texture and image buffers in addition to vertex buffers
* Also contains logic for writing the stored buffers to the command_buffer

1
notes/CanvasContainerClasses.txt → notes/VKProcessor/CanvasContainerClasses.txt
View File

@@ -18,6 +18,7 @@ All buffers will have a coupled handle type stored in the [[/src/canvas/mod.rs|c
===== CanvasTexture =====
===== CanvasFont =====

0
notes/CanvasFont.txt → notes/VKProcessor/CanvasFont.txt
View File

0
notes/CanvasFrame.txt → notes/VKProcessor/CanvasFrame.txt
View File

0
notes/CanvasImage.txt → notes/VKProcessor/CanvasImage.txt
View File

2
notes/CanvasState.txt → notes/VKProcessor/CanvasState.txt
View File

@@ -37,7 +37,7 @@ Creation-Date: 2020-02-03T23:30:41-08:00
**Owns:**
render_pass
[[CanvasImage]]
[[CanvasTexture]]
[[VKProcessor:CanvasTexture]]
[[CanvasFont]]
CompiledGraphicsPipeline
colored_vertex_buffer

0
notes/CanvasTexture.txt → notes/VKProcessor/CanvasTexture.txt
View File

0
notes/CompuState.txt → notes/VKProcessor/CompuState.txt
View File

0
notes/DynamicVertex.txt → notes/VKProcessor/DynamicVertex.txt
View File

24
src/canvas/canvas_frame.rs
View File

@@ -1,4 +1,3 @@
use crate::util::vertex_3d::Vertex3D;
use std::sync::Arc;
use std::collections::HashMap;
use std::hash::Hash;
@@ -10,11 +9,7 @@ use vulkano::pipeline::vertex::Vertex;
use std::any::Any;
// I don't think this is going to work without getting into Box'ing
pub trait DrawableTest<VTypes: Into<VertexTypes>, H: Handle + DynHash> {
fn get_vertices(&self) -> VTypes;
fn get_handle(&self) -> H;
}
pub mod dynhash {
use std::any::Any;
@@ -74,14 +69,19 @@ use crate::canvas::canvas_frame::dynhash::DynHash;
use crate::VertexTypes;
// CanvasFrameTest will be drawn to by objects implementing DrawableTest
pub struct CanvasFrameTest<VTypes> {
pub map: HashMap<Box<dyn DynHash>, VTypes>,
pub trait DrawableTest {
fn get(&self) -> VertexTypes;
}
impl<VTypes> CanvasFrameTest<VTypes> {
pub fn draw(&mut self, drawable: VTypes) {
self.map.insert(Box::new(10), drawable);
#[derive(Default)]
pub struct CanvasFrameTest {
pub map: Vec<VertexTypes>,
}
impl CanvasFrameTest {
pub fn draw(&mut self, drawable: &dyn DrawableTest) {
self.map.push(drawable.get());
}
}

222
src/canvas/canvas_state.rs
View File

@@ -20,7 +20,6 @@ use vulkano::pipeline::viewport::Viewport;
use vulkano::descriptor::descriptor::DescriptorDescTy::TexelBuffer;
use crate::canvas::canvas_frame::{CanvasFrame, CanvasFrameTest};
use std::hash::Hash;
use crate::util::vertex_3d::{Vertex3D, TextVertex3D};
use vulkano::pipeline::depth_stencil::{StencilFaceFlags, DynamicStencilValue};
use vulkano::memory::pool::PotentialDedicatedAllocation::Generic;
use std::borrow::Borrow;
@@ -29,11 +28,12 @@ use std::io::Read;
use rusttype::{Font, PositionedGlyph, Scale, Rect, point, GlyphId, Line, Curve, Segment};
use vulkano::pipeline::vertex::VertexDefinition;
use crate::canvas::managed::shader::dynamic_vertex::RuntimeVertexDef;
use crate::canvas::managed::handles::{CanvasTextureHandle, CanvasImageHandle, CanvasFontHandle, CompiledShaderHandle, Handle};
use crate::canvas::managed::handles::{CanvasTextureHandle, CanvasImageHandle, CanvasFontHandle, CompiledShaderHandle, Handle, DrawableHandle};
use crate::canvas::managed::gpu_buffers::{CanvasImage, CanvasTexture, CanvasFont};
use crate::canvas::managed::shader::shader_common::CompiledGraphicsPipeline;
use crate::canvas::managed::shader::generic_shader::GenericShader;
use crate::VertexTypes;
use crate::util::vertex::{TextVertex3D, TextureVertex2D, ImageVertex2D, ColorVertex2D, CanvasFrameAllocation};
/// Canvas state is used for storage of texture and image buffers in addition to vertex buffers
@@ -53,16 +53,6 @@ pub struct CanvasState {
// Compiled Graphics pipelines have a handle which self describe their position in this vector
shader_buffers: Vec<Arc<Box<dyn CompiledGraphicsPipeline>>>,
// Hold onto the vertices we get from the Compu and Canvas Frames
// When the run comes around, push the vertices to the GPU
colored_vertex_buffer: Vec<Arc<(dyn BufferAccess + Send + Sync)>>,
textured_vertex_buffer: HashMap<Arc<CanvasTextureHandle>, Arc<(dyn BufferAccess + Send + Sync)>>,
image_vertex_buffer: HashMap<Arc<CanvasImageHandle>, Arc<(dyn BufferAccess + Send + Sync)>>,
text_instances: HashMap<Arc<CanvasFontHandle>, Arc<(dyn BufferAccess + Send + Sync)>>,
// Looks like we gotta hold onto the queue for managing textures
queue: Arc<Queue>,
device: Arc<Device>,
@@ -70,7 +60,6 @@ pub struct CanvasState {
}
impl CanvasState {
/// This method is called once during initialization, then again whenever the window is resized
pub fn window_size_dependent_setup(&mut self, images: &[Arc<SwapchainImage<Window>>])
@@ -102,7 +91,6 @@ impl CanvasState {
device: Arc<Device>,
physical: PhysicalDevice,
capabilities: Capabilities) -> CanvasState {
let format = capabilities.supported_formats[0].0;
let render_pass = Arc::new(vulkano::single_pass_renderpass!(
@@ -172,11 +160,6 @@ impl CanvasState {
shader_buffers: vec![],
font_buffers: vec![],
colored_vertex_buffer: vec![],
textured_vertex_buffer: Default::default(),
image_vertex_buffer: Default::default(),
text_instances: HashMap::default(),
queue: queue.clone(),
device: device.clone(),
render_pass: render_pass.clone(),
@@ -393,91 +376,6 @@ impl CanvasState {
}
}
/// Scrape all the values from the CanvasFrame and then allocate the vertex buffers
pub fn draw(&mut self, canvas_frame: CanvasFrame) {
// Consume the canvas frame
let mut textured_drawables = canvas_frame.textured_drawables;
let mut colored_drawables = canvas_frame.colored_drawables;
let mut image_drawables = canvas_frame.image_drawables;
let mut text_drawables = canvas_frame.text_drawables;
// Walk through the consumed items and allocate them to GPU buffers
self.colored_vertex_buffer.clear();
{
let g = hprof::enter("Colored Vertex Buffer");
self.colored_vertex_buffer.push(
ImmutableBuffer::from_iter(
colored_drawables.iter().cloned(),
BufferUsage::vertex_buffer(),
self.queue.clone(),
).unwrap().0
);
}
self.textured_vertex_buffer.clear();
{
let g = hprof::enter("Textured Vertex Buffer");
for (k, v) in textured_drawables.drain() {
let vertex_buffer = v.clone().get(0).unwrap().clone();
// TODO
// v.clone().iter()
// .fold(Vec::new(), |mut a: Vec<RuntimeVertexDef>, b| {
// a.extend(b);
// a
// });
self.textured_vertex_buffer.insert(
k.clone(),
ImmutableBuffer::from_iter(
vertex_buffer.iter().cloned(),
BufferUsage::vertex_buffer(),
self.queue.clone(),
).unwrap().0,
);
}
}
self.image_vertex_buffer.clear();
{
let g = hprof::enter("Image Vertex Buffer");
for (k, v) in image_drawables.drain() {
let vertex_buffer = v.clone().get(0).unwrap().clone();
// TODO
// v.clone().iter()
// .fold(Vec::new(), |mut a: Vec<&RuntimeVertexDef>, b| {
// a.extend(b);
// a
// });
self.image_vertex_buffer.insert(
k.clone(),
ImmutableBuffer::from_iter(
vertex_buffer.iter().cloned(),
BufferUsage::vertex_buffer(),
self.queue.clone(),
).unwrap().0,
);
}
}
self.text_instances.clear();
{
let g = hprof::enter("Text Instance Vertex Buffer");
for (k, v) in text_drawables.drain() {
self.text_instances.insert(
k.clone(),
ImmutableBuffer::from_iter(
v.iter().cloned(),
BufferUsage::all(),
self.queue.clone(),
).unwrap().0,
);
}
}
}
/// Builds the descriptor set for solid colors using the input kernel (needs to support solid colors)
fn get_solid_color_descriptor_set(&self, kernel: Arc<GenericShader>) -> Box<dyn DescriptorSet + Send + Sync> {
let o: Box<dyn DescriptorSet + Send + Sync> = Box::new(
@@ -487,79 +385,58 @@ impl CanvasState {
o
}
/// Consume and allocated the canvas frame data to the GPU
pub fn allocate(&mut self, canvas_frame: CanvasFrameTest) -> CanvasFrameAllocation {
// This is taking in a canvas frame, which should be some sort of matrix of vertices of generic
// types and handles
pub fn draw_commands_test<VTypes: Into<VertexTypes>>(&mut self,
mut command_buffer: AutoCommandBufferBuilder,
framebuffers: Vec<Arc<dyn FramebufferAbstract + Send + Sync>>,
image_num: usize,
canvas_frame: CanvasFrameTest<VTypes>) -> AutoCommandBufferBuilder {
let mut colored_vertex_buffer: Vec<ColorVertex2D> = Vec::default();
let mut textured_vertex_buffer: HashMap<Arc<CanvasTextureHandle>, Vec<TextureVertex2D>> = HashMap::new();
let mut image_vertex_buffer: HashMap<Arc<CanvasImageHandle>, Vec<ImageVertex2D>> = HashMap::new();
let mut text_instances: HashMap<Arc<CanvasFontHandle>, Vec<TextVertex3D>> = HashMap::new();
// Specify the color to clear the framebuffer with i.e. blue
let clear_values = vec!(
ClearValue::Float([0.0, 0.0, 1.0, 1.0]),
ClearValue::DepthStencil((1.0, 0x00)),
);
self.dynamic_state = DynamicState {
line_width: None,
viewports: self.dynamic_state.viewports.clone(),
scissors: None,
compare_mask: None,
write_mask: None,
reference: None,
for value in canvas_frame.map {
match value {
VertexTypes::TextureType(vertices, handle) => {
textured_vertex_buffer.entry(handle).or_insert(vertices.clone()).extend(vertices);
}
VertexTypes::ImageType(vertices, handle) => {
image_vertex_buffer.entry(handle).or_insert(vertices.clone()).extend(vertices);
}
VertexTypes::ColorType(vertices) => {
colored_vertex_buffer.extend(vertices);
}
VertexTypes::ThreeDType(vertices) => {}
};
};
let mut command_buffer = command_buffer.begin_render_pass(
framebuffers[image_num].clone(), false, clear_values.clone(),
).unwrap();
for (k,v) in canvas_frame.map {
let buffer: Arc<(dyn BufferAccess + Send + Sync)> = match v.into() {
VertexTypes::TexturedType(vertices) => {
// Solid colors
let mut shader = self.shader_buffers.get(
self.get_shader_handle(String::from("color-passthrough"))
.unwrap().clone().get_handle() as usize
).unwrap();
let buffer = ImmutableBuffer::from_iter(
vertices.iter().cloned(),
let mut allocated_colored_buffer: Vec<Arc<(dyn BufferAccess + Send + Sync)>> = Vec::new();
if !colored_vertex_buffer.is_empty() {
allocated_colored_buffer.push(ImmutableBuffer::from_iter(
colored_vertex_buffer.iter().cloned(),
BufferUsage::vertex_buffer(),
self.queue.clone(),
).unwrap().0;
if !self.colored_vertex_buffer.is_empty() {
command_buffer = command_buffer.draw(
shader.get_pipeline().clone(),
&self.dynamic_state.clone(),
vec![buffer.clone()],
(), (),
).unwrap();
).unwrap().0);
}
buffer
},
VertexTypes::VType2(vertices) => {
CanvasFrameAllocation {
colored_vertex_buffer: allocated_colored_buffer,
textured_vertex_buffer: textured_vertex_buffer.into_iter().map(|(k, v)| {
(k,
ImmutableBuffer::from_iter(
vertices.iter().cloned(),
v.iter().cloned(),
BufferUsage::vertex_buffer(),
self.queue.clone(),
).unwrap().0
).unwrap().0 as Arc<(dyn BufferAccess + Send + Sync)>)
}).collect(),
image_vertex_buffer: image_vertex_buffer.into_iter().map(|(k, v)| {
(k,
ImmutableBuffer::from_iter(
v.iter().cloned(),
BufferUsage::vertex_buffer(),
self.queue.clone(),
).unwrap().0 as Arc<(dyn BufferAccess + Send + Sync)>)
}).collect(),
text_instances: Default::default(),
}
};
}
command_buffer
}
/// Pushes the draw commands to the command buffer. Requires the framebuffers and
@@ -567,7 +444,8 @@ impl CanvasState {
pub fn draw_commands(&mut self,
mut command_buffer: AutoCommandBufferBuilder,
framebuffers: Vec<Arc<dyn FramebufferAbstract + Send + Sync>>,
image_num: usize) -> AutoCommandBufferBuilder {
image_num: usize,
allocated_buffers: CanvasFrameAllocation) -> AutoCommandBufferBuilder {
// Specify the color to clear the framebuffer with i.e. blue
let clear_values = vec!(
@@ -597,11 +475,11 @@ impl CanvasState {
// This looks a little weird as colored_vertex_buffer is a vec of GPU allocated vecs.
// But we can pass in multiple vertex buffers
if !self.colored_vertex_buffer.is_empty() {
if allocated_buffers.colored_vertex_buffer.is_empty() {
command_buffer = command_buffer.draw(
shader.get_pipeline().clone(),
&self.dynamic_state.clone(),
self.colored_vertex_buffer.clone(),
allocated_buffers.colored_vertex_buffer.clone(),
(), (),
).unwrap();
}
@@ -612,8 +490,8 @@ impl CanvasState {
.unwrap().clone().get_handle() as usize
).unwrap();
if !self.image_vertex_buffer.is_empty() {
for (image_handle, vertex_buffer) in self.image_vertex_buffer.clone() {
if !allocated_buffers.image_vertex_buffer.is_empty() {
for (image_handle, vertex_buffer) in allocated_buffers.image_vertex_buffer.clone() {
let handle = image_handle.clone().get_handle() as usize;
let descriptor_set = self.image_buffers.get(handle).clone().unwrap().clone()
.get_descriptor_set(shader.get_pipeline().clone());
@@ -633,8 +511,8 @@ impl CanvasState {
.unwrap().clone().get_handle() as usize
).unwrap();
if !self.textured_vertex_buffer.is_empty() {
for (texture_handle, vertex_buffer) in self.textured_vertex_buffer.clone() {
if !allocated_buffers.textured_vertex_buffer.is_empty() {
for (texture_handle, vertex_buffer) in allocated_buffers.textured_vertex_buffer.clone() {
let handle = texture_handle.clone().get_handle() as usize;
let descriptor_set = self.texture_buffers.get(handle).clone().unwrap().clone()
.get_descriptor_set(shader.get_pipeline(), self.sampler.clone());

1
src/canvas/managed/canvas_text.rs
View File

@@ -10,7 +10,6 @@ use vulkano::format::ClearValue;
use vulkano::format::Format::R8Unorm;
use std::fs::File;
use std::io::Read;
use crate::util::vertex_3d::{Vertex3D, TextVertex3D};
//pub struct Glyph {}

9
src/canvas/managed/handles.rs
View File

@@ -3,6 +3,15 @@ pub trait Handle {
fn get_handle(&self) -> u32;
}
pub enum DrawableHandle {
Texture(CanvasTextureHandle),
Image(CanvasImageHandle),
Font(CanvasFontHandle),
}
/// Typed wrapper for a u32 handle
#[derive(Clone, Debug, Default, PartialEq, Eq, Hash)]
pub struct CanvasFontHandle {

1
src/canvas/managed/shader/generic_shader.rs
View File

@@ -11,7 +11,6 @@ use std::ffi::CStr;
use std::marker::PhantomData;
use vulkano::pipeline::depth_stencil::{DepthStencil, Compare, DepthBounds, Stencil, StencilOp};
use vulkano::pipeline::vertex::{SingleBufferDefinition, VertexDefinition};
use crate::util::vertex_3d::Vertex3D;
use shade_runner as sr;
use vulkano::memory::pool::PotentialDedicatedAllocation::Generic;
use vulkano::SafeDeref;

1
src/canvas/managed/shader/text_shader.rs
View File

@@ -10,7 +10,6 @@ use std::ffi::CStr;
use std::marker::PhantomData;
use vulkano::pipeline::depth_stencil::{DepthStencil, Compare, DepthBounds, Stencil, StencilOp};
use vulkano::pipeline::vertex::{SingleBufferDefinition, OneVertexOneInstanceDefinition};
use crate::util::vertex_3d::Vertex3D;
use shade_runner as sr;
use crate::canvas::managed::shader::shader_common::{ShaderType, CompiledGraphicsPipelineResources, CompiledGraphicsPipeline};
use crate::canvas::managed::handles::CompiledShaderHandle;

65
src/main.rs
View File

@@ -22,7 +22,6 @@ use sprite::Sprite;
use crate::util::load_raw;
use crate::sprite::{Poly, Text, TextHandle, TextVertex, TextInstance};
use vulkano::instance::debug::DebugCallback;
use crate::compute::compu_frame::CompuFrame;
use crate::canvas::canvas_frame::{CanvasFrame, CanvasFrameTest, DrawableTest};
@@ -30,6 +29,7 @@ use crate::compute::managed::compu_sprite::CompuSprite;
use std::sync::Arc;
use crate::canvas::managed::handles::{CanvasTextureHandle, Handle};
use crate::canvas::canvas_frame::dynhash::DynHash;
use crate::util::vertex::{VertexTypes, TextureVertex2D};
pub mod util;
@@ -57,48 +57,6 @@ pub mod compute;
*/
#[derive(Clone)]
pub struct TextureVertex2D {
pub v_position: [f32; 2],
pub ti_position: [f32; 2],
}
vulkano::impl_vertex!(TextureVertex2D, v_position, ti_position);
#[derive(Clone)]
pub struct ColorVertex2D {
pub v_position: [f32; 2],
pub color: [f32; 4],
}
vulkano::impl_vertex!(ColorVertex2D, v_position, color);
#[derive(Clone)]
pub struct ImageVertex2D {
pub v_position: [f32; 2],
pub color: [f32; 4],
}
vulkano::impl_vertex!(ImageVertex2D, v_position, color);
#[derive(Clone)]
pub enum VertexTypes {
TextureType(Vec<TextureVertex2D>),
ColorType(Vec<ColorVertex2D>),
ImageType(Vec<ImageVertex2D>),
}
pub struct DrawableTestee {
vertices: VertexTypes,
handle: Arc<CanvasTextureHandle>,
}
impl<VTypes: Into<VertexTypes>, H: Handle + DynHash> DrawableTest<VTypes, H> for DrawableTestee {
fn get_vertices(&self) -> VTypes {
unimplemented!()
}
fn get_handle(&self) -> H {
unimplemented!()
}
}
pub fn main() {
hprof::start_frame();
@@ -162,12 +120,12 @@ pub fn main() {
let sfml_handle = processor.get_texture_handle(String::from("sfml.png")).unwrap();
let font_handle = processor.get_font_handle(String::from("sansation.ttf")).unwrap();
let funky_sprite = Sprite::new_with_texture((0.0, -0.5), (0.5, 0.5), 0, funky_handle.clone());
let sfml_sprite = Sprite::new_with_texture((0.0, -0.5), (0.5, 0.5), 1, sfml_handle.clone());
let text_sprite = Text::new((-0.1,-0.1), (10.0, 10.0), font_handle.clone());
let funky_sprite = Sprite::new((0.0, -0.5), (0.5, 0.5), 0, funky_handle.clone());
let sfml_sprite = Sprite::new((0.0, -0.5), (0.5, 0.5), 1, sfml_handle.clone());
//let text_sprite = Text::new((-0.1,-0.1), (10.0, 10.0), font_handle.clone());
let test_polygon = Poly::new_with_color((-0.5, -0.5), (0.5, 0.5), 1, (1.0,0.0,0.0,0.0));
//let test_polygon = Poly::new_with_color((-0.5, -0.5), (0.5, 0.5), 1, (1.0,0.0,0.0,0.0));
drop(q2);
drop(q1);
@@ -226,17 +184,12 @@ pub fn main() {
break;
}
let sprite = Sprite::new((0.0,0.0), (0.0,0.0));
let dt = DrawableTestee {
vertices: VertexTypes::TexturedType(vec![ImplVertexData1 {x:0,y:0}]),
handle: Arc::new(CanvasTextureHandle{ handle: 0 })
};
let mut canvas_frame : CanvasFrameTest<VertexTypes> =
CanvasFrameTest{ map: Default::default() };
let funky_sprite = Sprite::new((0.0, -0.5), (0.5, 0.5), 0, funky_handle.clone());
canvas_frame.draw(dt.vertices);
canvas_frame.draw(sprite.get_vertices());
let mut canvas_frame = CanvasFrameTest::default();
canvas_frame.draw(&funky_sprite);
canvas_frame.draw(&sfml_sprite);
let mut compu_frame = CompuFrame::new();
// compu_frame.add(compute_buffer.clone(), compute_kernel.clone());

279
src/sprite.rs
View File

@@ -1,306 +1,45 @@
use std::sync::Arc;
use crate::util::vertex_3d::Vertex3D;
use crate::canvas::*;
use crate::canvas::managed::handles::{CanvasFontHandle, CanvasImageHandle, CanvasTextureHandle, Handle};
use crate::canvas::managed::shader::text_shader::GlyphInstance;
use crate::canvas::canvas_frame::{DrawableTest, Drawable};
use crate::{VertexTypes, ImplVertexData1};
use crate::canvas::canvas_frame::dynhash::DynHash;
use crate::util::vertex::{VertexTypes, TextureVertex2D, Vertex3D};
///
#[derive(Debug, Clone)]
pub struct Sprite {
pub verts: VertexTypes::TexturedType(vec![]),
pub vertices: [(f32, f32, f32); 6],
pub ti_position: [(f32, f32); 6],
pub verts: VertexTypes,
position: (f32, f32),
size: (f32, f32),
color: (f32, f32, f32, f32),
textured: bool,
texture_handle: Option<Arc<CanvasTextureHandle>>,
value: GlyphInstance,
}
/// Container class which implements drawable.
impl Sprite {
pub fn new(position: (f32, f32), size: (f32, f32)) -> Sprite {
Sprite::new_with_color(position, size, 0, (0., 0., 0., 0.))
}
pub fn new_with_color(position: (f32, f32),
size: (f32, f32),
depth: u32,
color: (f32, f32, f32, f32)) -> Sprite {
let normalized_depth = (depth as f32 / 255.0);
Sprite {
vertices: [
(position.0, position.1, normalized_depth), // top left
(position.0, position.1 + size.1, normalized_depth), // bottom left
(position.0 + size.0, position.1 + size.1, normalized_depth), // bottom right
(position.0, position.1, normalized_depth), // top left
(position.0 + size.0, position.1 + size.1, normalized_depth), // bottom right
(position.0 + size.0, position.1, normalized_depth), // top right
],
position: position,
ti_position: [
(-0.0, -0.0), // top left
(-0.0, 1.0), // bottom left
(1.0, 1.0), // bottom right
(-0.0, -0.0), // top left
(1.0, 1.0), // bottom right
(1.0, -0.0), // top right
],
size: size,
color: color,
textured: false,
texture_handle: None,
value: GlyphInstance {
screen_position: (0.0, 0.0),
atlas_position: (0.0, 0.0),
atlas_size: (0.0, 0.0),
scale: 0.0,
},
}
}
///
pub fn new_with_texture(position: (f32, f32),
pub fn new(position: (f32, f32),
size: (f32, f32),
depth: u32,
texture_handle: Arc<CanvasTextureHandle>) -> Sprite {
let normalized_depth = (depth as f32 / 255.0);
Sprite {
vertices: [
(position.0, position.1, normalized_depth), // top left
(position.0, position.1 + size.1, normalized_depth), // bottom left
(position.0 + size.0, position.1 + size.1, normalized_depth), // bottom right
(position.0, position.1, normalized_depth), // top left
(position.0 + size.0, position.1 + size.1, normalized_depth), // bottom right
(position.0 + size.0, position.1, normalized_depth), // top right
],
verts: VertexTypes::TextureType(Vec::new(), texture_handle),
position: position,
ti_position: [
(-0.0, -0.0), // top left
(-0.0, 1.0), // bottom left
(1.0, 1.0), // bottom right
(-0.0, -0.0), // top left
(1.0, 1.0), // bottom right
(1.0, -0.0), // top right
],
size: size,
color: (1.0, 0.0, 0.0, 1.0),
textured: true,
texture_handle: Some(texture_handle.clone()),
value: Default::default(),
}
}
}
impl DrawableTest for Sprite{
fn get(&self) -> VertexTypes {
self.verts.clone()
}
impl<V: Into<VertexTypes>, H: Handle + DynHash> DrawableTest<V, H> for Sprite{
fn get_vertices(&self) -> V {
VertexTypes::TexturedType(vec![ImplVertexData1{ x: 0, y: 0 }])
}
fn get_handle(&self) -> H {
self.texture_handle.unwrap()
}
}
impl Drawable for Sprite {
fn get_vertices(&self) -> Vec<(f32, f32, f32)> {
self.vertices.to_vec()
}
fn get_color(&self) -> (f32, f32, f32, f32) {
self.color.clone()
}
fn get_ti_coords(&self) -> Vec<(f32, f32)> {
self.ti_position.to_vec()
}
fn get_texture_handle(&self) -> Option<Arc<CanvasTextureHandle>> {
match self.textured {
true => {
self.texture_handle.clone()
}
false => None,
}
}
fn get_image_handle(&self) -> Option<Arc<CanvasImageHandle>> {
None
}
}
#[derive(Debug, Clone)]
pub struct Poly {
pub vertices: Vec<(f32, f32, f32)>,
pub ti_position: Vec<(f32, f32)>,
position: (f32, f32),
size: (f32, f32),
color: (f32, f32, f32, f32),
textured: bool,
texture_handle: Option<Arc<CanvasTextureHandle>>,
// ==================================
}
/// Container class which implements drawable.
impl Poly {
pub fn new(position: (f32, f32), size: (f32, f32)) -> Poly {
Poly::new_with_color(position, size, 0, (0., 0., 0., 0.))
}
pub fn new_with_color(position: (f32, f32),
size: (f32, f32),
depth: u32,
color: (f32, f32, f32, f32)) -> Poly {
let normalized_depth = (depth as f32 / 255.0);
Poly {
vertices: vec![
(-0.5, -0.5, normalized_depth),
(-1.0, 1.0, normalized_depth),
(-0.25, 0.0, normalized_depth),
(-0.25, 0.0, normalized_depth),
(-1.0, 1.0, normalized_depth),
(0.0, 0.5, normalized_depth),
(0.25, 0.0, normalized_depth),
(-1.0, 1.0, normalized_depth),
(0.0, 0.5, normalized_depth),
(0.5, -0.5, normalized_depth),
(-1.0, 1.0, normalized_depth),
(0.25, 0.0, normalized_depth),
(0.25, -0.5, normalized_depth),
(-1.0, 1.0, normalized_depth),
(0.5, -0.5, normalized_depth),
(0.25, -0.5, normalized_depth),
(-1.0, 1.0, normalized_depth),
(0.0, -0.1, normalized_depth),
(-0.25, -0.5, normalized_depth),
(-1.0, 1.0, normalized_depth),
(0.0, -0.1, normalized_depth),
(-0.5, -0.5, normalized_depth),
(-1.0, 1.0, normalized_depth),
(-0.25, -0.5, normalized_depth),
],
position: position,
ti_position: vec![
(0.0, 0.0),
(0.0, 0.0),
(0.0, 0.0),
(0.0, 0.0),
(0.0, 0.0),
(0.0, 0.0),
(0.0, 0.0),
(0.0, 0.0),
(0.0, 0.0),
(0.0, 0.0),
(0.0, 0.0),
(0.0, 0.0),
(0.0, 0.0),
(0.0, 0.0),
(0.0, 0.0),
(0.0, 0.0),
(0.0, 0.0),
(0.0, 0.0),
(0.0, 0.0),
(0.0, 0.0),
(0.0, 0.0),
(0.0, 0.0),
(0.0, 0.0),
(0.0, 0.0),
],
size: size,
color: color,
textured: false,
texture_handle: None,
}
}
}
impl Drawable for Poly {
fn get_vertices(&self) -> Vec<(f32, f32, f32)> {
self.vertices.to_vec()
}
fn get_color(&self) -> (f32, f32, f32, f32) {
self.color.clone()
}
fn get_ti_coords(&self) -> Vec<(f32, f32)> {
self.ti_position.to_vec()
}
fn get_texture_handle(&self) -> Option<Arc<CanvasTextureHandle>> {
match self.textured {
true => {
self.texture_handle.clone()
}
false => None,
}
}
fn get_image_handle(&self) -> Option<Arc<CanvasImageHandle>> {
None
}
}
#[derive(Debug, Clone)]
pub struct Text {
position: (f32, f32, f32),
scale: f32,
color: (f32, f32, f32, f32),
text_handle: Arc<CanvasFontHandle>,
}
/// Container class which implements drawable.
impl Text {
pub fn new(position: (f32, f32), size: (f32, f32), font_handle: Arc<CanvasFontHandle>) -> Text {
Text::new_with_color(position, size, 0, (0., 0., 0., 0.), font_handle)
}
pub fn new_with_color(position: (f32, f32),
size: (f32, f32),
depth: u32,
color: (f32, f32, f32, f32),
handle: Arc<CanvasFontHandle>) -> Text {
let normalized_depth = (depth as f32 / 255.0);
Text {
position: (position.0, position.1, normalized_depth),
scale: 0.0,
color,
text_handle: handle,
}
}
}
pub trait TextHandle {
fn do_nothing() -> u32;
}
pub trait TextInstance {
fn get_thing() -> Vec<(u32, u32, u32)>;
}
pub trait TextVertex {
fn get_vertices() -> Vec<(u32, u32, u32)>;
}

3
src/util/mod.rs
View File

@@ -4,8 +4,7 @@ use std::ffi::CStr;
use std::path::PathBuf;
pub mod timer;
pub mod vertex_2d;
pub mod vertex_3d;
pub mod vertex;
pub fn load_raw(filename: String) -> (Vec<u8>, (u32,u32)) {

78
src/util/vertex.rs Normal file
View File

@@ -0,0 +1,78 @@
use crate::canvas::managed::handles::{CanvasTextureHandle, CanvasImageHandle, CanvasFontHandle};
use std::sync::Arc;
use vulkano::buffer::BufferAccess;
use std::collections::HashMap;
#[derive(Default, Debug, Clone, Copy)]
pub struct TextureVertex2D {
pub v_position: [f32; 2],
pub ti_position: [f32; 2],
}
vulkano::impl_vertex!(TextureVertex2D, v_position, ti_position);
#[derive(Default, Debug, Clone, Copy)]
pub struct ColorVertex2D {
pub v_position: [f32; 2],
pub color: [f32; 4],
}
vulkano::impl_vertex!(ColorVertex2D, v_position, color);
#[derive(Default, Debug, Clone, Copy)]
pub struct ImageVertex2D {
pub v_position: [f32; 2],
pub color: [f32; 4],
}
vulkano::impl_vertex!(ImageVertex2D, v_position, color);
#[derive(Default, Debug, Clone, Copy)]
pub struct Vertex3D {
pub v_position: [f32; 3],
pub color : [f32; 4],
pub ti_position: [f32; 2],
}
vulkano::impl_vertex!(Vertex3D, v_position, color, ti_position);
/// Text vertex 3d with vertex position
#[derive(Default, Debug, Clone, Copy)]
pub struct TextVertex3D {
pub position: [f32; 3],
}
vulkano::impl_vertex!(TextVertex3D, position);
// ==============================================================================
#[derive(Debug, Clone)]
pub enum VertexTypes {
TextureType(Vec<TextureVertex2D>, Arc<CanvasTextureHandle>),
ImageType(Vec<ImageVertex2D>, Arc<CanvasImageHandle>),
ColorType(Vec<ColorVertex2D>),
ThreeDType(Vec<Vertex3D>),
}
#[derive(Clone)]
pub struct CanvasFrameAllocation {
pub colored_vertex_buffer: Vec<Arc<(dyn BufferAccess + Send + Sync)>>,
pub textured_vertex_buffer: HashMap<Arc<CanvasTextureHandle>, Arc<(dyn BufferAccess + Send + Sync)>>,
pub image_vertex_buffer: HashMap<Arc<CanvasImageHandle>, Arc<(dyn BufferAccess + Send + Sync)>>,
pub text_instances: HashMap<Arc<CanvasFontHandle>, Arc<(dyn BufferAccess + Send + Sync)>>,
}

10
src/util/vertex_2d.rs
View File

@@ -1,10 +0,0 @@
/// Generic vertex 2d with vertex position, texture position and a 32bit color
#[derive(Default, Debug, Clone, Copy)]
pub struct Vertex2D {
pub v_position: [f32; 2],
pub color : [f32; 4],
pub ti_position: [f32; 2],
}
vulkano::impl_vertex!(Vertex2D, v_position, color, ti_position);

20
src/util/vertex_3d.rs
View File

@@ -1,20 +0,0 @@
/// Generic vertex 3d with vertex position, texture position and a 32bit color
#[derive(Default, Debug, Clone, Copy)]
pub struct Vertex3D {
pub v_position: [f32; 3],
pub color : [f32; 4],
pub ti_position: [f32; 2],
}
vulkano::impl_vertex!(Vertex3D, v_position, color, ti_position);
/// Text vertex 3d with vertex position
#[derive(Default, Debug, Clone, Copy)]
pub struct TextVertex3D {
pub position: [f32; 3],
}
vulkano::impl_vertex!(TextVertex3D, position);

16
src/vkprocessor.rs
View File

@@ -15,13 +15,12 @@ use crate::canvas::canvas_frame::{CanvasFrame, CanvasFrameTest};
use std::time::Duration;
use vulkano::pipeline::depth_stencil::{DynamicStencilValue, StencilFaceFlags};
use vulkano::pipeline::vertex::{OneVertexOneInstanceDefinition, SingleBufferDefinition};
use crate::util::vertex_3d::Vertex3D;
use crate::canvas::canvas_state::CanvasState;
use crate::canvas::managed::shader::generic_shader::GenericShader;
use crate::canvas::managed::shader::text_shader::TextShader;
use crate::canvas::managed::handles::{CanvasTextureHandle, CompiledShaderHandle, CanvasFontHandle, CanvasImageHandle};
use crate::compute::managed::handles::{CompuKernelHandle, CompuBufferHandle};
use crate::{ImplVertexData1, VertexTypes};
use crate::util::vertex::VertexTypes;
/// VKProcessor holds the vulkan instance information, the swapchain,
@@ -224,10 +223,10 @@ impl<'a> VkProcessor<'a> {
}
///
pub fn run<VTypes: Into<VertexTypes>>(&mut self,
pub fn run(&mut self,
surface: &'a Arc<Surface<Window>>,
//canvas_frame: CanvasFrame,
canvas_frame: CanvasFrameTest<VTypes>,
canvas_frame: CanvasFrameTest,
compute_frame: CompuFrame,
) {
@@ -266,13 +265,12 @@ impl<'a> VkProcessor<'a> {
drop(g);
{
let allocated_buffers = {
// take the canvas frame and create the vertex buffers
// TODO: This performs gpu buffer creation. Shouldn't be in hotpath??
let g = hprof::enter("Canvas creates GPU buffers");
//self.canvas_state.draw(canvas_frame);
}
self.canvas_state.allocate(canvas_frame)
};
let mut command_buffer =
AutoCommandBufferBuilder::primary_one_time_submit(self.device.clone(), self.queue.family()).unwrap();
@@ -287,7 +285,7 @@ impl<'a> VkProcessor<'a> {
// Add the draw commands
//let mut command_buffer = self.canvas_state.draw_commands(command_buffer, framebuffers, image_num);
let mut command_buffer =
self.canvas_state.draw_commands_test(command_buffer, framebuffers, image_num, canvas_frame);
self.canvas_state.draw_commands(command_buffer, framebuffers, image_num, allocated_buffers);
// And build
let command_buffer = command_buffer.build().unwrap();