10416102820

Committed 16 Aug 2024 07:07AM UTC coverage: 59.11% (-0.8%) from 59.863%

Build # 10416102820

Build Type

Pull #367

github

Committed by

web-flow

Commit Message

Merge 86cb76186 into b5eeb34cf

Pull Request Pull Request #367: Add support for texture sampling as expression

Run Details

52 of 204 new or added lines in 8 files covered. (25.49%)

3 existing lines in 2 files now uncovered.

3494 of 5911 relevant lines covered (59.11%)

23.05 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

0.0

/src/render/batch.rs

use std::ops::{Index, Range};

#[cfg(feature = "2d")]
use bevy::math::FloatOrd;
use bevy::{
    prelude::*,
    render::render_resource::{Buffer, CachedComputePipelineId},
};

use super::{
    effect_cache::{DispatchBufferIndices, EffectSlices},
    EffectCacheId, GpuCompressedTransform, LayoutFlags,
};
use crate::{AlphaMode, EffectAsset, EffectShader, ParticleLayout, PropertyLayout, TextureLayout};

/// Data needed to render all batches pertaining to a specific effect.
#[derive(Debug, Component)]
pub(crate) struct EffectBatches {
    /// Handle of the underlying effect asset describing the effect.
    pub handle: Handle<EffectAsset>,
    /// One batch per particle group.
    pub group_batches: Vec<EffectBatch>,
    /// Index of the buffer.
    pub buffer_index: u32,
    /// Index of the first Spawner of the effects in the batch.
    pub spawner_base: u32,
    /// Number of particles to spawn/init this frame.
    pub spawn_count: u32,
    /// The effect cache ID.
    pub effect_cache_id: EffectCacheId,
    /// The indices within the various indirect dispatch buffers.
    pub dispatch_buffer_indices: DispatchBufferIndices,
    /// The index of the first [`GpuParticleGroup`] structure in the global
    /// [`EffectsMeta::particle_group_buffer`] buffer. The buffer is currently
    /// re-created each frame, so the rows for multiple groups of an effect are
    /// guaranteed to be contiguous.
    pub first_particle_group_buffer_index: u32,
    /// Particle layout.
    pub particle_layout: ParticleLayout,
    /// Flags describing the render layout.
    pub layout_flags: LayoutFlags,
    /// Texture layout.
    pub texture_layout: TextureLayout,
    /// Textures.
    pub textures: Vec<Handle<Image>>,
    /// Alpha mode.
    pub alpha_mode: AlphaMode,
    /// Entities holding the source [`ParticleEffect`] instances which were
    /// batched into this single batch. Used to determine visibility per view.
    ///
    /// [`ParticleEffect`]: crate::ParticleEffect
    pub entities: Vec<u32>,
    /// Configured shaders used for the particle rendering of this batch.
    /// Note that we don't need to keep the init/update shaders alive because
    /// their pipeline specialization is doing it via the specialization key.
    pub render_shaders: Vec<Handle<Shader>>,
    /// Init compute pipeline specialized for this batch.
    pub init_pipeline_id: CachedComputePipelineId,
    /// Update compute pipeline specialized for this batch.
    pub update_pipeline_ids: Vec<CachedComputePipelineId>,
}

impl Index<u32> for EffectBatches {
    type Output = EffectBatch;

    fn index(&self, index: u32) -> &Self::Output {
        &self.group_batches[index as usize]
    }
}

/// Single effect batch to drive rendering.
///
/// This component is spawned into the render world during the prepare phase
/// ([`prepare_effects()`]), once per effect batch per group. In turns it
/// references an [`EffectBatches`] component containing all the shared data for
/// all the groups of the effect.
#[derive(Debug, Component)]
pub(crate) struct EffectDrawBatch {
    /// Group index of the batch.
    pub group_index: u32,
    /// Entity holding the [`EffectBatches`] this batch is part of.
    pub batches_entity: Entity,
    /// For 2D rendering, the Z coordinate used as the sort key. Ignored for 3D
    /// rendering.
    #[cfg(feature = "2d")]
    pub z_sort_key_2d: FloatOrd,
    /// For 3d rendering, the position of the emitter so we can compute distance
    /// to camera. Ignored for 2D rendering.
    #[cfg(feature = "3d")]
    pub translation_3d: Vec3,
}

/// Batch data specific to a single particle group.
#[derive(Debug)]
pub(crate) struct EffectBatch {
    /// Slice of particles in the GPU effect buffer for the entire batch.
    pub slice: Range<u32>,
}

