Render a 2D Mesh to a texture/image

[bilowik]

This is probably a far more complex question than it seems and may not be feasible. I've been digging through the source trying to find how a Mesh (probably generically as a RenderAsset::PreparedAsset) gets sent to the underlying wgpu device for rendering but have been struggling.

I've seen the render_to_texture example, which is great for many things, but it involves creating a camera to look at a specific position and rendering what is at that position. To get a clean render of just the one Mesh, would need to move it far away, ensure it is not overlapping with anything else after that move, wait a frame for it to render to the texture. I am wondering if in the case of just a single Mesh, is there a better approach?

Thanks for taking the time to read this!

[nicopap]

I don't understand your question. I think in all this rambling, you forgot to ask precisely what you were looking for :)

Anyway

1 - How to render something with one camera but not another

Use the RenderLayers component. You can set your "render-to-texture" camera and what it is supposed to render to a singular RenderLayer, separated from all the other entities layers. This way, you'll have a separate view of the object in question

2 - How does bevy rendering works

Vast question! I'm going to do a very high level bird's eye view here, otherwise I'll have to write an entire book.

1. Extract mesh into the render world: Meshes are an Asset, and as you astutely already noted, they are passed to the render world through their RenderAsset dark world render world counterpart. What is accessed by the render world is not a Mesh, but a GpuMesh, the transformation is done at the extraction stage.
2. Tell wgpu to render the mesh: Yeah that's it. The bit of code you are looking for is in bevy_pbr/src/render/mesh.rs. This was my first contribution to bevy, 2 years ago now!

bevy/crates/bevy_pbr/src/render/mesh.rs

Lines 1251 to 1269 in 9478432

	if let Some(gpu_mesh) = meshes.into_inner().get(mesh_handle) {
	pass.set_vertex_buffer(0, gpu_mesh.vertex_buffer.slice(..));
	match &gpu_mesh.buffer_info {
	GpuBufferInfo::Indexed {
	buffer,
	index_format,
	count,
	} => {
	pass.set_index_buffer(buffer.slice(..), 0, *index_format);
	pass.draw_indexed(0..*count, 0, 0..1);
	}
	GpuBufferInfo::NonIndexed => {
	pass.draw(0..gpu_mesh.vertex_count, 0..1);
	}
	}
	RenderCommandResult::Success
	} else {
	RenderCommandResult::Failure
	}

3. Create a render command with DrawMesh: We have the code, but it needs to be ran, where is it ran? Well, first we make DrawMesh part of a larger render command:

bevy/crates/bevy_pbr/src/material.rs

Lines 342 to 348 in 9478432

	type DrawMaterial<M> = (
	SetItemPipeline,
	SetMeshViewBindGroup<0>,
	SetMaterialBindGroup<M, 1>,
	SetMeshBindGroup<2>,
	DrawMesh,
	);

4. Add the command to a render phase: Bevy's rendering uses RenderGraph. A graph is made of Nodes, nodes are basically "render passes" that implement ViewNode, which seems to mostly be worried about calling RenderPhase<I> for a specific I that implements PhaseItem. What's the relationship with DrawMaterial? Well, DrawMaterial is a RenderCommand, which is associated with a specific PhaseItem. Here we associate DrawMaterial with three different PhaseItems: Transparent3d, Opaque3d and AlphaMask3d. More on this later.

bevy/crates/bevy_pbr/src/material.rs

Lines 194 to 199 in 9478432

	render_app
	.init_resource::<DrawFunctions<Shadow>>()
	.add_render_command::<Shadow, DrawPrepass<M>>()
	.add_render_command::<Transparent3d, DrawMaterial<M>>()
	.add_render_command::<Opaque3d, DrawMaterial<M>>()
	.add_render_command::<AlphaMask3d, DrawMaterial<M>>()

5. Create a node to access the render phase: To run any rendering code, we need to add it as node to the RenderGraph. bevy defines a set of default nodes in bevy_core_pipeline, one of which is MainOpaquePass3dNode.

bevy/crates/bevy_core_pipeline/src/core_3d/main_opaque_pass_3d_node.rs

Line 25 in 9478432

pub struct MainOpaquePass3dNode;

6. In ViewNode: create a render pass: There is a lot of shared boilerplate between different Nodes. So bevy defines a wrapper type ViewNodeRunner that does the shared boilerplate. The unique work is implemented in the ViewNode trait implementation. Generally, nodes create render passes and execute them. Render passes are a webGPU concept, I'm not quite familiar with it.

