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

compiles and renders textures again

Browse Source
This commit is contained in:
mitchellhansen
2020-02-20 23:55:36 -08:00
parent d1051a0ca3
commit 438f96eb32
16 changed files with 110 additions and 89 deletions
Download Patch File Download Diff File Expand all files Collapse all files

26
src/canvas/canvas_state.rs
View File

@@ -30,10 +30,10 @@ use vulkano::pipeline::vertex::{VertexDefinition, Vertex};
use crate::canvas::managed::shader::dynamic_vertex::RuntimeVertexDef;
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::shader_common::CompiledShader;
use crate::canvas::managed::shader::generic_shader::GenericShader;
use crate::VertexTypes;
use crate::util::vertex::{TextVertex3D, TextureVertex2D, ImageVertex2D, ColorVertex2D, CanvasFrameAllocation};
use crate::util::vertex::{TextVertex3D, TextureVertex3D, ImageVertex3D, ColorVertex3D, CanvasFrameAllocation};
use shade_runner::Input;
@@ -52,7 +52,7 @@ pub struct CanvasState {
font_buffers: Vec<Arc<CanvasFont>>,
/// Compiled Graphics pipelines have a handle which self describe their position in this vector
shader_buffers: Vec<Arc<Box<dyn CompiledGraphicsPipeline>>>,
shader_buffers: Vec<Arc<Box<dyn CompiledShader>>>,
/// Looks like we gotta hold onto the queue for managing textures
queue: Arc<Queue>,
@@ -260,13 +260,13 @@ impl CanvasState {
filename: String,
physical: PhysicalDevice,
capabilities: Capabilities) -> Option<Arc<CompiledShaderHandle>>
where T: CompiledGraphicsPipeline, V: Vertex {
where T: CompiledShader, V: Vertex {
let handle = Arc::new(CompiledShaderHandle {
handle: self.shader_buffers.len() as u32
});
let shader: Box<dyn CompiledGraphicsPipeline> = Box::new(T::new::<V>(
let shader: Box<dyn CompiledShader> = Box::new(T::new::<V>(
filename.clone(),
self.device.clone(),
handle.clone(),
@@ -390,9 +390,9 @@ impl CanvasState {
/// Consume and allocate the canvas frame data to the GPU
pub fn allocate(&mut self, canvas_frame: CanvasFrame) -> CanvasFrameAllocation {
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 colored_vertex_buffer: Vec<ColorVertex3D> = Vec::default();
let mut textured_vertex_buffer: HashMap<Arc<CanvasTextureHandle>, Vec<TextureVertex3D>> = HashMap::new();
let mut image_vertex_buffer: HashMap<Arc<CanvasImageHandle>, Vec<ImageVertex3D>> = HashMap::new();
let mut text_instances: HashMap<Arc<CanvasFontHandle>, Vec<TextVertex3D>> = HashMap::new();
for value in canvas_frame.map {
@@ -477,7 +477,7 @@ 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 allocated_buffers.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(),
@@ -529,10 +529,10 @@ impl CanvasState {
}
// Text
let mut shader = self.shader_buffers.get(
self.get_shader_handle(String::from("simple_text"))
.unwrap().clone().get_handle() as usize
).unwrap();
// let mut shader = self.shader_buffers.get(
// self.get_shader_handle(String::from("simple_text"))
// .unwrap().clone().get_handle() as usize
// ).unwrap();
//
// if !self.text_instances.is_empty() {

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

@@ -3,15 +3,12 @@ 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 {

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

@@ -14,11 +14,11 @@ use vulkano::pipeline::vertex::{SingleBufferDefinition, VertexDefinition, Vertex
use shade_runner as sr;
use vulkano::memory::pool::PotentialDedicatedAllocation::Generic;
use vulkano::SafeDeref;
use crate::canvas::managed::shader::shader_common::{ShaderType, CompiledGraphicsPipelineResources, CompiledGraphicsPipeline};
use crate::canvas::managed::shader::shader_common::{ShaderType, CompiledShaderResources, CompiledShader};
use crate::canvas::managed::handles::CompiledShaderHandle;
use crate::canvas::managed::shader::dynamic_vertex::RuntimeVertexDef;
use crate::canvas::managed::ShaderSpecializationConstants;
use crate::util::vertex::{VertexTypes, ColorVertex2D};
use crate::util::vertex::{VertexTypes, ColorVertex3D};
/// CanvasShader holds the pipeline and render pass for the input shader source
#[derive(Clone)]
@@ -37,10 +37,10 @@ impl GenericShader {
}
/// Gives CanvasShader the resource functions
impl CompiledGraphicsPipelineResources for GenericShader {}
impl CompiledShaderResources for GenericShader {}
/// Convenience interface so we don't have to juggle shader types
impl CompiledGraphicsPipeline for GenericShader {
impl CompiledShader for GenericShader {
/// This will explode when the shader does not want to compile
fn new<V: Vertex>(filename: String,

4
src/canvas/managed/shader/shader_common.rs
View File

@@ -29,7 +29,7 @@ This best works I think if I allow users to
/// Inheriting this gives private functions to grab resources
pub trait CompiledGraphicsPipelineResources {
pub trait CompiledShaderResources {
fn get_path(filename: String, shader_type: ShaderType) -> PathBuf {
let project_root =
@@ -100,7 +100,7 @@ pub trait CompiledGraphicsPipelineResources {
pub trait CompiledGraphicsPipeline {
pub trait CompiledShader {
fn new<V>(filename: String,
device: Arc<Device>,
handle: Arc<CompiledShaderHandle>,

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

@@ -11,12 +11,12 @@ use std::marker::PhantomData;
use vulkano::pipeline::depth_stencil::{DepthStencil, Compare, DepthBounds, Stencil, StencilOp};
use vulkano::pipeline::vertex::{SingleBufferDefinition, OneVertexOneInstanceDefinition, Vertex};
use shade_runner as sr;
use crate::canvas::managed::shader::shader_common::{ShaderType, CompiledGraphicsPipelineResources, CompiledGraphicsPipeline};
use crate::canvas::managed::shader::shader_common::{ShaderType, CompiledShaderResources, CompiledShader};
use crate::canvas::managed::handles::CompiledShaderHandle;
use crate::canvas::managed::shader::generic_shader::GenericShader;
use crate::canvas::managed::shader::dynamic_vertex::RuntimeVertexDef;
use crate::canvas::managed::ShaderSpecializationConstants;
use crate::util::vertex::ColorVertex2D;
use crate::util::vertex::ColorVertex3D;
/// CanvasShader holds the pipeline and render pass for the input shader source
@@ -34,10 +34,10 @@ pub struct TextShader {
impl TextShader {}
/// Gives CanvasShader the resource functions
impl CompiledGraphicsPipelineResources for TextShader {}
impl CompiledShaderResources for TextShader {}
/// Convenience interface so we don't have to juggle shader types
impl CompiledGraphicsPipeline for TextShader {
impl CompiledShader for TextShader {
/// This will explode when the shader does not want to compile
fn new<V: Vertex>(filename: String,

40
src/main.rs
View File

@@ -27,8 +27,9 @@ use crate::compute::compu_frame::CompuFrame;
use crate::canvas::canvas_frame::{CanvasFrame, Drawable};
use crate::compute::managed::compu_sprite::CompuSprite;
use std::sync::Arc;
use crate::canvas::managed::handles::{CanvasTextureHandle, Handle};
use crate::util::vertex::{VertexTypes, TextureVertex2D};
use crate::canvas::managed::handles::{CanvasTextureHandle, Handle, CanvasFontHandle};
use crate::util::vertex::{VertexTypes, TextureVertex3D};
use crate::compute::managed::handles::{CompuBufferHandle, CompuKernelHandle};
pub mod util;
@@ -89,13 +90,11 @@ pub fn main() {
processor.preload_fonts();
}
let q2 = hprof::enter("Game Objects");
let mut timer = Timer::new();
let mut frame_future = Box::new(sync::now(processor.device.clone())) as Box<dyn GpuFuture>;
let mut frame_future : Box<dyn GpuFuture> =
Box::new(sync::now(processor.device.clone())) as Box<dyn GpuFuture>;
let step_size: f32 = 0.005;
let mut elapsed_time: f32;
@@ -104,26 +103,31 @@ pub fn main() {
let mut current_time: f32 = timer.elap_time();
let image_data = load_raw(String::from("funky-bird.jpg"));
let image_dimensions_f = ((image_data.1).0 as f32, (image_data.1).1 as f32);
let image_dimensions_u = image_data.1;
let compu_sprite1 = CompuSprite::new((0.0, -0.5), (0.4, 0.4), 0, image_dimensions_f,
// This swap image needs to match the size of the compute
processor.new_swap_image(image_dimensions_u));
let image_dimensions_f : (f32, f32) = ((image_data.1).0 as f32, (image_data.1).1 as f32);
let image_dimensions_u : (u32, u32) = image_data.1;
let compu_sprite1 : CompuSprite =
CompuSprite::new((0.0, -0.5), (0.4, 0.4), 0, image_dimensions_f,
// Swap image to render the result to. Must match dimensions
processor.new_swap_image(image_dimensions_u));
let compute_buffer = processor.new_compute_buffer(image_data.0, image_data.1, 4);
let compute_buffer : Arc<CompuBufferHandle> =
processor.new_compute_buffer(image_data.0, image_data.1, 4);
let compute_kernel = processor.get_kernel_handle(String::from("simple-edge.compute"))
let compute_kernel : Arc<CompuKernelHandle> =
processor.get_kernel_handle(String::from("simple-edge.compute"))
.expect("Can't find that kernel");
let funky_handle = processor.get_texture_handle(String::from("funky-bird.jpg")).unwrap();
let sfml_handle = processor.get_texture_handle(String::from("sfml.png")).unwrap();
let font_handle = processor.get_font_handle(String::from("sansation.ttf")).unwrap();
// Get the handles for the assets
let funky_handle : Arc<CanvasTextureHandle> =
processor.get_texture_handle(String::from("funky-bird.jpg")).unwrap();
let sfml_handle : Arc<CanvasTextureHandle> =
processor.get_texture_handle(String::from("sfml.png")).unwrap();
let font_handle : Arc<CanvasFontHandle> =
processor.get_font_handle(String::from("sansation.ttf")).unwrap();
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));
drop(q2);

25
src/sprite.rs
View File

@@ -2,7 +2,7 @@ use std::sync::Arc;
use crate::canvas::*;
use crate::canvas::managed::handles::{CanvasFontHandle, CanvasImageHandle, CanvasTextureHandle, Handle};
use crate::canvas::canvas_frame::{Drawable};
use crate::util::vertex::{VertexTypes, TextureVertex2D, Vertex3D};
use crate::util::vertex::{VertexTypes, TextureVertex3D, Vertex3D};
///
#[derive(Debug, Clone)]
@@ -25,8 +25,29 @@ impl Sprite {
let normalized_depth = (depth as f32 / 255.0);
let verts = vec![
TextureVertex3D{
v_position: [position.0, position.1, normalized_depth], // top left
ti_position: [-0.0, -0.0] },
TextureVertex3D{
v_position: [position.0, position.1 + size.1, normalized_depth], // bottom left
ti_position: [-0.0, 1.0] },
TextureVertex3D{
v_position: [position.0 + size.0, position.1 + size.1, normalized_depth], // bottom right
ti_position: [1.0, 1.0] },
TextureVertex3D{
v_position: [position.0, position.1, normalized_depth], // top left
ti_position: [-0.0, -0.0] },
TextureVertex3D{
v_position: [position.0 + size.0, position.1 + size.1, normalized_depth], // bottom right
ti_position: [1.0, 1.0] },
TextureVertex3D{
v_position: [position.0 + size.0, position.1, normalized_depth], // top right
ti_position: [1.0, -0.0] },
];
Sprite {
verts: VertexTypes::TextureType(Vec::new(), texture_handle),
verts: VertexTypes::TextureType(verts, texture_handle),
position: position,
size: size,
}

26
src/util/vertex.rs
View File

@@ -4,25 +4,25 @@ use vulkano::buffer::BufferAccess;
use std::collections::HashMap;
#[derive(Default, Debug, Clone, Copy)]
pub struct TextureVertex2D {
pub v_position: [f32; 2],
pub struct TextureVertex3D {
pub v_position: [f32; 3],
pub ti_position: [f32; 2],
}
vulkano::impl_vertex!(TextureVertex2D, v_position, ti_position);
vulkano::impl_vertex!(TextureVertex3D, v_position, ti_position);
#[derive(Default, Debug, Clone, Copy)]
pub struct ColorVertex2D {
pub v_position: [f32; 2],
pub struct ColorVertex3D {
pub v_position: [f32; 3],
pub color: [f32; 4],
}
vulkano::impl_vertex!(ColorVertex2D, v_position, color);
vulkano::impl_vertex!(ColorVertex3D, v_position, color);
#[derive(Default, Debug, Clone, Copy)]
pub struct ImageVertex2D {
pub v_position: [f32; 2],
pub color: [f32; 4],
pub struct ImageVertex3D {
pub v_position: [f32; 3],
pub ti_position: [f32; 2],
}
vulkano::impl_vertex!(ImageVertex2D, v_position, color);
vulkano::impl_vertex!(ImageVertex3D, v_position, ti_position);
#[derive(Default, Debug, Clone, Copy)]
pub struct Vertex3D {
@@ -52,9 +52,9 @@ vulkano::impl_vertex!(GlyphInstance, screen_position, atlas_position, atlas_size
#[derive(Debug, Clone)]
pub enum VertexTypes {
TextureType(Vec<TextureVertex2D>, Arc<CanvasTextureHandle>),
ImageType(Vec<ImageVertex2D>, Arc<CanvasImageHandle>),
ColorType(Vec<ColorVertex2D>),
TextureType(Vec<TextureVertex3D>, Arc<CanvasTextureHandle>),
ImageType(Vec<ImageVertex3D>, Arc<CanvasImageHandle>),
ColorType(Vec<ColorVertex3D>),
ThreeDType(Vec<Vertex3D>),
}

10
src/vkprocessor.rs
View File

@@ -20,7 +20,7 @@ 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::util::vertex::{VertexTypes, ColorVertex2D, TextVertex3D, TextureVertex2D, ImageVertex2D};
use crate::util::vertex::{VertexTypes, ColorVertex3D, TextVertex3D, TextureVertex3D, ImageVertex3D};
/// VKProcessor holds the vulkan instance information, the swapchain,
@@ -168,10 +168,10 @@ impl<'a> VkProcessor<'a> {
/// A hardcoded list of shaders which can be preloaded from this function
pub fn preload_shaders(&mut self) {
self.canvas_state.load_shader::<GenericShader, ColorVertex2D>(String::from("color-passthrough"), self.physical.clone(), self.capabilities.clone());
self.canvas_state.load_shader::<GenericShader, TextureVertex2D>(String::from("simple_texture"), self.physical.clone(), self.capabilities.clone());
self.canvas_state.load_shader::<GenericShader, ImageVertex2D>(String::from("simple_image"), self.physical.clone(), self.capabilities.clone());
self.canvas_state.load_shader::<TextShader, TextVertex3D>(String::from("simple_text"), self.physical.clone(), self.capabilities.clone());
self.canvas_state.load_shader::<GenericShader, ColorVertex3D>(String::from("color-passthrough"), self.physical.clone(), self.capabilities.clone());
self.canvas_state.load_shader::<GenericShader, TextureVertex3D>(String::from("simple_texture"), self.physical.clone(), self.capabilities.clone());
self.canvas_state.load_shader::<GenericShader, ImageVertex3D>(String::from("simple_image"), self.physical.clone(), self.capabilities.clone());
// self.canvas_state.load_shader::<TextShader, TextVertex3D>(String::from("simple_text"), self.physical.clone(), self.capabilities.clone());
}
/// A hardcoded list of shaders which can be proloaded from this function