impl EffectBatches {
    /// Create a new batch from a single input.
    pub fn from_input(
        input: BatchesInput,
        spawner_base: u32,
        effect_cache_id: EffectCacheId,
        init_pipeline_id: CachedComputePipelineId,
        update_pipeline_ids: Vec<CachedComputePipelineId>,
        dispatch_buffer_indices: DispatchBufferIndices,
        first_particle_group_buffer_index: u32,
    ) -> EffectBatches {
        EffectBatches {
            buffer_index: input.effect_slices.buffer_index,
            spawner_base,
            spawn_count: input.spawn_count,
            particle_layout: input.effect_slices.particle_layout,
            effect_cache_id,
            dispatch_buffer_indices,
            first_particle_group_buffer_index,
            group_batches: input
                .effect_slices
                .slices
                .windows(2)
                .map(|range| EffectBatch {
                    slice: range[0]..range[1],
                })
                .collect(),
            handle: input.handle,
            layout_flags: input.layout_flags,
            texture_layout: input.texture_layout,
            textures: input.textures,
            alpha_mode: input.alpha_mode,
            render_shaders: input.effect_shader.render,
            init_pipeline_id,
            update_pipeline_ids,
            entities: vec![input.entity.index()],
        }
    }
}

/// Effect batching input, obtained from extracted effects.
#[derive(Debug, Clone)]
pub(crate) struct BatchesInput {
    /// Handle of the underlying effect asset describing the effect.
    pub handle: Handle<EffectAsset>,
    /// Entity index excluding generation ([`Entity::index()`]). This is
    /// transient for a single frame, so the generation is useless.
    pub entity: Entity,
    /// Effect slices.
    pub effect_slices: EffectSlices,
    /// Layout of the effect properties.
    pub property_layout: PropertyLayout,
    /// Effect shader.
    pub effect_shader: EffectShader,
    /// Various flags related to the effect.
    pub layout_flags: LayoutFlags,
    /// Texture layout.
    pub texture_layout: TextureLayout,
    /// Textures.
    pub textures: Vec<Handle<Image>>,
    /// Alpha mode.
    pub alpha_mode: AlphaMode,
    /// Number of particles to spawn for this effect.
    pub spawn_count: u32,
    /// Emitter transform.
    pub transform: GpuCompressedTransform,
    /// Emitter inverse transform.
    pub inverse_transform: GpuCompressedTransform,
    /// GPU buffer where properties for this batch need to be written.
    pub property_buffer: Option<Buffer>,
    /// Serialized property data.
    // FIXME - Contains a single effect's data; should handle multiple ones.
    pub property_data: Option<Vec<u8>>,
    /// Sort key, for 2D only.
    #[cfg(feature = "2d")]
    pub z_sort_key_2d: FloatOrd,
}

