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

Revert "adding 3d sprites"

Browse Source 
This reverts commit 8c84c08f7e.
master
mitchellhansen 5 years ago
parent 8c84c08f7e
commit 77b781df1a
8 changed files with 55 additions and 2263 deletions
Show Stats Download Patch File Download Diff File

3
notes/VKProcessor/CanvasContainerClasses.txt
Unescape View File

@ -11,8 +11,7 @@ The Canvas needs to package certain buffers along with their metadata. These tak
All buffers will have a coupled handle type stored in [[/src/canvas/managed/handles.rs|handles.rs]] and a reference to that handle
==== Todo ====
Need to pull out the persistent descriptor set **build **command after adding it's self.

103
src/canvas/canvas_state.rs
Unescape View File

@ -1,6 +1,6 @@
use vulkano::command_buffer::{AutoCommandBufferBuilder, DynamicState};
use std::collections::{HashMap, HashSet};
use vulkano::buffer::{BufferAccess, BufferUsage, ImmutableBuffer, CpuAccessibleBuffer, CpuBufferPool};
use vulkano::buffer::{BufferAccess, BufferUsage, ImmutableBuffer, CpuAccessibleBuffer};
use std::sync::Arc;
use vulkano::format::{ClearValue, Format, R8Unorm, ClearValuesTuple};
use vulkano::framebuffer::{FramebufferAbstract, Framebuffer, RenderPass, RenderPassAbstract};
@ -28,8 +28,8 @@ use std::io::Read;
use rusttype::{Font, PositionedGlyph, Scale, Rect, point, GlyphId, Line, Curve, Segment};
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, CanvasUniformHandle};
use crate::canvas::managed::gpu_buffers::{CanvasImage, CanvasTexture, CanvasFont, CanvasUniform};
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::CompiledShader;
use crate::canvas::managed::shader::generic_shader::GenericShader;
use crate::VertexTypes;
@ -50,7 +50,6 @@ pub struct CanvasState {
image_buffers: Vec<Arc<CanvasImage>>,
texture_buffers: Vec<Arc<CanvasTexture>>,
font_buffers: Vec<Arc<CanvasFont>>,
uniform_buffers: Vec<Arc<CanvasUniform>>,
/// Compiled Graphics pipelines have a handle which self describe their position in this vector
shader_buffers: Vec<Arc<Box<dyn CompiledShader>>>,
@ -162,8 +161,6 @@ impl CanvasState {
shader_buffers: vec![],
font_buffers: vec![],
uniform_buffer: CpuBufferPool::new(device.clone(), BufferUsage::all()),
queue: queue.clone(),
device: device.clone(),
render_pass: render_pass.clone(),
@ -255,24 +252,6 @@ impl CanvasState {
Some(handle)
}
/// Load a texture using it's filename from a file. Returns the handle of the loaded texture
pub fn load_buffer_pool(&mut self) -> Option<Arc<CanvasTextureHandle>> {
let handle = Arc::new(CanvasUniformHandle {
handle: self.uniform_buffers.len() as u32
});
let texture = Arc::new(CanvasUniform {
handle: handle.clone(),
buffer: self.get_texture_from_file(filename.clone()),
name: filename.clone(),
});
self.texture_buffers.push(texture);
Some(handle)
}
/// Load and Compile a shader with the filename at resources/shaders
/// Takes physical and capabilities as we don't store that in Canvas
pub fn load_shader<T: 'static, V>(&mut self,
@ -563,11 +542,58 @@ 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();
//
// self.dynamic_state = DynamicState {
// line_width: None,
// viewports: self.dynamic_state.viewports.clone(),
// scissors: None,
// compare_mask: Some(DynamicStencilValue {
// face: StencilFaceFlags::StencilFrontAndBack,
// value: 0x00,
// }),
// write_mask: Some(DynamicStencilValue {
// face: StencilFaceFlags::StencilFrontAndBack,
// value: 0xFF,
// }),
// reference: Some(DynamicStencilValue {
// face: StencilFaceFlags::StencilFrontAndBack,
// value: 0x00,
// }),
// };
//
// if !allocated_buffers.text_vertex_buffer.is_empty() {
// command_buffer = command_buffer.draw(
// shader.get_pipeline().clone(),
// &self.dynamic_state.clone(),
// allocated_buffers.text_vertex_buffer.clone(),
// (), (),
// ).unwrap();
// }
//
// self.dynamic_state = DynamicState {
// line_width: None,
// viewports: self.dynamic_state.viewports.clone(),
// scissors: None,
// compare_mask: Some(DynamicStencilValue {
// face: StencilFaceFlags::StencilFrontAndBack,
// value: 0xFF,
// }),
// write_mask: Some(DynamicStencilValue {
// face: StencilFaceFlags::StencilFrontAndBack,
// value: 0x00,
// }),
// reference: Some(DynamicStencilValue {
// face: StencilFaceFlags::StencilFrontAndBack,
// value: 0x00,
// }),
// };
if !allocated_buffers.text_vertex_buffer.is_empty() {
command_buffer = command_buffer.draw(
@ -578,35 +604,6 @@ impl CanvasState {
).unwrap();
}
// So I need a uniform buffer which is the transformation matrix for the camera I think...
// I also need two buffers, one for normals, one for vertices. These can be piped through the
// current interfaces by just adding another type to VertexTypes
//
// 3D
let mut shader = self.shader_buffers.get(
self.get_shader_handle(String::from("simple_3d"))
.unwrap().clone().get_handle() as usize
).unwrap();
// The other modules get the descriptor set like this
// let descriptor_set = self.texture_buffers.get(handle).clone().unwrap().clone()
// .get_descriptor_set(shader.get_pipeline(), self.sampler.clone());
//
// let set = Arc::new(
// PersistentDescriptorSet::start(layout.clone()) //
// .add_buffer(uniform_buffer_subbuffer).unwrap()
// .build().unwrap()
// );
// if !allocated_buffers.text_vertex_buffer.is_empty() {
// command_buffer = command_buffer.draw_indexed(
// shader.get_pipeline().clone(),
// &self.dynamic_state.clone(),
// vec!(vertex_buffer.clone(), normals_buffer.clone()),
// index_buffer.clone(), set.clone(), ()
// ).unwrap();
// }
command_buffer
.end_render_pass()

27
src/canvas/managed/gpu_buffers.rs
Unescape View File

@ -4,35 +4,12 @@ use vulkano::format::{Format, R8Unorm};
use vulkano::sampler::Sampler;
use vulkano::descriptor::DescriptorSet;
use vulkano::descriptor::descriptor_set::PersistentDescriptorSet;
use vulkano::buffer::{CpuAccessibleBuffer, BufferAccess, CpuBufferPool};
use vulkano::buffer::{CpuAccessibleBuffer, BufferAccess};
use vulkano::pipeline::GraphicsPipelineAbstract;
use rusttype::Font;
use crate::canvas::managed::handles::{CanvasTextureHandle, CanvasImageHandle, CanvasFontHandle, CanvasUniformHandle};
use crate::canvas::managed::handles::{CanvasTextureHandle, CanvasImageHandle, CanvasFontHandle};
/// Canvas buffer which represents an allocated Texture with a key and dimensions
#[derive(Clone)]
pub struct CanvasUniform {
pub(crate) handle: Arc<CanvasUniformHandle>,
pub(crate) buffer: Arc<CpuBufferPool<>>,
pub(crate) name: String,
}
impl CanvasUniform {
pub fn get_descriptor_set(&self,
pipeline: Arc<dyn GraphicsPipelineAbstract + Sync + Send>,
data: Arc<Format>) -> Box<dyn DescriptorSet + Send + Sync> {
let o: Box<dyn DescriptorSet + Send + Sync> = Box::new(
PersistentDescriptorSet::start(
pipeline.clone(), 0,
)
.add_buffer(self.buffer.next(data).unwrap()).unwrap()
.build().unwrap());
o
}
}
/// Canvas buffer which represents an allocated Texture with a key and dimensions
#[derive(Clone)]
pub struct CanvasTexture {

12
src/canvas/managed/handles.rs
Unescape View File

@ -1,4 +1,3 @@
use crate::canvas::managed::gpu_buffers::CanvasUniform;
pub trait Handle {
fn get_handle(&self) -> u32;
@ -58,15 +57,4 @@ impl Handle for CompiledShaderHandle {
}
}
/// Typed wrapper for a u32 handle
#[derive(Clone, Debug, Default, PartialEq, Eq, Hash)]
pub struct CanvasUniformHandle {
pub(in crate::canvas) handle: u32
}
impl Handle for CanvasUniformHandle {
fn get_handle(&self) -> u32 {
self.handle
}
}

1
src/canvas/managed/mod.rs
Unescape View File

@ -3,7 +3,6 @@ pub mod shader;
pub mod handles;
pub mod canvas_text;
pub mod gpu_buffers;
pub mod teapot_data;
use vulkano::pipeline::shader::{SpecializationConstants, SpecializationMapEntry};

2111
src/canvas/managed/teapot_data.rs
View File

File diff suppressed because it is too large Load Diff

57
src/drawables/teapot.rs
Unescape View File

@ -1,57 +0,0 @@
use crate::canvas::canvas_frame::Drawable;
use crate::util::vertex::{VertexTypes, ColorVertex3D};
///
#[derive(Debug, Clone)]
pub struct Teapot {
pub verts: VertexTypes,
position: (f32, f32),
size: (f32, f32),
}
/// Container class which implements drawable.
impl Teapot {
///
pub fn new(position: (f32, f32),
size: (f32, f32),
depth: u32) -> Teapot {
let normalized_depth = (depth as f32 / 255.0);
let verts = vec![
ColorVertex3D{
v_position: [position.0, position.1, normalized_depth], // top left
color: [0.0, 1.0, 1.0, 0.5] },
ColorVertex3D{
v_position: [position.0, position.1 + size.1, normalized_depth], // bottom left
color: [1.0, 1.0, 1.0, 1.0] },
ColorVertex3D{
v_position: [position.0 + size.0, position.1 + size.1, normalized_depth], // bottom right
color: [1.0, 1.0, 1.0, 1.0] },
ColorVertex3D{
v_position: [position.0, position.1, normalized_depth], // top left
color: [1.0, 1.0, 1.0, 1.0] },
ColorVertex3D{
v_position: [position.0 + size.0, position.1 + size.1, normalized_depth], // bottom right
color: [1.0, 1.0, 1.0, 1.0] },
ColorVertex3D{
v_position: [position.0 + size.0, position.1, normalized_depth], // top right
color: [1.0, 1.0, 1.0, 1.0] },
];
Teapot {
verts: VertexTypes::ColorType(verts),
position: position,
size: size,
}
}
}
impl Drawable for Teapot {
fn get(&self) -> VertexTypes {
self.verts.clone()
}
}

4
src/main.rs
Unescape View File

@ -112,7 +112,7 @@ pub fn main() {
//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), 1);
let text_sprite = Text::new((-0.1,-0.1), (10.0, 10.0), 1);
//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);
@ -174,7 +174,7 @@ pub fn main() {
let mut canvas_frame = CanvasFrame::default();
canvas_frame.draw(&funky_sprite);
// canvas_frame.draw(&text_sprite);
canvas_frame.draw(&text_sprite);
// canvas_frame.draw(&rect);
let mut compu_frame = CompuFrame::new();

Write Preview
Loading…
Cancel
Save