[core-remote] remove ray_tracing stuff from global

Signed-off-by: sagudev <16504129+sagudev@users.noreply.github.com>
This commit is contained in:
sagudev authored and Teodor Tanasoaia committed 2026-08-14 16:30:02 +02:00
1 parent 5cd735daf4
commit 36338914f5
4 files changed
+2 -178

No files matched your search

+1 -83
View File
@@ -1,13 +1,9 @@
use wgpu_core::command::{CommandEncoderError, EncoderStateError};
use wgpu_core::ray_tracing::{
BlasAabbGeometry, BlasBuildEntry, BlasGeometries, BlasTriangleGeometry, TlasInstance,
TlasPackage,
};
use wgpu_core::Label;
use wgt::{BufferAddress, Extent3d, ImageSubresourceRange};
use crate::global::Global;
use crate::id::{BlasId, BufferId, CommandEncoderId, TextureId, TlasId};
use crate::id::{BufferId, CommandEncoderId, TextureId};
use crate::{id, TexelCopyBufferInfo};
impl Global {
@@ -130,84 +126,6 @@ impl Global {
}
}
impl Global {
pub fn command_encoder_mark_acceleration_structures_built(
&self,
command_encoder_id: CommandEncoderId,
blas_ids: &[BlasId],
tlas_ids: &[TlasId],
) -> Result<(), EncoderStateError> {
let hub = &self.hub;
let cmd_enc = hub.command_encoders.get(command_encoder_id);
let blases = blas_ids
.iter()
.map(|&id| hub.blas_s.get(id))
.collect::<Vec<_>>();
let tlases = tlas_ids
.iter()
.map(|&id| hub.tlas_s.get(id))
.collect::<Vec<_>>();
cmd_enc.mark_acceleration_structures_built(&blases, &tlases)
}
pub fn command_encoder_build_acceleration_structures<'a>(
&self,
command_encoder_id: CommandEncoderId,
blas_iter: impl Iterator<Item = BlasBuildEntry<'a, BlasId, BufferId>>,
tlas_iter: impl Iterator<Item = TlasPackage<'a, TlasId, BlasId>>,
) -> Result<(), EncoderStateError> {
let hub = &self.hub;
let cmd_enc = hub.command_encoders.get(command_encoder_id);
let blases = blas_iter.map(|e| BlasBuildEntry {
blas: hub.blas_s.get(e.blas),
geometries: match e.geometries {
BlasGeometries::TriangleGeometries(triangle_geometries) => {
let triangle_geometries = triangle_geometries.map(|tg| BlasTriangleGeometry {
size: tg.size,
vertex_buffer: hub.buffers.get(tg.vertex_buffer),
index_buffer: tg
.index_buffer
.map(|index_buffer| hub.buffers.get(index_buffer)),
transform_buffer: tg
.transform_buffer
.map(|transform_buffer| hub.buffers.get(transform_buffer)),
first_vertex: tg.first_vertex,
vertex_stride: tg.vertex_stride,
first_index: tg.first_index,
transform_buffer_offset: tg.transform_buffer_offset,
});
BlasGeometries::TriangleGeometries(Box::new(triangle_geometries.into_iter()))
}
BlasGeometries::AabbGeometries(aabb_geometries) => {
let aabb_geometries = aabb_geometries.map(|ag| BlasAabbGeometry {
size: ag.size,
stride: ag.stride,
aabb_buffer: hub.buffers.get(ag.aabb_buffer),
primitive_offset: ag.primitive_offset,
});
BlasGeometries::AabbGeometries(Box::new(aabb_geometries.into_iter()))
}
},
});
let tlases = tlas_iter.map(|e| TlasPackage {
tlas: hub.tlas_s.get(e.tlas),
instances: Box::new(e.instances.map(|instance| {
instance.as_ref().map(|instance| TlasInstance {
blas: hub.blas_s.get(instance.blas),
transform: instance.transform,
custom_data: instance.custom_data,
mask: instance.mask,
})
})),
lowest_unmodified: e.lowest_unmodified,
});
cmd_enc.build_acceleration_structures(blases.into_iter(), tlases.into_iter())
}
}
impl Global {
pub fn command_encoder_copy_buffer_to_buffer(
&self,
-1
View File
@@ -23,7 +23,6 @@ mod device;
mod instance;
mod present;
mod queue;
mod ray_tracing;
mod render_pass;
#[derive(Debug, PartialEq, Eq)]
+1 -21
View File
@@ -1,11 +1,10 @@
use core::ptr::NonNull;
use wgpu_core::device::queue::{QueueSubmitError, QueueWriteError, SubmittedWorkDoneClosure};
use wgpu_core::ray_tracing::CompactBlasError;
use wgpu_core::SubmissionIndex;
use crate::global::Global;
use crate::id::{BlasId, BufferId, CommandBufferId, QueueId, StagingBufferId, TextureId};
use crate::id::{BufferId, CommandBufferId, QueueId, StagingBufferId, TextureId};
impl Global {
pub fn queue_write_buffer(
@@ -111,23 +110,4 @@ impl Global {
let result = queue.on_submitted_work_done(closure);
result.unwrap_or(0) // '0' means no wait is necessary
}
pub fn queue_compact_blas(
&self,
queue_id: QueueId,
blas_id: BlasId,
id_in: Option<BlasId>,
) -> (BlasId, Option<u64>, Option<CompactBlasError>) {
let fid = self.hub.blas_s.prepare(id_in);
let queue = self.hub.queues.get(queue_id);
let blas = self.hub.blas_s.get(blas_id);
let (blas, error) = queue.compact_blas(&blas);
let handle = blas.handle();
let id = fid.assign(blas);
(id, handle, error)
}
}
@@ -1,73 +0,0 @@
use wgpu_core::ray_tracing::{BlasPrepareCompactError, CreateBlasError, CreateTlasError};
use wgpu_core::resource::{self, BlasCompactCallback, InvalidResourceError};
use wgpu_core::SubmissionIndex;
use crate::global::Global;
use crate::id::{self, BlasId, TlasId};
impl Global {
pub fn device_create_blas(
&self,
device_id: id::DeviceId,
desc: &resource::BlasDescriptor,
sizes: wgt::BlasGeometrySizeDescriptors,
id_in: Option<BlasId>,
) -> (BlasId, Option<u64>, Option<CreateBlasError>) {
let fid = self.hub.blas_s.prepare(id_in);
let device = self.hub.devices.get(device_id);
let (blas, error) = device.create_blas(desc, sizes);
let handle = blas.handle();
let id = fid.assign(blas);
(id, handle, error)
}
pub fn device_create_tlas(
&self,
device_id: id::DeviceId,
desc: &resource::TlasDescriptor,
id_in: Option<TlasId>,
) -> (TlasId, Option<CreateTlasError>) {
let fid = self.hub.tlas_s.prepare(id_in);
let device = self.hub.devices.get(device_id);
let (tlas, error) = device.create_tlas(desc);
let id = fid.assign(tlas);
(id, error)
}
pub fn blas_drop(&self, blas_id: BlasId) {
let _blas = self.hub.blas_s.remove(blas_id);
}
pub fn tlas_drop(&self, tlas_id: TlasId) {
let _tlas = self.hub.tlas_s.remove(tlas_id);
}
pub fn blas_prepare_compact_async(
&self,
blas_id: BlasId,
callback: Option<BlasCompactCallback>,
) -> Result<SubmissionIndex, BlasPrepareCompactError> {
let hub = &self.hub;
let blas = hub.blas_s.get(blas_id);
blas.prepare_compact_async(callback)
}
pub fn ready_for_compaction(&self, blas_id: BlasId) -> Result<bool, InvalidResourceError> {
let hub = &self.hub;
let blas = hub.blas_s.get(blas_id);
blas.ready_for_compaction()
}
}