bevy/crates/bevy_core_pipeline/src/core_3d/main_opaque_pass_3d_node.rs

Lines 68 to 102 in 9478432

	let mut render_pass = render_context.begin_tracked_render_pass(RenderPassDescriptor {
	label: Some("main_opaque_pass_3d"),
	// NOTE: The opaque pass loads the color
	// buffer as well as writing to it.
	color_attachments: &[Some(target.get_color_attachment(Operations {
	load: match camera_3d.clear_color {
	ClearColorConfig::Default => {
	LoadOp::Clear(world.resource::<ClearColor>().0.into())
	}
	ClearColorConfig::Custom(color) => LoadOp::Clear(color.into()),
	ClearColorConfig::None => LoadOp::Load,
	},
	store: true,
	}))],
	depth_stencil_attachment: Some(RenderPassDepthStencilAttachment {
	view: &depth.view,
	// NOTE: The opaque main pass loads the depth buffer and possibly overwrites it
	depth_ops: Some(Operations {
	load: if depth_prepass.is_some()
	|| normal_prepass.is_some()
	|| motion_vector_prepass.is_some()
	{
	// if any prepass runs, it will generate a depth buffer so we should use it,
	// even if only the normal_prepass is used.
	Camera3dDepthLoadOp::Load
	} else {
	// NOTE: 0.0 is the far plane due to bevy's use of reverse-z projections.
	camera_3d.depth_load_op.clone()
	}
	.into(),
	store: true,
	}),
	stencil_ops: None,
	}),
	});

7. In ViewNode: call PhaseItem::render on RenderPhase: RenderPhase is a component. They are added to the render-world equivalent of cameras. Each view may have several RenderPhases of different types. RenderPhase is a collection of PhaseItems, according to the docs, each PhaseItem is an "renderable" entity that is visible from the camera, one needs to add them manually in queue systems.

bevy/crates/bevy_core_pipeline/src/core_3d/main_opaque_pass_3d_node.rs

Lines 110 to 111 in 9478432

	// Opaque draws
	opaque_phase.render(&mut render_pass, world, view_entity);

8. In PhaseItem::render, call the draw method on all the render phase items: This is complicated I think I'm lost here. Somehow, the DrawMesh ended up in a resource of type DrawFunctions<I>. DrawFunction stores a Vec<Box<dyn Draw>>. DrawMesh does not itself implement Draw, but it implements RenderCommand. The documentation on RenderCommand hints that somehow it was associated with a RenderCommandState and added to this DrawFunctions resource. But I can't identify the code that does that.

bevy/crates/bevy_render/src/render_phase/mod.rs

Lines 77 to 91 in 9478432

	pub fn render<'w>(
	&self,
	render_pass: &mut TrackedRenderPass<'w>,
	world: &'w World,
	view: Entity,
	) {
	let draw_functions = world.resource::<DrawFunctions<I>>();
	let mut draw_functions = draw_functions.write();
	draw_functions.prepare(world);
	for item in &self.items {
	let draw_function = draw_functions.get_mut(item.draw_function()).unwrap();
	draw_function.draw(world, render_pass, view, item);
	}
	}

I find myself in a maze of little twisty passages, and I'm utterly lost. I can't go forward on this. But I think this should close the loop, as DrawFunctions::draw calls the RenderCommands::render method, which is the function we read at point (2) of this exposé.

bevy/crates/bevy_render/src/render_phase/draw.rs

Lines 260 to 272 in 9478432

	fn draw<'w>(
	&mut self,
	world: &'w World,
	pass: &mut TrackedRenderPass<'w>,
	view: Entity,
	item: &P,
	) {
	let param = self.state.get_manual(world);
	let view = self.view.get_manual(world, view).unwrap();
	let entity = self.entity.get_manual(world, item.entity()).unwrap();
	// TODO: handle/log `RenderCommand` failure
	C::render(item, view, entity, param, pass);
	}

[bilowik]

Apologies for the rambling. The main question I was asking was how the GPUMesh was processed and passed to the underlying wgpu device, the code I was looking was in that first code block, hadn't looked in bevy_pbr yet so that explains why I hadn't found it. The additional context will also be super helpful thanks!

[re0312]

thanks ,really useful to me