1	use std::ops::{Index, Range};
2
3	#[cfg(feature = "2d")]
4	use bevy::math::FloatOrd;
5	use bevy::{
6	prelude::*,
7	render::render_resource::{Buffer, CachedComputePipelineId},
8	};
9
10	use super::{
11	effect_cache::{DispatchBufferIndices, EffectSlices},
12	EffectCacheId, GpuCompressedTransform, LayoutFlags,
13	};
14	use crate::{AlphaMode, EffectAsset, EffectShader, ParticleLayout, PropertyLayout, TextureLayout};
15
16	/// Data needed to render all batches pertaining to a specific effect.
17	#[derive(Debug, Component)]
18	pub(crate) struct EffectBatches {
19	/// Handle of the underlying effect asset describing the effect.
20	pub handle: Handle<EffectAsset>,
21	/// One batch per particle group.
22	pub group_batches: Vec<EffectBatch>,
23	/// Index of the buffer.
24	pub buffer_index: u32,
25	/// Index of the first Spawner of the effects in the batch.
26	pub spawner_base: u32,
27	/// Number of particles to spawn/init this frame.
28	pub spawn_count: u32,
29	/// The effect cache ID.
30	pub effect_cache_id: EffectCacheId,
31	/// The indices within the various indirect dispatch buffers.
32	pub dispatch_buffer_indices: DispatchBufferIndices,
33	/// The index of the first [`GpuParticleGroup`] structure in the global
34	/// [`EffectsMeta::particle_group_buffer`] buffer. The buffer is currently
35	/// re-created each frame, so the rows for multiple groups of an effect are
36	/// guaranteed to be contiguous.
37	pub first_particle_group_buffer_index: u32,
38	/// Particle layout.
39	pub particle_layout: ParticleLayout,
40	/// Flags describing the render layout.
41	pub layout_flags: LayoutFlags,
42	/// Texture layout.
43	pub texture_layout: TextureLayout,
44	/// Textures.
45	pub textures: Vec<Handle<Image>>,
46	/// Alpha mode.
47	pub alpha_mode: AlphaMode,
48	/// Entities holding the source [`ParticleEffect`] instances which were
49	/// batched into this single batch. Used to determine visibility per view.
50	///
51	/// [`ParticleEffect`]: crate::ParticleEffect
52	pub entities: Vec<u32>,
53	/// Configured shaders used for the particle rendering of this batch.
54	/// Note that we don't need to keep the init/update shaders alive because
55	/// their pipeline specialization is doing it via the specialization key.
56	pub render_shaders: Vec<Handle<Shader>>,
57	/// Init compute pipeline specialized for this batch.
58	pub init_pipeline_id: CachedComputePipelineId,
59	/// Update compute pipeline specialized for this batch.
60	pub update_pipeline_ids: Vec<CachedComputePipelineId>,
61	}
62
63	impl Index<u32> for EffectBatches {
64	type Output = EffectBatch;
65
66	fn index(&self, index: u32) -> &Self::Output {	×
67	&self.group_batches[index as usize]	×
68	}
69	}
70
71	/// Single effect batch to drive rendering.
72	///
73	/// This component is spawned into the render world during the prepare phase
74	/// ([`prepare_effects()`]), once per effect batch per group. In turns it
75	/// references an [`EffectBatches`] component containing all the shared data for
76	/// all the groups of the effect.
77	#[derive(Debug, Component)]
78	pub(crate) struct EffectDrawBatch {
79	/// Group index of the batch.
80	pub group_index: u32,
81	/// Entity holding the [`EffectBatches`] this batch is part of.
82	pub batches_entity: Entity,
83	/// For 2D rendering, the Z coordinate used as the sort key. Ignored for 3D
84	/// rendering.
85	#[cfg(feature = "2d")]
86	pub z_sort_key_2d: FloatOrd,
87	/// For 3d rendering, the position of the emitter so we can compute distance
88	/// to camera. Ignored for 2D rendering.
89	#[cfg(feature = "3d")]
90	pub translation_3d: Vec3,
91	}
92
93	/// Batch data specific to a single particle group.
94	#[derive(Debug)]
95	pub(crate) struct EffectBatch {
96	/// Slice of particles in the GPU effect buffer for the entire batch.
97	pub slice: Range<u32>,
98	}
99
100	impl EffectBatches {
101	/// Create a new batch from a single input.
102	pub fn from_input(	×
103	input: BatchesInput,
104	spawner_base: u32,
105	effect_cache_id: EffectCacheId,
106	init_pipeline_id: CachedComputePipelineId,
107	update_pipeline_ids: Vec<CachedComputePipelineId>,
108	dispatch_buffer_indices: DispatchBufferIndices,
109	first_particle_group_buffer_index: u32,
110	) -> EffectBatches {
111	EffectBatches {
112	buffer_index: input.effect_slices.buffer_index,	×
113	spawner_base,
114	spawn_count: input.spawn_count,	×
115	particle_layout: input.effect_slices.particle_layout,	×
116	effect_cache_id,
117	dispatch_buffer_indices,
118	first_particle_group_buffer_index,
119	group_batches: input	×
120	.effect_slices
121	.slices
122	.windows(2)
123	.map(\|range\| EffectBatch {
124	slice: range[0]..range[1],
125	})
126	.collect(),
127	handle: input.handle,	×
128	layout_flags: input.layout_flags,	×
NEW 129	texture_layout: input.texture_layout,	×
NEW 130	textures: input.textures,	×
131	alpha_mode: input.alpha_mode,	×
132	render_shaders: input.effect_shader.render,	×
133	init_pipeline_id,
134	update_pipeline_ids,
135	entities: vec![input.entity.index()],	×
136	}
137	}
138	}
139
140	/// Effect batching input, obtained from extracted effects.
141	#[derive(Debug, Clone)]
142	pub(crate) struct BatchesInput {
143	/// Handle of the underlying effect asset describing the effect.
144	pub handle: Handle<EffectAsset>,
145	/// Entity index excluding generation ([`Entity::index()`]). This is
146	/// transient for a single frame, so the generation is useless.
147	pub entity: Entity,
148	/// Effect slices.
149	pub effect_slices: EffectSlices,
150	/// Layout of the effect properties.
151	pub property_layout: PropertyLayout,
152	/// Effect shader.
153	pub effect_shader: EffectShader,
154	/// Various flags related to the effect.
155	pub layout_flags: LayoutFlags,
156	/// Texture layout.
157	pub texture_layout: TextureLayout,
158	/// Textures.
159	pub textures: Vec<Handle<Image>>,
160	/// Alpha mode.
161	pub alpha_mode: AlphaMode,
162	/// Number of particles to spawn for this effect.
163	pub spawn_count: u32,
164	/// Emitter transform.
165	pub transform: GpuCompressedTransform,
166	/// Emitter inverse transform.
167	pub inverse_transform: GpuCompressedTransform,
168	/// GPU buffer where properties for this batch need to be written.
169	pub property_buffer: Option<Buffer>,
170	/// Serialized property data.
171	// FIXME - Contains a single effect's data; should handle multiple ones.
172	pub property_data: Option<Vec<u8>>,
173	/// Sort key, for 2D only.
174	#[cfg(feature = "2d")]
175	pub z_sort_key_2d: FloatOrd,
176	}

djeedai / bevy_hanabi / 10416102820

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous