Mirrors/bevy
2
0
Fork 0
mirror of https://github.com/bevyengine/bevy synced 2024-11-22 04:33:37 +00:00
Code Issues Projects Releases Packages Wiki Activity

initial texture support

Browse source
This commit is contained in:
Carter Anderson 2020-02-05 17:50:56 -08:00
parent 6d0661d299
commit 8c831845f9
7 changed files with 153 additions and 52 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

47
src/render/render_graph_2/passes/forward.rs
View file

@ -1,9 +1,7 @@
use crate::render::{
render_graph_2::{
resource_name, PassDescriptor,
RenderGraphBuilder, RenderPassColorAttachmentDescriptor,
},
};
use crate::render::render_graph_2::{
resource_name, PassDescriptor, RenderGraphBuilder, RenderPassColorAttachmentDescriptor,
RenderPassDepthStencilAttachmentDescriptor, TextureDescriptor, TextureDimension,
};
pub trait ForwardPassBuilder {
fn add_forward_pass(self) -> Self;
@ -11,7 +9,23 @@ pub trait ForwardPassBuilder {
impl ForwardPassBuilder for RenderGraphBuilder {
fn add_forward_pass(self) -> Self {
self.add_pass(
self.add_texture(
resource_name::texture::DEPTH,
TextureDescriptor {
size: wgpu::Extent3d {
depth: 1,
width: 2560,
height: 1440,
},
array_layer_count: 1,
mip_level_count: 1,
sample_count: 1,
dimension: TextureDimension::D2,
format: wgpu::TextureFormat::Depth32Float,
usage: wgpu::TextureUsage::OUTPUT_ATTACHMENT,
},
)
.add_pass(
"main",
PassDescriptor {
color_attachments: vec![RenderPassColorAttachmentDescriptor {
@ -26,16 +40,15 @@ impl ForwardPassBuilder for RenderGraphBuilder {
a: 1.0,
},
}],
depth_stencil_attachment: None,
// depth_stencil_attachment: Some(RenderPassDepthStencilAttachmentDescriptor {
// attachment: "forward_depth".to_string(),
// depth_load_op: wgpu::LoadOp::Clear,
// depth_store_op: wgpu::StoreOp::Store,
// stencil_load_op: wgpu::LoadOp::Clear,
// stencil_store_op: wgpu::StoreOp::Store,
// clear_depth: 1.0,
// clear_stencil: 0,
// }),
depth_stencil_attachment: Some(RenderPassDepthStencilAttachmentDescriptor {
attachment: resource_name::texture::DEPTH.to_string(),
depth_load_op: wgpu::LoadOp::Clear,
depth_store_op: wgpu::StoreOp::Store,
stencil_load_op: wgpu::LoadOp::Clear,
stencil_store_op: wgpu::StoreOp::Store,
clear_depth: 1.0,
clear_stencil: 0,
}),
sample_count: 1,
},
)

60
src/render/render_graph_2/pipeline_layout.rs
View file

@ -59,10 +59,10 @@ pub enum BindType {
Sampler,
SampledTexture {
multisampled: bool,
dimension: TextureDimension,
dimension: TextureViewDimension,
},
StorageTexture {
dimension: TextureDimension,
dimension: TextureViewDimension,
},
}
@ -117,7 +117,7 @@ impl UniformPropertyType {
}
#[derive(Copy, Clone, Hash)]
pub enum TextureDimension {
pub enum TextureViewDimension {
D1,
D2,
D2Array,
@ -125,3 +125,57 @@ pub enum TextureDimension {
CubeArray,
D3,
}
impl From<TextureViewDimension> for wgpu::TextureViewDimension {
fn from(dimension: TextureViewDimension) -> Self {
match dimension {
TextureViewDimension::D1 => wgpu::TextureViewDimension::D1,
TextureViewDimension::D2 => wgpu::TextureViewDimension::D2,
TextureViewDimension::D2Array => wgpu::TextureViewDimension::D2Array,
TextureViewDimension::Cube => wgpu::TextureViewDimension::Cube,
TextureViewDimension::CubeArray => wgpu::TextureViewDimension::CubeArray,
TextureViewDimension::D3 => wgpu::TextureViewDimension::D3,
}
}
}
#[derive(Copy, Clone, Hash)]
pub enum TextureDimension {
D1,
D2,
D3,
}
impl From<TextureDimension> for wgpu::TextureDimension {
fn from(dimension: TextureDimension) -> Self {
match dimension {
TextureDimension::D1 => wgpu::TextureDimension::D1,
TextureDimension::D2 => wgpu::TextureDimension::D2,
TextureDimension::D3 => wgpu::TextureDimension::D3,
}
}
}
pub struct TextureDescriptor {
pub size: wgpu::Extent3d,
pub array_layer_count: u32,
pub mip_level_count: u32,
pub sample_count: u32,
pub dimension: TextureDimension,
pub format: wgpu::TextureFormat,
pub usage: wgpu::TextureUsage,
}
impl From<TextureDescriptor> for wgpu::TextureDescriptor {
fn from(texture_descriptor: TextureDescriptor) -> Self {
wgpu::TextureDescriptor {
size: texture_descriptor.size,
array_layer_count: texture_descriptor.array_layer_count,
mip_level_count: texture_descriptor.mip_level_count,
sample_count: texture_descriptor.sample_count,
dimension: texture_descriptor.dimension.into(),
format: texture_descriptor.format,
usage: texture_descriptor.usage,
}
}
}

18
src/render/render_graph_2/pipelines/forward/mod.rs
View file

@ -98,15 +98,15 @@ impl ForwardPipelineBuilder for RenderGraphBuilder {
depth_bias_slope_scale: 0.0,
depth_bias_clamp: 0.0,
})
// .with_depth_stencil_state(wgpu::DepthStencilStateDescriptor {
// format: wgpu::TextureFormat::Depth32Float,
// depth_write_enabled: true,
// depth_compare: wgpu::CompareFunction::Less,
// stencil_front: wgpu::StencilStateFaceDescriptor::IGNORE,
// stencil_back: wgpu::StencilStateFaceDescriptor::IGNORE,
// stencil_read_mask: 0,
// stencil_write_mask: 0,
// })
.with_depth_stencil_state(wgpu::DepthStencilStateDescriptor {
format: wgpu::TextureFormat::Depth32Float,
depth_write_enabled: true,
depth_compare: wgpu::CompareFunction::Less,
stencil_front: wgpu::StencilStateFaceDescriptor::IGNORE,
stencil_back: wgpu::StencilStateFaceDescriptor::IGNORE,
stencil_read_mask: 0,
stencil_write_mask: 0,
})
.add_color_state(wgpu::ColorStateDescriptor {
format: wgpu::TextureFormat::Bgra8UnormSrgb,
color_blend: wgpu::BlendDescriptor::REPLACE,

9
src/render/render_graph_2/render_graph.rs
View file

@ -1,4 +1,4 @@
use crate::render::render_graph_2::{PassDescriptor, PipelineDescriptor, ResourceProvider};
use crate::render::render_graph_2::{PassDescriptor, PipelineDescriptor, ResourceProvider, TextureDescriptor};
use std::collections::HashMap;
pub struct RenderGraph {
@ -7,6 +7,7 @@ pub struct RenderGraph {
pub pass_descriptors: HashMap<String, PassDescriptor>,
pub pass_pipelines: HashMap<String, Vec<String>>,
pub resource_providers: Vec<Box<dyn ResourceProvider>>,
pub queued_textures: Vec<(String, TextureDescriptor)>,
}
impl Default for RenderGraph {
@ -16,6 +17,7 @@ impl Default for RenderGraph {
pass_descriptors: HashMap::new(),
pass_pipelines: HashMap::new(),
resource_providers: Vec::new(),
queued_textures: Vec::new(),
}
}
}
@ -63,6 +65,11 @@ impl RenderGraphBuilder {
self
}
pub fn add_texture(mut self, name: &str, texture_descriptor: TextureDescriptor) -> Self {
self.render_graph.queued_textures.push((name.to_string(), texture_descriptor));
self
}
pub fn build(self) -> RenderGraph {
self.render_graph
}

39
src/render/render_graph_2/renderer.rs
View file

@ -1,20 +1,49 @@
use crate::{legion::prelude::*, render::render_graph_2::{RenderGraph, ResourceInfo, PipelineDescriptor, wgpu_renderer::DynamicUniformBufferInfo}};
use crate::{
legion::prelude::*,
render::render_graph_2::{
wgpu_renderer::DynamicUniformBufferInfo, PipelineDescriptor, RenderGraph, ResourceInfo,
TextureDescriptor,
},
};
use std::ops::Range;
pub trait Renderer {
fn initialize(&mut self, world: &mut World, render_graph: &mut RenderGraph);
fn resize(&mut self, world: &mut World, render_graph: &mut RenderGraph, width: u32, height: u32);
fn resize(
&mut self,
world: &mut World,
render_graph: &mut RenderGraph,
width: u32,
height: u32,
);
fn process_render_graph(&mut self, render_graph: &mut RenderGraph, world: &mut World);
// TODO: swap out wgpu::BufferUsage for non-wgpu type
fn create_buffer_with_data(&mut self, name: &str, data: &[u8], buffer_usage: wgpu::BufferUsage);
fn create_texture(&mut self, name: &str, texture_descriptor: TextureDescriptor);
fn get_dynamic_uniform_buffer_info(&self, name: &str) -> Option<&DynamicUniformBufferInfo>;
fn get_dynamic_uniform_buffer_info_mut(&mut self, name: &str) -> Option<&mut DynamicUniformBufferInfo>;
fn get_dynamic_uniform_buffer_info_mut(
&mut self,
name: &str,
) -> Option<&mut DynamicUniformBufferInfo>;
fn add_dynamic_uniform_buffer_info(&mut self, name: &str, info: DynamicUniformBufferInfo);
fn create_buffer(&mut self, name: &str, size: u64, buffer_usage: wgpu::BufferUsage);
fn create_buffer_mapped(&mut self, name: &str, size: usize, buffer_usage: wgpu::BufferUsage, func: &mut dyn FnMut(&mut [u8]));
fn create_buffer_mapped(
&mut self,
name: &str,
size: usize,
buffer_usage: wgpu::BufferUsage,
func: &mut dyn FnMut(&mut [u8]),
);
fn remove_buffer(&mut self, name: &str);
fn get_resource_info(&self, name: &str) -> Option<&ResourceInfo>;
fn copy_buffer_to_buffer(&mut self, source_buffer: &str, source_offset: u64, destination_buffer: &str, destination_offset: u64, size: u64);
fn copy_buffer_to_buffer(
&mut self,
source_buffer: &str,
source_offset: u64,
destination_buffer: &str,
destination_offset: u64,
size: u64,
);
}
pub trait RenderPass {

1
src/render/render_graph_2/resource_name.rs
View file

@ -1,5 +1,6 @@
pub mod texture {
pub const SWAP_CHAIN: &str = "SwapChain";
pub const DEPTH: &str = "Depth";
}
pub mod uniform {

25
src/render/render_graph_2/wgpu_renderer.rs
View file

@ -4,7 +4,7 @@ use crate::{
resource_name, BindGroup, BindType, PassDescriptor, PipelineDescriptor, RenderGraph,
RenderPass, RenderPassColorAttachmentDescriptor,
RenderPassDepthStencilAttachmentDescriptor, Renderer, ResourceInfo, ShaderUniforms,
TextureDimension,
TextureDescriptor,
},
};
use std::{collections::HashMap, ops::Deref};
@ -488,6 +488,10 @@ impl Renderer for WgpuRenderer {
resource_provider.update(self, world);
}
for (name, texture_descriptor) in render_graph.queued_textures.drain(..) {
self.create_texture(&name, texture_descriptor);
}
let mut encoder = self.encoder.take().unwrap();
let mut swap_chain = world.resources.get_mut::<wgpu::SwapChain>().unwrap();
@ -638,6 +642,12 @@ impl Renderer for WgpuRenderer {
self.dynamic_uniform_buffer_info
.insert(name.to_string(), info);
}
fn create_texture(&mut self, name: &str, texture_descriptor: TextureDescriptor) {
let texture = self.device.create_texture(&texture_descriptor.into());
self.textures
.insert(name.to_string(), texture.create_default_view());
}
}
pub struct WgpuRenderPass<'a, 'b, 'c, 'd> {
@ -717,19 +727,6 @@ impl<'a, 'b, 'c, 'd> RenderPass for WgpuRenderPass<'a, 'b, 'c, 'd> {
}
}
impl From<TextureDimension> for wgpu::TextureViewDimension {
fn from(dimension: TextureDimension) -> Self {
match dimension {
TextureDimension::D1 => wgpu::TextureViewDimension::D1,
TextureDimension::D2 => wgpu::TextureViewDimension::D2,
TextureDimension::D2Array => wgpu::TextureViewDimension::D2Array,
TextureDimension::Cube => wgpu::TextureViewDimension::Cube,
TextureDimension::CubeArray => wgpu::TextureViewDimension::CubeArray,
TextureDimension::D3 => wgpu::TextureViewDimension::D3,
}
}
}
impl From<&BindType> for wgpu::BindingType {
fn from(bind_type: &BindType) -> Self {
match bind_type {