This commit is contained in:
1 parent
f29712d158
commit
3e053a81ab
123 files changed
+31930
-1404
No files matched your search
+396
@@ -0,0 +1,396 @@
|
||||
use crate::render_phase::{PhaseItem, TrackedRenderPass};
|
||||
use bevy_app::{App, SubApp};
|
||||
use bevy_ecs::{
|
||||
entity::Entity,
|
||||
query::{QueryEntityError, QueryState, ROQueryItem, ReadOnlyQueryData},
|
||||
resource::Resource,
|
||||
system::{ReadOnlySystemParam, SystemParam, SystemParamItem, SystemState},
|
||||
world::World,
|
||||
};
|
||||
use bevy_utils::TypeIdMap;
|
||||
use core::{any::TypeId, fmt::Debug, hash::Hash};
|
||||
use std::sync::{PoisonError, RwLock, RwLockReadGuard, RwLockWriteGuard};
|
||||
use thiserror::Error;
|
||||
use variadics_please::all_tuples;
|
||||
|
||||
/// A draw function used to draw [`PhaseItem`]s.
|
||||
///
|
||||
/// The draw function can retrieve and query the required ECS data from the render world.
|
||||
///
|
||||
/// This trait can either be implemented directly or implicitly composed out of multiple modular
|
||||
/// [`RenderCommand`]s. For more details and an example see the [`RenderCommand`] documentation.
|
||||
pub trait Draw<P: PhaseItem>: Send + Sync + 'static {
|
||||
/// Prepares the draw function to be used. This is called once and only once before the phase
|
||||
/// begins. There may be zero or more [`draw`](Draw::draw) calls following a call to this function.
|
||||
/// Implementing this is optional.
|
||||
#[expect(
|
||||
unused_variables,
|
||||
reason = "The parameters here are intentionally unused by the default implementation; however, putting underscores here will result in the underscores being copied by rust-analyzer's tab completion."
|
||||
)]
|
||||
fn prepare(&mut self, world: &'_ World) {}
|
||||
|
||||
/// Draws a [`PhaseItem`] by issuing zero or more `draw` calls via the [`TrackedRenderPass`].
|
||||
fn draw<'w>(
|
||||
&mut self,
|
||||
world: &'w World,
|
||||
pass: &mut TrackedRenderPass<'w>,
|
||||
view: Entity,
|
||||
item: &P,
|
||||
) -> Result<(), DrawError>;
|
||||
}
|
||||
|
||||
#[derive(Error, Debug, PartialEq, Eq)]
|
||||
pub enum DrawError {
|
||||
#[error("Failed to execute render command {0:?}")]
|
||||
RenderCommandFailure(&'static str),
|
||||
#[error("Failed to get execute view query")]
|
||||
InvalidViewQuery,
|
||||
#[error("View entity not found")]
|
||||
ViewEntityNotFound,
|
||||
}
|
||||
|
||||
// TODO: make this generic?
|
||||
/// An identifier for a [`Draw`] function stored in [`DrawFunctions`].
|
||||
#[derive(Copy, Clone, Debug, Eq, PartialEq, PartialOrd, Ord, Hash)]
|
||||
pub struct DrawFunctionId(u32);
|
||||
|
||||
/// Stores all [`Draw`] functions for the [`PhaseItem`] type.
|
||||
///
|
||||
/// For retrieval, the [`Draw`] functions are mapped to their respective [`TypeId`]s.
|
||||
pub struct DrawFunctionsInternal<P: PhaseItem> {
|
||||
pub draw_functions: Vec<Box<dyn Draw<P>>>,
|
||||
pub indices: TypeIdMap<DrawFunctionId>,
|
||||
}
|
||||
|
||||
impl<P: PhaseItem> DrawFunctionsInternal<P> {
|
||||
/// Prepares all draw function. This is called once and only once before the phase begins.
|
||||
pub fn prepare(&mut self, world: &World) {
|
||||
for function in &mut self.draw_functions {
|
||||
function.prepare(world);
|
||||
}
|
||||
}
|
||||
|
||||
/// Adds the [`Draw`] function and maps it to its own type.
|
||||
pub fn add<T: Draw<P>>(&mut self, draw_function: T) -> DrawFunctionId {
|
||||
self.add_with::<T, T>(draw_function)
|
||||
}
|
||||
|
||||
/// Adds the [`Draw`] function and maps it to the type `T`
|
||||
pub fn add_with<T: 'static, D: Draw<P>>(&mut self, draw_function: D) -> DrawFunctionId {
|
||||
let id = DrawFunctionId(self.draw_functions.len().try_into().unwrap());
|
||||
self.draw_functions.push(Box::new(draw_function));
|
||||
self.indices.insert(TypeId::of::<T>(), id);
|
||||
id
|
||||
}
|
||||
|
||||
/// Retrieves the [`Draw`] function corresponding to the `id` mutably.
|
||||
pub fn get_mut(&mut self, id: DrawFunctionId) -> Option<&mut dyn Draw<P>> {
|
||||
self.draw_functions.get_mut(id.0 as usize).map(|f| &mut **f)
|
||||
}
|
||||
|
||||
/// Retrieves the id of the [`Draw`] function corresponding to their associated type `T`.
|
||||
pub fn get_id<T: 'static>(&self) -> Option<DrawFunctionId> {
|
||||
self.indices.get(&TypeId::of::<T>()).copied()
|
||||
}
|
||||
|
||||
/// Retrieves the id of the [`Draw`] function corresponding to their associated type `T`.
|
||||
///
|
||||
/// Fallible wrapper for [`Self::get_id()`]
|
||||
///
|
||||
/// ## Panics
|
||||
/// If the id doesn't exist, this function will panic.
|
||||
pub fn id<T: 'static>(&self) -> DrawFunctionId {
|
||||
self.get_id::<T>().unwrap_or_else(|| {
|
||||
panic!(
|
||||
"Draw function {} not found for {}",
|
||||
core::any::type_name::<T>(),
|
||||
core::any::type_name::<P>()
|
||||
)
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
/// Stores all draw functions for the [`PhaseItem`] type hidden behind a reader-writer lock.
|
||||
///
|
||||
/// To access them the [`DrawFunctions::read`] and [`DrawFunctions::write`] methods are used.
|
||||
#[derive(Resource)]
|
||||
pub struct DrawFunctions<P: PhaseItem> {
|
||||
internal: RwLock<DrawFunctionsInternal<P>>,
|
||||
}
|
||||
|
||||
impl<P: PhaseItem> Default for DrawFunctions<P> {
|
||||
fn default() -> Self {
|
||||
Self {
|
||||
internal: RwLock::new(DrawFunctionsInternal {
|
||||
draw_functions: Vec::new(),
|
||||
indices: Default::default(),
|
||||
}),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl<P: PhaseItem> DrawFunctions<P> {
|
||||
/// Accesses the draw functions in read mode.
|
||||
pub fn read(&self) -> RwLockReadGuard<'_, DrawFunctionsInternal<P>> {
|
||||
self.internal.read().unwrap_or_else(PoisonError::into_inner)
|
||||
}
|
||||
|
||||
/// Accesses the draw functions in write mode.
|
||||
pub fn write(&self) -> RwLockWriteGuard<'_, DrawFunctionsInternal<P>> {
|
||||
self.internal
|
||||
.write()
|
||||
.unwrap_or_else(PoisonError::into_inner)
|
||||
}
|
||||
}
|
||||
|
||||
/// [`RenderCommand`]s are modular standardized pieces of render logic that can be composed into
|
||||
/// [`Draw`] functions.
|
||||
///
|
||||
/// To turn a stateless render command into a usable draw function it has to be wrapped by a
|
||||
/// [`RenderCommandState`].
|
||||
/// This is done automatically when registering a render command as a [`Draw`] function via the
|
||||
/// [`AddRenderCommand::add_render_command`] method.
|
||||
///
|
||||
/// Compared to the draw function the required ECS data is fetched automatically
|
||||
/// (by the [`RenderCommandState`]) from the render world.
|
||||
/// Therefore the three types [`Param`](RenderCommand::Param),
|
||||
/// [`ViewQuery`](RenderCommand::ViewQuery) and
|
||||
/// [`ItemQuery`](RenderCommand::ItemQuery) are used.
|
||||
/// They specify which information is required to execute the render command.
|
||||
///
|
||||
/// Multiple render commands can be combined together by wrapping them in a tuple.
|
||||
///
|
||||
/// # Example
|
||||
///
|
||||
/// The `DrawMaterial` draw function is created from the following render command
|
||||
/// tuple. Const generics are used to set specific bind group locations:
|
||||
///
|
||||
/// ```
|
||||
/// # use bevy_render::render_phase::SetItemPipeline;
|
||||
/// # struct SetMeshViewBindGroup<const N: usize>;
|
||||
/// # struct SetMeshViewBindingArrayBindGroup<const N: usize>;
|
||||
/// # struct SetMeshBindGroup<const N: usize>;
|
||||
/// # struct SetMaterialBindGroup<M, const N: usize>(std::marker::PhantomData<M>);
|
||||
/// # struct DrawMesh;
|
||||
/// pub type DrawMaterial<M> = (
|
||||
/// SetItemPipeline,
|
||||
/// SetMeshViewBindGroup<0>,
|
||||
/// SetMeshViewBindingArrayBindGroup<1>,
|
||||
/// SetMeshBindGroup<2>,
|
||||
/// SetMaterialBindGroup<M, 3>,
|
||||
/// DrawMesh,
|
||||
/// );
|
||||
/// ```
|
||||
pub trait RenderCommand<P: PhaseItem> {
|
||||
/// Specifies the general ECS data (e.g. resources) required by [`RenderCommand::render`].
|
||||
///
|
||||
/// When fetching resources, note that, due to lifetime limitations of the `Deref` trait,
|
||||
/// [`SRes::into_inner`] must be called on each [`SRes`] reference in the
|
||||
/// [`RenderCommand::render`] method, instead of being automatically dereferenced as is the
|
||||
/// case in normal `systems`.
|
||||
///
|
||||
/// All parameters have to be read only.
|
||||
///
|
||||
/// [`SRes`]: bevy_ecs::system::lifetimeless::SRes
|
||||
/// [`SRes::into_inner`]: bevy_ecs::system::lifetimeless::SRes::into_inner
|
||||
type Param: SystemParam + 'static;
|
||||
/// Specifies the ECS data of the view entity required by [`RenderCommand::render`].
|
||||
///
|
||||
/// The view entity refers to the camera, or shadow-casting light, etc. from which the phase
|
||||
/// item will be rendered from.
|
||||
/// All components have to be accessed read only.
|
||||
type ViewQuery: ReadOnlyQueryData;
|
||||
/// Specifies the ECS data of the item entity required by [`RenderCommand::render`].
|
||||
///
|
||||
/// The item is the entity that will be rendered for the corresponding view.
|
||||
/// All components have to be accessed read only.
|
||||
///
|
||||
/// For efficiency reasons, Bevy doesn't always extract entities to the
|
||||
/// render world; for instance, entities that simply consist of meshes are
|
||||
/// often not extracted. If the entity doesn't exist in the render world,
|
||||
/// the supplied query data will be `None`.
|
||||
type ItemQuery: ReadOnlyQueryData;
|
||||
|
||||
/// Renders a [`PhaseItem`] by recording commands (e.g. setting pipelines, binding bind groups,
|
||||
/// issuing draw calls, etc.) via the [`TrackedRenderPass`].
|
||||
fn render<'w>(
|
||||
item: &P,
|
||||
view: ROQueryItem<'w, '_, Self::ViewQuery>,
|
||||
entity: Option<ROQueryItem<'w, '_, Self::ItemQuery>>,
|
||||
param: SystemParamItem<'w, '_, Self::Param>,
|
||||
pass: &mut TrackedRenderPass<'w>,
|
||||
) -> RenderCommandResult;
|
||||
}
|
||||
|
||||
/// The result of a [`RenderCommand`].
|
||||
#[derive(Debug)]
|
||||
pub enum RenderCommandResult {
|
||||
Success,
|
||||
Skip,
|
||||
Failure(&'static str),
|
||||
}
|
||||
|
||||
macro_rules! render_command_tuple_impl {
|
||||
($(#[$meta:meta])* $(($name: ident, $view: ident, $entity: ident)),*) => {
|
||||
$(#[$meta])*
|
||||
impl<P: PhaseItem, $($name: RenderCommand<P>),*> RenderCommand<P> for ($($name,)*) {
|
||||
type Param = ($($name::Param,)*);
|
||||
type ViewQuery = ($($name::ViewQuery,)*);
|
||||
type ItemQuery = ($($name::ItemQuery,)*);
|
||||
|
||||
#[expect(
|
||||
clippy::allow_attributes,
|
||||
reason = "We are in a macro; as such, `non_snake_case` may not always lint."
|
||||
)]
|
||||
#[allow(
|
||||
non_snake_case,
|
||||
reason = "Parameter and variable names are provided by the macro invocation, not by us."
|
||||
)]
|
||||
fn render<'w>(
|
||||
_item: &P,
|
||||
($($view,)*): ROQueryItem<'w, '_, Self::ViewQuery>,
|
||||
maybe_entities: Option<ROQueryItem<'w, '_, Self::ItemQuery>>,
|
||||
($($name,)*): SystemParamItem<'w, '_, Self::Param>,
|
||||
_pass: &mut TrackedRenderPass<'w>,
|
||||
) -> RenderCommandResult {
|
||||
match maybe_entities {
|
||||
None => {
|
||||
$(
|
||||
match $name::render(_item, $view, None, $name, _pass) {
|
||||
RenderCommandResult::Skip => return RenderCommandResult::Skip,
|
||||
RenderCommandResult::Failure(reason) => return RenderCommandResult::Failure(reason),
|
||||
_ => {},
|
||||
}
|
||||
)*
|
||||
}
|
||||
Some(($($entity,)*)) => {
|
||||
$(
|
||||
match $name::render(_item, $view, Some($entity), $name, _pass) {
|
||||
RenderCommandResult::Skip => return RenderCommandResult::Skip,
|
||||
RenderCommandResult::Failure(reason) => return RenderCommandResult::Failure(reason),
|
||||
_ => {},
|
||||
}
|
||||
)*
|
||||
}
|
||||
}
|
||||
RenderCommandResult::Success
|
||||
}
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
all_tuples!(
|
||||
#[doc(fake_variadic)]
|
||||
render_command_tuple_impl,
|
||||
0,
|
||||
15,
|
||||
C,
|
||||
V,
|
||||
E
|
||||
);
|
||||
|
||||
/// Wraps a [`RenderCommand`] into a state so that it can be used as a [`Draw`] function.
|
||||
///
|
||||
/// The [`RenderCommand::Param`], [`RenderCommand::ViewQuery`] and
|
||||
/// [`RenderCommand::ItemQuery`] are fetched from the ECS and passed to the command.
|
||||
pub struct RenderCommandState<P: PhaseItem + 'static, C: RenderCommand<P>> {
|
||||
state: SystemState<C::Param>,
|
||||
view: QueryState<C::ViewQuery>,
|
||||
entity: QueryState<C::ItemQuery>,
|
||||
}
|
||||
|
||||
impl<P: PhaseItem, C: RenderCommand<P>> RenderCommandState<P, C> {
|
||||
/// Creates a new [`RenderCommandState`] for the [`RenderCommand`].
|
||||
pub fn new(world: &mut World) -> Self {
|
||||
Self {
|
||||
state: SystemState::new(world),
|
||||
view: world.query(),
|
||||
entity: world.query(),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl<P: PhaseItem, C: RenderCommand<P> + Send + Sync + 'static> Draw<P> for RenderCommandState<P, C>
|
||||
where
|
||||
C::Param: ReadOnlySystemParam,
|
||||
{
|
||||
/// Prepares the render command to be used. This is called once and only once before the phase
|
||||
/// begins. There may be zero or more [`draw`](RenderCommandState::draw) calls following a call to this function.
|
||||
fn prepare(&mut self, world: &'_ World) {
|
||||
self.view.update_archetypes(world);
|
||||
self.entity.update_archetypes(world);
|
||||
}
|
||||
|
||||
/// Fetches the ECS parameters for the wrapped [`RenderCommand`] and then renders it.
|
||||
fn draw<'w>(
|
||||
&mut self,
|
||||
world: &'w World,
|
||||
pass: &mut TrackedRenderPass<'w>,
|
||||
view: Entity,
|
||||
item: &P,
|
||||
) -> Result<(), DrawError> {
|
||||
let param = self.state.get(world);
|
||||
let view = match self.view.get_manual(world, view) {
|
||||
Ok(view) => view,
|
||||
Err(err) => match err {
|
||||
QueryEntityError::NotSpawned(_) => return Err(DrawError::ViewEntityNotFound),
|
||||
QueryEntityError::QueryDoesNotMatch(_, _)
|
||||
| QueryEntityError::AliasedMutability(_) => {
|
||||
return Err(DrawError::InvalidViewQuery)
|
||||
}
|
||||
},
|
||||
};
|
||||
|
||||
let entity = self.entity.get_manual(world, item.entity()).ok();
|
||||
match C::render(item, view, entity, param, pass) {
|
||||
RenderCommandResult::Success | RenderCommandResult::Skip => Ok(()),
|
||||
RenderCommandResult::Failure(reason) => Err(DrawError::RenderCommandFailure(reason)),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Registers a [`RenderCommand`] as a [`Draw`] function.
|
||||
/// They are stored inside the [`DrawFunctions`] resource of the app.
|
||||
pub trait AddRenderCommand {
|
||||
/// Adds the [`RenderCommand`] for the specified render phase to the app.
|
||||
fn add_render_command<P: PhaseItem, C: RenderCommand<P> + Send + Sync + 'static>(
|
||||
&mut self,
|
||||
) -> &mut Self
|
||||
where
|
||||
C::Param: ReadOnlySystemParam;
|
||||
}
|
||||
|
||||
impl AddRenderCommand for SubApp {
|
||||
fn add_render_command<P: PhaseItem, C: RenderCommand<P> + Send + Sync + 'static>(
|
||||
&mut self,
|
||||
) -> &mut Self
|
||||
where
|
||||
C::Param: ReadOnlySystemParam,
|
||||
{
|
||||
let draw_function = RenderCommandState::<P, C>::new(self.world_mut());
|
||||
let draw_functions = self
|
||||
.world()
|
||||
.get_resource::<DrawFunctions<P>>()
|
||||
.unwrap_or_else(|| {
|
||||
panic!(
|
||||
"DrawFunctions<{}> must be added to the world as a resource \
|
||||
before adding render commands to it",
|
||||
core::any::type_name::<P>(),
|
||||
);
|
||||
});
|
||||
draw_functions.write().add_with::<C, _>(draw_function);
|
||||
self
|
||||
}
|
||||
}
|
||||
|
||||
impl AddRenderCommand for App {
|
||||
fn add_render_command<P: PhaseItem, C: RenderCommand<P> + Send + Sync + 'static>(
|
||||
&mut self,
|
||||
) -> &mut Self
|
||||
where
|
||||
C::Param: ReadOnlySystemParam,
|
||||
{
|
||||
SubApp::add_render_command::<P, C>(self.main_mut());
|
||||
self
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,671 @@
|
||||
use crate::{
|
||||
diagnostic::internal::{Pass, PassKind, WritePipelineStatistics, WriteTimestamp},
|
||||
render_resource::{
|
||||
BindGroup, BindGroupId, Buffer, BufferId, BufferSlice, RenderPipeline, RenderPipelineId,
|
||||
ShaderStages,
|
||||
},
|
||||
renderer::RenderDevice,
|
||||
};
|
||||
use bevy_camera::Viewport;
|
||||
use bevy_color::LinearRgba;
|
||||
use bevy_utils::default;
|
||||
use core::ops::Range;
|
||||
use wgpu::{IndexFormat, QuerySet, RenderPass};
|
||||
|
||||
#[cfg(feature = "detailed_trace")]
|
||||
use tracing::trace;
|
||||
|
||||
type BufferSliceKey = (BufferId, wgpu::BufferAddress, wgpu::BufferSize);
|
||||
|
||||
/// Tracks the state of a [`TrackedRenderPass`].
|
||||
///
|
||||
/// This is used to skip redundant operations on the [`TrackedRenderPass`] (e.g. setting an already
|
||||
/// set pipeline, binding an already bound bind group). These operations can otherwise be fairly
|
||||
/// costly due to IO to the GPU, so deduplicating these calls results in a speedup.
|
||||
#[derive(Debug, Default)]
|
||||
struct DrawState {
|
||||
pipeline: Option<RenderPipelineId>,
|
||||
bind_groups: Vec<(Option<BindGroupId>, Vec<u32>)>,
|
||||
/// List of vertex buffers by [`BufferId`], offset, and size. See [`DrawState::buffer_slice_key`]
|
||||
vertex_buffers: Vec<Option<BufferSliceKey>>,
|
||||
index_buffer: Option<(BufferSliceKey, IndexFormat)>,
|
||||
|
||||
/// Stores whether this state is populated or empty for quick state invalidation
|
||||
stores_state: bool,
|
||||
}
|
||||
|
||||
impl DrawState {
|
||||
/// Marks the `pipeline` as bound.
|
||||
fn set_pipeline(&mut self, pipeline: RenderPipelineId) {
|
||||
// TODO: do these need to be cleared?
|
||||
// self.bind_groups.clear();
|
||||
// self.vertex_buffers.clear();
|
||||
// self.index_buffer = None;
|
||||
self.pipeline = Some(pipeline);
|
||||
self.stores_state = true;
|
||||
}
|
||||
|
||||
/// Checks, whether the `pipeline` is already bound.
|
||||
fn is_pipeline_set(&self, pipeline: RenderPipelineId) -> bool {
|
||||
self.pipeline == Some(pipeline)
|
||||
}
|
||||
|
||||
/// Marks the `bind_group` as bound to the `index`.
|
||||
fn set_bind_group(&mut self, index: usize, bind_group: BindGroupId, dynamic_indices: &[u32]) {
|
||||
let group = &mut self.bind_groups[index];
|
||||
group.0 = Some(bind_group);
|
||||
group.1.clear();
|
||||
group.1.extend(dynamic_indices);
|
||||
self.stores_state = true;
|
||||
}
|
||||
|
||||
/// Checks, whether the `bind_group` is already bound to the `index`.
|
||||
fn is_bind_group_set(
|
||||
&self,
|
||||
index: usize,
|
||||
bind_group: BindGroupId,
|
||||
dynamic_indices: &[u32],
|
||||
) -> bool {
|
||||
if let Some(current_bind_group) = self.bind_groups.get(index) {
|
||||
current_bind_group.0 == Some(bind_group) && dynamic_indices == current_bind_group.1
|
||||
} else {
|
||||
false
|
||||
}
|
||||
}
|
||||
|
||||
/// Marks the vertex `buffer` as bound to the `index`.
|
||||
fn set_vertex_buffer(&mut self, index: usize, buffer_slice: BufferSlice) {
|
||||
self.vertex_buffers[index] = Some(self.buffer_slice_key(&buffer_slice));
|
||||
self.stores_state = true;
|
||||
}
|
||||
|
||||
/// Checks, whether the vertex `buffer` is already bound to the `index`.
|
||||
fn is_vertex_buffer_set(&self, index: usize, buffer_slice: &BufferSlice) -> bool {
|
||||
if let Some(current) = self.vertex_buffers.get(index) {
|
||||
*current == Some(self.buffer_slice_key(buffer_slice))
|
||||
} else {
|
||||
false
|
||||
}
|
||||
}
|
||||
|
||||
/// Returns the value used for checking whether `BufferSlice`s are equivalent.
|
||||
fn buffer_slice_key(&self, buffer_slice: &BufferSlice) -> BufferSliceKey {
|
||||
(
|
||||
buffer_slice.id(),
|
||||
buffer_slice.offset(),
|
||||
buffer_slice.size(),
|
||||
)
|
||||
}
|
||||
|
||||
/// Marks the index `buffer` as bound.
|
||||
fn set_index_buffer(&mut self, buffer_slice: &BufferSlice, index_format: IndexFormat) {
|
||||
self.index_buffer = Some((self.buffer_slice_key(buffer_slice), index_format));
|
||||
self.stores_state = true;
|
||||
}
|
||||
|
||||
/// Checks, whether the index `buffer` is already bound.
|
||||
fn is_index_buffer_set(&self, buffer: &BufferSlice, index_format: IndexFormat) -> bool {
|
||||
self.index_buffer == Some((self.buffer_slice_key(buffer), index_format))
|
||||
}
|
||||
|
||||
/// Resets tracking state
|
||||
pub fn reset_tracking(&mut self) {
|
||||
if !self.stores_state {
|
||||
return;
|
||||
}
|
||||
self.pipeline = None;
|
||||
self.bind_groups.iter_mut().for_each(|val| {
|
||||
val.0 = None;
|
||||
val.1.clear();
|
||||
});
|
||||
self.vertex_buffers.iter_mut().for_each(|val| {
|
||||
*val = None;
|
||||
});
|
||||
self.index_buffer = None;
|
||||
self.stores_state = false;
|
||||
}
|
||||
}
|
||||
|
||||
/// A [`RenderPass`], which tracks the current pipeline state to skip redundant operations.
|
||||
///
|
||||
/// It is used to set the current [`RenderPipeline`], [`BindGroup`]s and [`Buffer`]s.
|
||||
/// After all requirements are specified, draw calls can be issued.
|
||||
pub struct TrackedRenderPass<'a> {
|
||||
pass: RenderPass<'a>,
|
||||
state: DrawState,
|
||||
}
|
||||
|
||||
impl<'a> TrackedRenderPass<'a> {
|
||||
/// Tracks the supplied render pass.
|
||||
pub fn new(device: &RenderDevice, pass: RenderPass<'a>) -> Self {
|
||||
let limits = device.limits();
|
||||
let max_bind_groups = limits.max_bind_groups as usize;
|
||||
let max_vertex_buffers = limits.max_vertex_buffers as usize;
|
||||
Self {
|
||||
state: DrawState {
|
||||
bind_groups: vec![(None, Vec::new()); max_bind_groups],
|
||||
vertex_buffers: vec![None; max_vertex_buffers],
|
||||
..default()
|
||||
},
|
||||
pass,
|
||||
}
|
||||
}
|
||||
|
||||
/// Returns the wgpu [`RenderPass`].
|
||||
///
|
||||
/// Function invalidates internal tracking state,
|
||||
/// some redundant pipeline operations may not be skipped.
|
||||
pub fn wgpu_pass(&mut self) -> &mut RenderPass<'a> {
|
||||
self.state.reset_tracking();
|
||||
&mut self.pass
|
||||
}
|
||||
|
||||
/// Sets the active [`RenderPipeline`].
|
||||
///
|
||||
/// Subsequent draw calls will exhibit the behavior defined by the `pipeline`.
|
||||
pub fn set_render_pipeline(&mut self, pipeline: &'a RenderPipeline) {
|
||||
#[cfg(feature = "detailed_trace")]
|
||||
trace!("set pipeline: {:?}", pipeline);
|
||||
if self.state.is_pipeline_set(pipeline.id()) {
|
||||
return;
|
||||
}
|
||||
self.pass.set_pipeline(pipeline);
|
||||
self.state.set_pipeline(pipeline.id());
|
||||
}
|
||||
|
||||
/// Sets the active bind group for a given bind group index. The bind group layout
|
||||
/// in the active pipeline when any `draw()` function is called must match the layout of
|
||||
/// this bind group.
|
||||
///
|
||||
/// If the bind group have dynamic offsets, provide them in binding order.
|
||||
/// These offsets have to be aligned to [`WgpuLimits::min_uniform_buffer_offset_alignment`](crate::settings::WgpuLimits::min_uniform_buffer_offset_alignment)
|
||||
/// or [`WgpuLimits::min_storage_buffer_offset_alignment`](crate::settings::WgpuLimits::min_storage_buffer_offset_alignment) appropriately.
|
||||
pub fn set_bind_group(
|
||||
&mut self,
|
||||
index: usize,
|
||||
bind_group: &'a BindGroup,
|
||||
dynamic_uniform_indices: &[u32],
|
||||
) {
|
||||
if self
|
||||
.state
|
||||
.is_bind_group_set(index, bind_group.id(), dynamic_uniform_indices)
|
||||
{
|
||||
#[cfg(feature = "detailed_trace")]
|
||||
trace!(
|
||||
"set bind_group {} (already set): {:?} ({:?})",
|
||||
index,
|
||||
bind_group,
|
||||
dynamic_uniform_indices
|
||||
);
|
||||
return;
|
||||
}
|
||||
#[cfg(feature = "detailed_trace")]
|
||||
trace!(
|
||||
"set bind_group {}: {:?} ({:?})",
|
||||
index,
|
||||
bind_group,
|
||||
dynamic_uniform_indices
|
||||
);
|
||||
|
||||
self.pass
|
||||
.set_bind_group(index as u32, bind_group, dynamic_uniform_indices);
|
||||
self.state
|
||||
.set_bind_group(index, bind_group.id(), dynamic_uniform_indices);
|
||||
}
|
||||
|
||||
/// Assign a vertex buffer to a slot.
|
||||
///
|
||||
/// Subsequent calls to [`draw`] and [`draw_indexed`] on this
|
||||
/// [`TrackedRenderPass`] will use `buffer` as one of the source vertex buffers.
|
||||
///
|
||||
/// The `slot_index` refers to the index of the matching descriptor in
|
||||
/// [`VertexState::buffers`](crate::render_resource::VertexState::buffers).
|
||||
///
|
||||
/// [`draw`]: TrackedRenderPass::draw
|
||||
/// [`draw_indexed`]: TrackedRenderPass::draw_indexed
|
||||
pub fn set_vertex_buffer(&mut self, slot_index: usize, buffer_slice: BufferSlice<'a>) {
|
||||
if self.state.is_vertex_buffer_set(slot_index, &buffer_slice) {
|
||||
#[cfg(feature = "detailed_trace")]
|
||||
trace!(
|
||||
"set vertex buffer {} (already set): {:?} (offset = {}, size = {})",
|
||||
slot_index,
|
||||
buffer_slice.id(),
|
||||
buffer_slice.offset(),
|
||||
buffer_slice.size(),
|
||||
);
|
||||
return;
|
||||
}
|
||||
#[cfg(feature = "detailed_trace")]
|
||||
trace!(
|
||||
"set vertex buffer {}: {:?} (offset = {}, size = {})",
|
||||
slot_index,
|
||||
buffer_slice.id(),
|
||||
buffer_slice.offset(),
|
||||
buffer_slice.size(),
|
||||
);
|
||||
|
||||
self.pass
|
||||
.set_vertex_buffer(slot_index as u32, *buffer_slice);
|
||||
self.state.set_vertex_buffer(slot_index, buffer_slice);
|
||||
}
|
||||
|
||||
/// Sets the active index buffer.
|
||||
///
|
||||
/// Subsequent calls to [`TrackedRenderPass::draw_indexed`] will use the buffer referenced by
|
||||
/// `buffer_slice` as the source index buffer.
|
||||
pub fn set_index_buffer(&mut self, buffer_slice: BufferSlice<'a>, index_format: IndexFormat) {
|
||||
let already_set = self.state.is_index_buffer_set(&buffer_slice, index_format);
|
||||
#[cfg(feature = "detailed_trace")]
|
||||
trace!(
|
||||
"set index buffer{}: {:?} (offset = {}, size = {})",
|
||||
if already_set { " (already set)" } else { "" },
|
||||
buffer_slice.id(),
|
||||
buffer_slice.offset(),
|
||||
buffer_slice.size(),
|
||||
);
|
||||
if already_set {
|
||||
return;
|
||||
}
|
||||
self.pass.set_index_buffer(*buffer_slice, index_format);
|
||||
self.state.set_index_buffer(&buffer_slice, index_format);
|
||||
}
|
||||
|
||||
/// Draws primitives from the active vertex buffer(s).
|
||||
///
|
||||
/// The active vertex buffer(s) can be set with [`TrackedRenderPass::set_vertex_buffer`].
|
||||
pub fn draw(&mut self, vertices: Range<u32>, instances: Range<u32>) {
|
||||
#[cfg(feature = "detailed_trace")]
|
||||
trace!("draw: {:?} {:?}", vertices, instances);
|
||||
self.pass.draw(vertices, instances);
|
||||
}
|
||||
|
||||
/// Draws indexed primitives using the active index buffer and the active vertex buffer(s).
|
||||
///
|
||||
/// The active index buffer can be set with [`TrackedRenderPass::set_index_buffer`], while the
|
||||
/// active vertex buffer(s) can be set with [`TrackedRenderPass::set_vertex_buffer`].
|
||||
pub fn draw_indexed(&mut self, indices: Range<u32>, base_vertex: i32, instances: Range<u32>) {
|
||||
#[cfg(feature = "detailed_trace")]
|
||||
trace!(
|
||||
"draw indexed: {:?} {} {:?}",
|
||||
indices,
|
||||
base_vertex,
|
||||
instances
|
||||
);
|
||||
self.pass.draw_indexed(indices, base_vertex, instances);
|
||||
}
|
||||
|
||||
/// Draws primitives from the active vertex buffer(s) based on the contents of the
|
||||
/// `indirect_buffer`.
|
||||
///
|
||||
/// The active vertex buffers can be set with [`TrackedRenderPass::set_vertex_buffer`].
|
||||
///
|
||||
/// The structure expected in `indirect_buffer` is the following:
|
||||
///
|
||||
/// ```
|
||||
/// #[repr(C)]
|
||||
/// struct DrawIndirect {
|
||||
/// vertex_count: u32, // The number of vertices to draw.
|
||||
/// instance_count: u32, // The number of instances to draw.
|
||||
/// first_vertex: u32, // The Index of the first vertex to draw.
|
||||
/// first_instance: u32, // The instance ID of the first instance to draw.
|
||||
/// // has to be 0, unless [`Features::INDIRECT_FIRST_INSTANCE`] is enabled.
|
||||
/// }
|
||||
/// ```
|
||||
pub fn draw_indirect(&mut self, indirect_buffer: &'a Buffer, indirect_offset: u64) {
|
||||
#[cfg(feature = "detailed_trace")]
|
||||
trace!("draw indirect: {:?} {}", indirect_buffer, indirect_offset);
|
||||
self.pass.draw_indirect(indirect_buffer, indirect_offset);
|
||||
}
|
||||
|
||||
/// Draws indexed primitives using the active index buffer and the active vertex buffers,
|
||||
/// based on the contents of the `indirect_buffer`.
|
||||
///
|
||||
/// The active index buffer can be set with [`TrackedRenderPass::set_index_buffer`], while the
|
||||
/// active vertex buffers can be set with [`TrackedRenderPass::set_vertex_buffer`].
|
||||
///
|
||||
/// The structure expected in `indirect_buffer` is the following:
|
||||
///
|
||||
/// ```
|
||||
/// #[repr(C)]
|
||||
/// struct DrawIndexedIndirect {
|
||||
/// vertex_count: u32, // The number of vertices to draw.
|
||||
/// instance_count: u32, // The number of instances to draw.
|
||||
/// first_index: u32, // The base index within the index buffer.
|
||||
/// vertex_offset: i32, // The value added to the vertex index before indexing into the vertex buffer.
|
||||
/// first_instance: u32, // The instance ID of the first instance to draw.
|
||||
/// // has to be 0, unless [`Features::INDIRECT_FIRST_INSTANCE`] is enabled.
|
||||
/// }
|
||||
/// ```
|
||||
pub fn draw_indexed_indirect(&mut self, indirect_buffer: &'a Buffer, indirect_offset: u64) {
|
||||
#[cfg(feature = "detailed_trace")]
|
||||
trace!(
|
||||
"draw indexed indirect: {:?} {}",
|
||||
indirect_buffer,
|
||||
indirect_offset
|
||||
);
|
||||
self.pass
|
||||
.draw_indexed_indirect(indirect_buffer, indirect_offset);
|
||||
}
|
||||
|
||||
/// Dispatches multiple draw calls from the active vertex buffer(s) based on the contents of the
|
||||
/// `indirect_buffer`.`count` draw calls are issued.
|
||||
///
|
||||
/// The active vertex buffers can be set with [`TrackedRenderPass::set_vertex_buffer`].
|
||||
///
|
||||
/// `indirect_buffer` should contain `count` tightly packed elements of the following structure:
|
||||
///
|
||||
/// ```
|
||||
/// #[repr(C)]
|
||||
/// struct DrawIndirect {
|
||||
/// vertex_count: u32, // The number of vertices to draw.
|
||||
/// instance_count: u32, // The number of instances to draw.
|
||||
/// first_vertex: u32, // The Index of the first vertex to draw.
|
||||
/// first_instance: u32, // The instance ID of the first instance to draw.
|
||||
/// // has to be 0, unless [`Features::INDIRECT_FIRST_INSTANCE`] is enabled.
|
||||
/// }
|
||||
/// ```
|
||||
pub fn multi_draw_indirect(
|
||||
&mut self,
|
||||
indirect_buffer: &'a Buffer,
|
||||
indirect_offset: u64,
|
||||
count: u32,
|
||||
) {
|
||||
#[cfg(feature = "detailed_trace")]
|
||||
trace!(
|
||||
"multi draw indirect: {:?} {}, {}x",
|
||||
indirect_buffer,
|
||||
indirect_offset,
|
||||
count
|
||||
);
|
||||
self.pass
|
||||
.multi_draw_indirect(indirect_buffer, indirect_offset, count);
|
||||
}
|
||||
|
||||
/// Dispatches multiple draw calls from the active vertex buffer(s) based on the contents of
|
||||
/// the `indirect_buffer`.
|
||||
/// The count buffer is read to determine how many draws to issue.
|
||||
///
|
||||
/// The indirect buffer must be long enough to account for `max_count` draws, however only
|
||||
/// `count` elements will be read, where `count` is the value read from `count_buffer` capped
|
||||
/// at `max_count`.
|
||||
///
|
||||
/// The active vertex buffers can be set with [`TrackedRenderPass::set_vertex_buffer`].
|
||||
///
|
||||
/// `indirect_buffer` should contain `count` tightly packed elements of the following structure:
|
||||
///
|
||||
/// ```
|
||||
/// #[repr(C)]
|
||||
/// struct DrawIndirect {
|
||||
/// vertex_count: u32, // The number of vertices to draw.
|
||||
/// instance_count: u32, // The number of instances to draw.
|
||||
/// first_vertex: u32, // The Index of the first vertex to draw.
|
||||
/// first_instance: u32, // The instance ID of the first instance to draw.
|
||||
/// // has to be 0, unless [`Features::INDIRECT_FIRST_INSTANCE`] is enabled.
|
||||
/// }
|
||||
/// ```
|
||||
pub fn multi_draw_indirect_count(
|
||||
&mut self,
|
||||
indirect_buffer: &'a Buffer,
|
||||
indirect_offset: u64,
|
||||
count_buffer: &'a Buffer,
|
||||
count_offset: u64,
|
||||
max_count: u32,
|
||||
) {
|
||||
#[cfg(feature = "detailed_trace")]
|
||||
trace!(
|
||||
"multi draw indirect count: {:?} {}, ({:?} {})x, max {}x",
|
||||
indirect_buffer,
|
||||
indirect_offset,
|
||||
count_buffer,
|
||||
count_offset,
|
||||
max_count
|
||||
);
|
||||
self.pass.multi_draw_indirect_count(
|
||||
indirect_buffer,
|
||||
indirect_offset,
|
||||
count_buffer,
|
||||
count_offset,
|
||||
max_count,
|
||||
);
|
||||
}
|
||||
|
||||
/// Dispatches multiple draw calls from the active index buffer and the active vertex buffers,
|
||||
/// based on the contents of the `indirect_buffer`. `count` draw calls are issued.
|
||||
///
|
||||
/// The active index buffer can be set with [`TrackedRenderPass::set_index_buffer`], while the
|
||||
/// active vertex buffers can be set with [`TrackedRenderPass::set_vertex_buffer`].
|
||||
///
|
||||
/// `indirect_buffer` should contain `count` tightly packed elements of the following structure:
|
||||
///
|
||||
/// ```
|
||||
/// #[repr(C)]
|
||||
/// struct DrawIndexedIndirect {
|
||||
/// vertex_count: u32, // The number of vertices to draw.
|
||||
/// instance_count: u32, // The number of instances to draw.
|
||||
/// first_index: u32, // The base index within the index buffer.
|
||||
/// vertex_offset: i32, // The value added to the vertex index before indexing into the vertex buffer.
|
||||
/// first_instance: u32, // The instance ID of the first instance to draw.
|
||||
/// // has to be 0, unless [`Features::INDIRECT_FIRST_INSTANCE`] is enabled.
|
||||
/// }
|
||||
/// ```
|
||||
pub fn multi_draw_indexed_indirect(
|
||||
&mut self,
|
||||
indirect_buffer: &'a Buffer,
|
||||
indirect_offset: u64,
|
||||
count: u32,
|
||||
) {
|
||||
#[cfg(feature = "detailed_trace")]
|
||||
trace!(
|
||||
"multi draw indexed indirect: {:?} {}, {}x",
|
||||
indirect_buffer,
|
||||
indirect_offset,
|
||||
count
|
||||
);
|
||||
self.pass
|
||||
.multi_draw_indexed_indirect(indirect_buffer, indirect_offset, count);
|
||||
}
|
||||
|
||||
/// Dispatches multiple draw calls from the active index buffer and the active vertex buffers,
|
||||
/// based on the contents of the `indirect_buffer`.
|
||||
/// The count buffer is read to determine how many draws to issue.
|
||||
///
|
||||
/// The indirect buffer must be long enough to account for `max_count` draws, however only
|
||||
/// `count` elements will be read, where `count` is the value read from `count_buffer` capped
|
||||
/// at `max_count`.
|
||||
///
|
||||
/// The active index buffer can be set with [`TrackedRenderPass::set_index_buffer`], while the
|
||||
/// active vertex buffers can be set with [`TrackedRenderPass::set_vertex_buffer`].
|
||||
///
|
||||
/// `indirect_buffer` should contain `count` tightly packed elements of the following structure:
|
||||
///
|
||||
/// ```
|
||||
/// #[repr(C)]
|
||||
/// struct DrawIndexedIndirect {
|
||||
/// vertex_count: u32, // The number of vertices to draw.
|
||||
/// instance_count: u32, // The number of instances to draw.
|
||||
/// first_index: u32, // The base index within the index buffer.
|
||||
/// vertex_offset: i32, // The value added to the vertex index before indexing into the vertex buffer.
|
||||
/// first_instance: u32, // The instance ID of the first instance to draw.
|
||||
/// // has to be 0, unless [`Features::INDIRECT_FIRST_INSTANCE`] is enabled.
|
||||
/// }
|
||||
/// ```
|
||||
pub fn multi_draw_indexed_indirect_count(
|
||||
&mut self,
|
||||
indirect_buffer: &'a Buffer,
|
||||
indirect_offset: u64,
|
||||
count_buffer: &'a Buffer,
|
||||
count_offset: u64,
|
||||
max_count: u32,
|
||||
) {
|
||||
#[cfg(feature = "detailed_trace")]
|
||||
trace!(
|
||||
"multi draw indexed indirect count: {:?} {}, ({:?} {})x, max {}x",
|
||||
indirect_buffer,
|
||||
indirect_offset,
|
||||
count_buffer,
|
||||
count_offset,
|
||||
max_count
|
||||
);
|
||||
self.pass.multi_draw_indexed_indirect_count(
|
||||
indirect_buffer,
|
||||
indirect_offset,
|
||||
count_buffer,
|
||||
count_offset,
|
||||
max_count,
|
||||
);
|
||||
}
|
||||
|
||||
/// Sets the stencil reference.
|
||||
///
|
||||
/// Subsequent stencil tests will test against this value.
|
||||
pub fn set_stencil_reference(&mut self, reference: u32) {
|
||||
#[cfg(feature = "detailed_trace")]
|
||||
trace!("set stencil reference: {}", reference);
|
||||
self.pass.set_stencil_reference(reference);
|
||||
}
|
||||
|
||||
/// Sets the scissor region.
|
||||
///
|
||||
/// Subsequent draw calls will discard any fragments that fall outside this region.
|
||||
pub fn set_scissor_rect(&mut self, x: u32, y: u32, width: u32, height: u32) {
|
||||
#[cfg(feature = "detailed_trace")]
|
||||
trace!("set_scissor_rect: {} {} {} {}", x, y, width, height);
|
||||
self.pass.set_scissor_rect(x, y, width, height);
|
||||
}
|
||||
|
||||
/// Set push constant data.
|
||||
///
|
||||
/// `Features::PUSH_CONSTANTS` must be enabled on the device in order to call these functions.
|
||||
pub fn set_push_constants(&mut self, stages: ShaderStages, offset: u32, data: &[u8]) {
|
||||
#[cfg(feature = "detailed_trace")]
|
||||
trace!(
|
||||
"set push constants: {:?} offset: {} data.len: {}",
|
||||
stages,
|
||||
offset,
|
||||
data.len()
|
||||
);
|
||||
self.pass.set_push_constants(stages, offset, data);
|
||||
}
|
||||
|
||||
/// Set the rendering viewport.
|
||||
///
|
||||
/// Subsequent draw calls will be projected into that viewport.
|
||||
pub fn set_viewport(
|
||||
&mut self,
|
||||
x: f32,
|
||||
y: f32,
|
||||
width: f32,
|
||||
height: f32,
|
||||
min_depth: f32,
|
||||
max_depth: f32,
|
||||
) {
|
||||
#[cfg(feature = "detailed_trace")]
|
||||
trace!(
|
||||
"set viewport: {} {} {} {} {} {}",
|
||||
x,
|
||||
y,
|
||||
width,
|
||||
height,
|
||||
min_depth,
|
||||
max_depth
|
||||
);
|
||||
self.pass
|
||||
.set_viewport(x, y, width, height, min_depth, max_depth);
|
||||
}
|
||||
|
||||
/// Set the rendering viewport to the given camera [`Viewport`].
|
||||
///
|
||||
/// Subsequent draw calls will be projected into that viewport.
|
||||
pub fn set_camera_viewport(&mut self, viewport: &Viewport) {
|
||||
self.set_viewport(
|
||||
viewport.physical_position.x as f32,
|
||||
viewport.physical_position.y as f32,
|
||||
viewport.physical_size.x as f32,
|
||||
viewport.physical_size.y as f32,
|
||||
viewport.depth.start,
|
||||
viewport.depth.end,
|
||||
);
|
||||
}
|
||||
|
||||
/// Insert a single debug marker.
|
||||
///
|
||||
/// This is a GPU debugging feature. This has no effect on the rendering itself.
|
||||
pub fn insert_debug_marker(&mut self, label: &str) {
|
||||
#[cfg(feature = "detailed_trace")]
|
||||
trace!("insert debug marker: {}", label);
|
||||
self.pass.insert_debug_marker(label);
|
||||
}
|
||||
|
||||
/// Start a new debug group.
|
||||
///
|
||||
/// Push a new debug group over the internal stack. Subsequent render commands and debug
|
||||
/// markers are grouped into this new group, until [`pop_debug_group`] is called.
|
||||
///
|
||||
/// ```
|
||||
/// # fn example(mut pass: bevy_render::render_phase::TrackedRenderPass<'static>) {
|
||||
/// pass.push_debug_group("Render the car");
|
||||
/// // [setup pipeline etc...]
|
||||
/// pass.draw(0..64, 0..1);
|
||||
/// pass.pop_debug_group();
|
||||
/// # }
|
||||
/// ```
|
||||
///
|
||||
/// Note that [`push_debug_group`] and [`pop_debug_group`] must always be called in pairs.
|
||||
///
|
||||
/// This is a GPU debugging feature. This has no effect on the rendering itself.
|
||||
///
|
||||
/// [`push_debug_group`]: TrackedRenderPass::push_debug_group
|
||||
/// [`pop_debug_group`]: TrackedRenderPass::pop_debug_group
|
||||
pub fn push_debug_group(&mut self, label: &str) {
|
||||
#[cfg(feature = "detailed_trace")]
|
||||
trace!("push_debug_group marker: {}", label);
|
||||
self.pass.push_debug_group(label);
|
||||
}
|
||||
|
||||
/// End the current debug group.
|
||||
///
|
||||
/// Subsequent render commands and debug markers are not grouped anymore in
|
||||
/// this group, but in the previous one (if any) or the default top-level one
|
||||
/// if the debug group was the last one on the stack.
|
||||
///
|
||||
/// Note that [`push_debug_group`] and [`pop_debug_group`] must always be called in pairs.
|
||||
///
|
||||
/// This is a GPU debugging feature. This has no effect on the rendering itself.
|
||||
///
|
||||
/// [`push_debug_group`]: TrackedRenderPass::push_debug_group
|
||||
/// [`pop_debug_group`]: TrackedRenderPass::pop_debug_group
|
||||
pub fn pop_debug_group(&mut self) {
|
||||
#[cfg(feature = "detailed_trace")]
|
||||
trace!("pop_debug_group");
|
||||
self.pass.pop_debug_group();
|
||||
}
|
||||
|
||||
/// Sets the blend color as used by some of the blending modes.
|
||||
///
|
||||
/// Subsequent blending tests will test against this value.
|
||||
pub fn set_blend_constant(&mut self, color: LinearRgba) {
|
||||
#[cfg(feature = "detailed_trace")]
|
||||
trace!("set blend constant: {:?}", color);
|
||||
self.pass.set_blend_constant(wgpu::Color::from(color));
|
||||
}
|
||||
}
|
||||
|
||||
impl WriteTimestamp for TrackedRenderPass<'_> {
|
||||
fn write_timestamp(&mut self, query_set: &QuerySet, index: u32) {
|
||||
self.pass.write_timestamp(query_set, index);
|
||||
}
|
||||
}
|
||||
|
||||
impl WritePipelineStatistics for TrackedRenderPass<'_> {
|
||||
fn begin_pipeline_statistics_query(&mut self, query_set: &QuerySet, index: u32) {
|
||||
self.pass.begin_pipeline_statistics_query(query_set, index);
|
||||
}
|
||||
|
||||
fn end_pipeline_statistics_query(&mut self) {
|
||||
self.pass.end_pipeline_statistics_query();
|
||||
}
|
||||
}
|
||||
|
||||
impl Pass for TrackedRenderPass<'_> {
|
||||
const KIND: PassKind = PassKind::Render;
|
||||
}
|
||||
+1911
File diff suppressed because it is too large.
Load diff
@@ -0,0 +1,39 @@
|
||||
use bevy_math::{Affine3A, Mat4, Vec3, Vec4};
|
||||
|
||||
/// A distance calculator for the draw order of [`PhaseItem`](crate::render_phase::PhaseItem)s.
|
||||
pub struct ViewRangefinder3d {
|
||||
view_from_world_row_2: Vec4,
|
||||
}
|
||||
|
||||
impl ViewRangefinder3d {
|
||||
/// Creates a 3D rangefinder for a view matrix.
|
||||
pub fn from_world_from_view(world_from_view: &Affine3A) -> ViewRangefinder3d {
|
||||
let view_from_world = world_from_view.inverse();
|
||||
|
||||
ViewRangefinder3d {
|
||||
view_from_world_row_2: Mat4::from(view_from_world).row(2),
|
||||
}
|
||||
}
|
||||
|
||||
/// Calculates the distance, or view-space `Z` value, for the given world-space `position`.
|
||||
#[inline]
|
||||
pub fn distance(&self, position: &Vec3) -> f32 {
|
||||
// NOTE: row 2 of the inverse view matrix dotted with the world-space position
|
||||
// gives the z component of the point in view-space
|
||||
self.view_from_world_row_2.dot(position.extend(1.0))
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::ViewRangefinder3d;
|
||||
use bevy_math::{Affine3A, Vec3};
|
||||
|
||||
#[test]
|
||||
fn distance() {
|
||||
let view_matrix = Affine3A::from_translation(Vec3::new(0.0, 0.0, -1.0));
|
||||
let rangefinder = ViewRangefinder3d::from_world_from_view(&view_matrix);
|
||||
assert_eq!(rangefinder.distance(&Vec3::new(0., 0., 0.)), 1.0);
|
||||
assert_eq!(rangefinder.distance(&Vec3::new(0., 0., 1.)), 2.0);
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user