ajoneil
/
kea-gfx
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Remove compute/ray_query strategy

Browse Source 
This was added largely to test if it would help Arc 770 to function.
It didn't help, and I've confirmed A770 has functional ray tracing
pipelines in Quake 2 RTX
main
Andrew O'Neil 1 month ago
parent 9c52878454
commit 338c946375
6 changed files with 12 additions and 188 deletions
Show Stats Download Patch File Download Diff File

2
kea_renderer/src/gpu/mod.rs
Unescape Escape View File

@ -1,6 +1,4 @@
mod ray_query_pipeline;
mod ray_tracing_pipeline;
mod slots;
pub use ray_query_pipeline::RayQueryPipeline;
pub use ray_tracing_pipeline::RayTracingPipeline;

125
kea_renderer/src/gpu/ray_query_pipeline.rs
Unescape Escape View File

@ -1,125 +0,0 @@
use super::slots::create_and_bind_slots;
use crate::{path_tracer::Pipeline, scenes::Scene};
use ash::vk;
use core::slice;
use kea_gpu::{
commands::CommandBufferRecorder,
compute::ComputePipeline,
presentation::PresentationFeature,
shaders::ShaderModule,
slots::{SlotBindings, SlotLayout},
storage::images::{ImageLayout, ImageView},
Kea,
};
use kea_renderer_shaders::{path_tracer::entrypoints::PushConstants, SlotId};
pub struct RayQueryPipeline {
pipeline: ComputePipeline<SlotId>,
slot_bindings: SlotBindings<SlotId>,
size: (u32, u32),
}
impl RayQueryPipeline {
pub fn new(kea: &Kea, scene: &Scene) -> Self {
let modules = ShaderModule::new_multimodule(kea.device(), "./kea_renderer_shaders");
let pipeline = ComputePipeline::<SlotId>::new(
kea.device().clone(),
SlotLayout::new(kea_renderer_shaders::SLOTS.to_vec()),
modules["path_tracer::entrypoints::generate_rays_compute"]
.entry_point("path_tracer::entrypoints::generate_rays_compute"),
);
let size = kea.feature::<PresentationFeature>().presenter().size();
let slot_bindings = create_and_bind_slots(
kea,
scene,
pipeline.slot_layout(),
pipeline.layout().descriptor_set_layout(),
);
Self {
pipeline,
slot_bindings,
size,
}
}
}
impl Pipeline for RayQueryPipeline {
fn bind(&self, cmd: &CommandBufferRecorder, iteration: u64) {
cmd.bind_pipeline(vk::PipelineBindPoint::COMPUTE, &self.pipeline.pipeline());
cmd.bind_descriptor_sets(
vk::PipelineBindPoint::COMPUTE,
&self.pipeline.layout(),
slice::from_ref(&self.slot_bindings.descriptor_set()),
);
let constants = PushConstants { iteration };
let (_, constants, _) = unsafe { slice::from_ref(&constants).align_to::<u8>() };
cmd.push_constants(
self.pipeline.layout(),
vk::ShaderStageFlags::COMPUTE,
constants,
);
}
fn trace_rays(&self, cmd: &CommandBufferRecorder) {
cmd.dispatch((self.size.0 * self.size.1 / 32, 1, 1));
}
fn copy_to_swapchain(&self, cmd: &CommandBufferRecorder, swapchain_image: &ImageView) {
cmd.transition_image_layout(
self.slot_bindings.bound_image(SlotId::OutputImage).image(),
ImageLayout::TransferSource,
vk::AccessFlags2::SHADER_STORAGE_WRITE,
vk::AccessFlags2::TRANSFER_READ,
vk::PipelineStageFlags2::COMPUTE_SHADER,
vk::PipelineStageFlags2::COPY,
);
let copy_region = vk::ImageCopy::builder()
.src_subresource(vk::ImageSubresourceLayers {
aspect_mask: vk::ImageAspectFlags::COLOR,
base_array_layer: 0,
mip_level: 0,
layer_count: 1,
})
.dst_subresource(vk::ImageSubresourceLayers {
aspect_mask: vk::ImageAspectFlags::COLOR,
base_array_layer: 0,
mip_level: 0,
layer_count: 1,
})
.extent(vk::Extent3D {
width: self.size.0,
height: self.size.1,
depth: 1,
})
.build();
cmd.copy_image(
&self.slot_bindings.bound_image(SlotId::OutputImage).image(),
&swapchain_image.image(),
&copy_region,
);
cmd.transition_image_layout(
self.slot_bindings.bound_image(SlotId::OutputImage).image(),
ImageLayout::General,
vk::AccessFlags2::TRANSFER_READ,
vk::AccessFlags2::SHADER_STORAGE_WRITE,
vk::PipelineStageFlags2::COPY,
vk::PipelineStageFlags2::COMPUTE_SHADER,
);
cmd.transition_image_layout(
self.slot_bindings.bound_image(SlotId::LightImage).image(),
ImageLayout::General,
vk::AccessFlags2::SHADER_STORAGE_WRITE | vk::AccessFlags2::SHADER_STORAGE_READ,
vk::AccessFlags2::SHADER_STORAGE_WRITE | vk::AccessFlags2::SHADER_STORAGE_READ,
vk::PipelineStageFlags2::COMPUTE_SHADER,
vk::PipelineStageFlags2::COMPUTE_SHADER,
)
}
}

10
kea_renderer/src/gpu/ray_tracing_pipeline.rs
Unescape Escape View File

@ -1,5 +1,5 @@
use super::slots::create_and_bind_slots;
use crate::{path_tracer::Pipeline, scenes::Scene};
use crate::scenes::Scene;
use ash::vk;
use core::slice;
use kea_gpu::{
@ -46,10 +46,8 @@ impl RayTracingPipeline {
size,
}
}
}
impl Pipeline for RayTracingPipeline {
fn bind(&self, cmd: &CommandBufferRecorder, iteration: u64) {
pub fn bind(&self, cmd: &CommandBufferRecorder, iteration: u64) {
cmd.bind_pipeline(
vk::PipelineBindPoint::RAY_TRACING_KHR,
&self.pipeline.pipeline(),
@ -69,14 +67,14 @@ impl Pipeline for RayTracingPipeline {
);
}
fn trace_rays(&self, cmd: &CommandBufferRecorder) {
pub fn trace_rays(&self, cmd: &CommandBufferRecorder) {
cmd.trace_rays(
self.pipeline.shader_binding_tables(),
(self.size.0, self.size.1, 1),
);
}
fn copy_to_swapchain(&self, cmd: &CommandBufferRecorder, swapchain_image: &ImageView) {
pub fn copy_to_swapchain(&self, cmd: &CommandBufferRecorder, swapchain_image: &ImageView) {
cmd.transition_image_layout(
self.slot_bindings.bound_image(SlotId::OutputImage).image(),
ImageLayout::TransferSource,

7
kea_renderer/src/main.rs
Unescape Escape View File

@ -6,7 +6,7 @@ use kea_gpu::{
ray_tracing::RayTracingFeature,
Config, Kea,
};
use path_tracer::{PathTracer, Strategy};
use path_tracer::PathTracer;
mod gpu;
mod path_tracer;
@ -22,9 +22,6 @@ struct Args {
resolution_x: u32,
#[arg(short = 'y', long, default_value_t = 720)]
resolution_y: u32,
#[arg(short, long, value_enum, default_value_t = Strategy::RayTracingPipeline)]
strategy: Strategy,
}
fn main() {
@ -48,6 +45,6 @@ fn main() {
}
let kea = Kea::new(config);
let path_tracer = PathTracer::new(kea, args.strategy);
let path_tracer = PathTracer::new(kea);
window.event_loop(move || path_tracer.draw())
}

29
kea_renderer/src/path_tracer.rs
Unescape Escape View File

@ -1,43 +1,24 @@
use crate::{
gpu::{RayQueryPipeline, RayTracingPipeline},
gpu::RayTracingPipeline,
scenes::{self, Scene},
};
use ash::vk;
use clap::ValueEnum;
use kea_gpu::{
commands::{CommandBufferRecorder, CommandPool},
presentation::PresentationFeature,
storage::images::{ImageLayout, ImageView},
Kea,
commands::CommandPool, presentation::PresentationFeature, storage::images::ImageLayout, Kea,
};
use std::{cell::Cell, slice};
pub trait Pipeline {
fn bind(&self, cmd: &CommandBufferRecorder, iteration: u64);
fn trace_rays(&self, cmd: &CommandBufferRecorder);
fn copy_to_swapchain(&self, cmd: &CommandBufferRecorder, swapchain_image: &ImageView);
}
pub struct PathTracer {
kea: Kea,
_scene: Scene,
pipeline: Box<dyn Pipeline>,
pipeline: RayTracingPipeline,
iteration: Cell<u64>,
}
#[derive(Clone, ValueEnum)]
pub enum Strategy {
RayTracingPipeline,
RayQuery,
}
impl PathTracer {
pub fn new(kea: Kea, strategy: Strategy) -> PathTracer {
pub fn new(kea: Kea) -> PathTracer {
let scene = scenes::examples::cornell_box(kea.device().clone());
let pipeline: Box<dyn Pipeline> = match strategy {
Strategy::RayTracingPipeline => Box::new(RayTracingPipeline::new(&kea, &scene)),
Strategy::RayQuery => Box::new(RayQueryPipeline::new(&kea, &scene)),
};
let pipeline = RayTracingPipeline::new(&kea, &scene);
PathTracer {
kea,

27
kea_renderer_shaders/src/path_tracer/entrypoints.rs
Unescape Escape View File

@ -4,7 +4,7 @@ use crate::{
};
use kea_gpu_shaderlib::Ray;
use spirv_std::{
glam::{vec2, vec3, vec4, Quat, UVec2, UVec3, Vec2, Vec3, Vec4, Vec4Swizzles},
glam::{vec2, vec3, Quat, UVec2, UVec3, Vec2, Vec3, Vec4, Vec4Swizzles},
ray_tracing::RayFlags,
spirv, Image,
};
@ -240,28 +240,3 @@ fn sample_bounce(
pub fn ray_miss(#[spirv(incoming_ray_payload)] ray_payload: &mut RayPayload) {
ray_payload.hit = None;
}
#[spirv(compute(threads(32)))]
pub fn generate_rays_compute(
#[spirv(global_invocation_id)] global_id: UVec3,
#[spirv(descriptor_set = 0, binding = 0)]
accel_structure: &spirv_std::ray_tracing::AccelerationStructure,
#[spirv(descriptor_set = 0, binding = 1)] output_image: &Image!(
2D,
format = rgba32f,
sampled = false
),
#[spirv(descriptor_set = 0, binding = 6)] light_image: &Image!(
2D,
format = rgba32f,
sampled = false
),
#[spirv(push_constant)] constants: &PushConstants,
) {
let x = global_id.x / 720;
let y = global_id.x % 720;
unsafe {
output_image.write(UVec2::new(x, y), vec4(0.7, 0.0, 0.0, 0.0));
}
}

Write Preview
Loading…
Cancel
Save