asuro/rust-engine
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

textures!!!

Browse Source
This commit is contained in:
Till
2019-08-02 23:50:37 +02:00
parent c582af5138
commit 4f261fa708
5 changed files with 108 additions and 27 deletions
Download Patch File Download Diff File Expand all files Collapse all files

84
src/vulkan.rs
View File

@@ -2,7 +2,7 @@ use vulkano::buffer::{BufferUsage, CpuAccessibleBuffer};
use vulkano::command_buffer::{AutoCommandBufferBuilder, DynamicState};
use vulkano::device::{Device, DeviceExtensions, Queue};
use vulkano::framebuffer::{Framebuffer, FramebufferAbstract, Subpass, RenderPassAbstract};
use vulkano::image::{SwapchainImage, AttachmentImage, ImageUsage};
use vulkano::image::{SwapchainImage, AttachmentImage, ImageUsage, ImmutableImage, Dimensions};
use vulkano::instance::{Instance, PhysicalDevice, ApplicationInfo, Version, InstanceExtensions};
use vulkano::pipeline::{GraphicsPipeline, GraphicsPipelineAbstract};
use vulkano::pipeline::shader::{GraphicsShaderType, ShaderModule};
@@ -14,6 +14,9 @@ use vulkano::sync;
use vulkano::format::{Format, ClearValue};
use vulkano::instance::debug::{DebugCallback, MessageTypes};
use vulkano::memory::pool::{PotentialDedicatedAllocation, StdMemoryPoolAlloc};
use vulkano::descriptor::descriptor_set::PersistentDescriptorSet;
use vulkano::descriptor::DescriptorSet;
use vulkano::sampler::{Sampler, Filter, MipmapMode, SamplerAddressMode};
use vulkano_win::VkSurfaceBuild;
@@ -28,14 +31,15 @@ use cgmath::{Matrix4, SquareMatrix};
use shade_runner;
use shade_runner::{CompiledShaders, Entry};
use shaderc;
use vs::ty::PushConstants;
use line_vs::ty::LinePushConstants;
use crate::mesh::CPUMesh;
use crate::mesh::{CPUMesh};
use crate::vulkan::RenderLoopResult::Quit;
use image::{ImageFormat, ConvertBuffer, ImageBuffer, Rgb, Rgba};
const VALIDATION_LAYERS: &[&str] = &[
"VK_LAYER_LUNARG_standard_validation"
];
@@ -66,6 +70,8 @@ pub struct Mesh {
pub struct GameObject {
pub mesh_index: usize,
pub texture_index: usize,
pub descriptor_set: Arc<DescriptorSet + Send + Sync>,
pub model_matrix: Matrix4<f32>,
}
@@ -82,12 +88,15 @@ pub struct GameData {
pub shutdown: bool,
pub game_objects: Vec<GameObject>,
pub meshes: Vec<Mesh>,
pub textures: Vec<Arc<ImmutableImage<Format>>>,
}
pub struct VulkanRenderer {
pub game_data: GameData,
pub device: Arc<Device>,
pub framebuffers: Vec<Arc<FramebufferAbstract + Send + Sync>>,
pub sampler: Arc<Sampler>,
pub default_descriptor_set: Arc<DescriptorSet + Send + Sync>,
pub dynamic_state: DynamicState,
pub pipeline: Arc<GraphicsPipelineAbstract + Send + Sync>,
pub line_pipeline: Arc<GraphicsPipelineAbstract + Send + Sync>,
@@ -130,6 +139,7 @@ impl VulkanRenderer {
dimensions: [0, 0],
meshes: vec![],
game_objects: vec![],
textures: vec![],
};
if enable_validation_layers {
@@ -268,11 +278,36 @@ impl VulkanRenderer {
}
).unwrap());
let sampler = Sampler::new(device.clone(), Filter::Linear, Filter::Linear,
MipmapMode::Nearest, SamplerAddressMode::Repeat, SamplerAddressMode::Repeat,
SamplerAddressMode::Repeat, 0.0, 1.0, 0.0, 0.0).unwrap();
let pipeline: Arc<GraphicsPipelineAbstract + Send + Sync> =
create_pipeline::<Vertex>(device.clone(), render_pass.clone(), "shaders/triangle.vert", "shaders/triangle.frag", false).unwrap();
let line_pipeline: Arc<GraphicsPipelineAbstract + Send + Sync> =
create_pipeline::<LinePoint>(device.clone(), render_pass.clone(), "shaders/line.vert", "shaders/line.frag", true).unwrap();
let (default_tex, default_tex_future) = {
let image = image::load_from_memory_with_format(include_bytes!("../models/Eye.png"),
ImageFormat::PNG).unwrap().to_rgba();
let image_data = image.into_raw().clone();
ImmutableImage::from_iter(
image_data.iter().cloned(),
Dimensions::Dim2d { width: 4096, height: 4096 },
Format::R8G8B8A8Unorm,
queue.clone(),
).unwrap()
};
let default_descriptor_set = Arc::new(PersistentDescriptorSet::start(pipeline.clone(), 0)
.add_sampled_image(default_tex.clone(), sampler.clone()).unwrap()
.build().unwrap()
);
data.textures.push(default_tex);
// Dynamic viewports allow us to recreate just the viewport when the window is resized
// Otherwise we would have to recreate the whole pipeline.
let mut dynamic_state = DynamicState { line_width: None, viewports: None, scissors: None };
@@ -289,7 +324,9 @@ impl VulkanRenderer {
// that, we store the submission of the previous frame here.
let previous_frame_end = Some(Box::new(sync::now(device.clone())) as Box<dyn GpuFuture>);
VulkanRenderer { game_data: data, device, framebuffers, dynamic_state, pipeline, line_pipeline,
VulkanRenderer { game_data: data, device, framebuffers, sampler,
default_descriptor_set: default_descriptor_set,
dynamic_state, pipeline, line_pipeline,
surface, swapchain, render_pass, queue, line_vertex_buffer, events_loop,
recreate_swapchain: false, debug_callback, previous_frame_end }
}
@@ -362,10 +399,12 @@ impl VulkanRenderer {
let game_object = &self.game_data.game_objects[i];
let mesh = &self.game_data.meshes[game_object.mesh_index];
self.game_data.push_constants.model = game_object.model_matrix.into();
cbb = cbb.draw_indexed(self.pipeline.clone(), &self.dynamic_state,
cbb = cbb.draw_indexed(self.pipeline.clone(),
&self.dynamic_state,
vec![mesh.vertex_buffer.clone()],
mesh.index_buffer.clone(),
(), self.game_data.push_constants.clone()).unwrap();
game_object.descriptor_set.clone(),
self.game_data.push_constants.clone()).unwrap();
}
cbb = cbb.draw(self.line_pipeline.clone(), &self.dynamic_state, vec![self.line_vertex_buffer.clone()], (), self.game_data.line_push_constants.clone()).unwrap()
@@ -423,6 +462,22 @@ impl VulkanRenderer {
self.game_data.meshes.len() - 1
}
pub fn upload_texture(self: &mut Self, texture_data: &gltf::image::Data) {
let buffer: ImageBuffer<Rgb<u8>, Vec<u8>> = image::ImageBuffer::from_raw(texture_data.width, texture_data.height, texture_data.pixels.clone()).unwrap();
let new_buffer: ImageBuffer<Rgba<u8>, Vec<u8>> = buffer.convert();
let (image_view, future) = ImmutableImage::from_iter(
new_buffer.iter().cloned(),
Dimensions::Dim2d { width: texture_data.width, height: texture_data.height },
Format::R8G8B8A8Unorm,
self.queue.clone(),
).unwrap();
future.flush().unwrap();
self.game_data.textures.push(image_view);
}
pub fn add_game_object(self: &mut Self, game_object: GameObject) -> usize {
self.game_data.game_objects.push(game_object);
self.game_data.game_objects.len() - 1
@@ -523,9 +578,10 @@ fn create_pipeline<V: vulkano::pipeline::vertex::Vertex>(device: Arc<Device>, re
.vertex_shader(vertex_shader_entry.clone(), ())
.triangle_list()
.viewports_dynamic_scissors_irrelevant(1)
.depth_stencil_simple_depth()
.cull_mode_back()
.fragment_shader(fragment_shader_entry.clone(), ())
.depth_stencil_simple_depth()
.blend_alpha_blending()
.cull_mode_back()
.render_pass(sub_pass.clone())
.build(device.clone())
.unwrap());
@@ -538,8 +594,14 @@ fn create_pipeline<V: vulkano::pipeline::vertex::Vertex>(device: Arc<Device>, re
}
impl GameObject {
pub fn new(mesh: MeshHandle) -> GameObject {
GameObject { mesh_index: mesh, model_matrix: Matrix4::identity() }
pub fn new(mesh: MeshHandle, texture_index: usize, renderer: &VulkanRenderer) -> GameObject {
println!("Texid: {}", texture_index);
let descriptor_set = Arc::new(PersistentDescriptorSet::start(renderer.pipeline.clone(), 0)
.add_sampled_image(renderer.game_data.textures[texture_index].clone(), renderer.sampler.clone()).unwrap()
.build().unwrap()
);
GameObject { mesh_index: mesh, texture_index, descriptor_set, model_matrix: Matrix4::identity() }
}
}