Add texture pool to render cache node

[TrueDoctor]

Reuse existing but no longer used viewport textures to reduce memory consumption while waiting for a gc on web

[gemini-code-assist]

Summary of Changes

Hello @TrueDoctor, I'm Gemini Code Assist¹! I'm currently reviewing this pull request and will post my feedback shortly. In the meantime, here's a summary to help you and other reviewers quickly get up to speed!

This pull request significantly optimizes memory management within the rendering pipeline by implementing a texture pooling system. By leveraging Arc for shared ownership of wgpu::Texture objects, the system can now reuse textures that are no longer in active use, thereby reducing the frequency of new texture allocations. This change is particularly beneficial for web platforms where memory garbage collection can be a performance bottleneck, leading to a smoother and more efficient user experience.

Highlights

• Texture Pooling Implementation: Introduced a texture pooling mechanism in TileCacheImpl to reuse wgpu::Texture instances, reducing memory allocations and improving performance, especially for web environments.
• Shared Ownership for Textures: Migrated several wgpu::Texture fields and parameters across the codebase to use std::sync::Arc<wgpu::Texture>, enabling shared ownership and facilitating texture reuse.
• Refactored Texture Compositing: The composite_cached_regions function was updated to accept a pre-allocated wgpu::Texture from the new texture pool, rather than creating a new one each time.
• ImageTexture Updates: The ImageTexture struct now holds an Arc<wgpu::Texture> and derives DynAny for improved type handling.

Changelog

• desktop/src/render/state.rs
  • Updated transparent_texture and viewport_texture fields to use std::sync::Arc<wgpu::Texture>.
  • Wrapped the creation of transparent_texture in Arc::new().
  • Modified bind_viewport_texture to accept std::sync::Arc<wgpu::Texture>.
• desktop/wrapper/src/lib.rs
  • Changed the HasRun variant of NodeGraphExecutionResult to hold an Option<std::sync::Arc<wgpu::Texture>>.
• editor/src/node_graph_executor/runtime.rs
  • Added a new field current_viewport_texture: Option<ImageTexture> to NodeRuntime.
  • Initialized current_viewport_texture to None in the NodeRuntime::new constructor.
  • Modified calls to Raster::new_gpu to clone the Arc reference from image_texture.texture.
  • Stored the image_texture in current_viewport_texture after rendering to the WASM viewport surface.
• node-graph/libraries/application-io/src/lib.rs
  • Added the DynAny derive macro to the ImageTexture struct.
  • Updated the texture field within ImageTexture to be Arc<wgpu::Texture>.
  • Removed the unsafe impl StaticType for ImageTexture block.
• node-graph/nodes/gstd/src/render_cache.rs
  • Introduced a texture_cache field to TileCacheImpl, consisting of a UVec2 size and a Vec of Arc<wgpu::Texture>.
  • Initialized the texture_cache to its default value in TileCacheImpl::default.
  • Implemented a request_texture method in TileCacheImpl to manage and provide reusable wgpu::Texture instances from the cache.
  • Added a public request_texture method to TileCache that delegates to the internal TileCacheImpl.
  • Modified render_output_cache to acquire the output texture from tile_cache.request_texture.
  • Updated the composite_cached_regions function to accept a reference to an existing wgpu::Texture for output, instead of creating a new one, and changed its return type to only rendering::RenderMetadata.
  • Changed CachedRegion.texture to store a cloned Arc reference.
• node-graph/nodes/gstd/src/render_node.rs
  • Wrapped the wgpu::Texture returned from exec.render_vello_scene_to_texture in an Arc::new() call.

Using Gemini Code Assist

The full guide for Gemini Code Assist can be found on our documentation page, here are some quick tips.

Invoking Gemini

You can request assistance from Gemini at any point by creating a comment using either /gemini <command> or @gemini-code-assist <command>. Below is a summary of the supported commands on the current page.

Feature	Command	Description
Code Review	/gemini review	Performs a code review for the current pull request in its current state.
Pull Request Summary	/gemini summary	Provides a summary of the current pull request in its current state.
Comment	@gemini-code-assist	Responds in comments when explicitly tagged, both in pull request comments and review comments.
Help	/gemini help	Displays a list of available commands.

Customization

To customize Gemini Code Assist for GitHub experience, repository maintainers can create a configuration file and/or provide a custom code review style guide (such as PEP-8 for Python) by creating and adding files to a .gemini/ folder in the base of the repository. Detailed instructions can be found here.

Limitations & Feedback

Gemini Code Assist may make mistakes. Please leave feedback on any instances where its feedback is incorrect or counter productive. You can react with 👍 and 👎 on @gemini-code-assist comments. If you're interested in giving your feedback about your experience with Gemini Code Assist for Github and other Google products, sign up here.

You can also get AI-powered code generation, chat, as well as code reviews directly in the IDE at no cost with the Gemini Code Assist IDE Extension.

Footnotes

1. Review the Privacy Notices, Generative AI Prohibited Use Policy, Terms of Service, and learn how to configure Gemini Code Assist in GitHub here. Gemini can make mistakes, so double check it and use code with caution. ↩

[gemini-code-assist]

Code Review

This pull request introduces a texture pool to the render cache node, aimed at reducing memory consumption and allocation overhead, particularly for WASM-based viewport rendering. By wrapping wgpu::Texture in std::sync::Arc and tracking strong reference counts, the system can now reuse textures that are no longer in use by the editor or previous frames. The implementation is clean and leverages Rust's ownership model effectively to manage GPU resource lifetimes without explicit manual pooling logic in most places. The identified redundant comment should be removed to maintain code clarity.

[cubic-dev-ai]

2 issues found across 7 files

Prompt for AI agents (unresolved issues)

Check if these issues are valid — if so, understand the root cause of each and fix them. If appropriate, use sub-agents to investigate and fix each issue separately.


<file name="editor/src/node_graph_executor/runtime.rs">

<violation number="1" location="editor/src/node_graph_executor/runtime.rs:63">
P2: `current_viewport_texture` is written but never read anywhere in the codebase. This field stores a cloned `ImageTexture` every frame (keeping a GPU texture alive via `Arc`) without any code that recycles or accesses it. This is dead code that increases memory consumption — the opposite of the PR's stated goal of reducing memory pressure.</violation>
</file>

<file name="node-graph/nodes/gstd/src/render_cache.rs">

<violation number="1" location="node-graph/nodes/gstd/src/render_cache.rs:238">
P2: Reused textures from the pool retain stale pixel data from the previous frame. Unlike a freshly allocated texture, a pooled texture contains actual rendered content. Since `composite_cached_regions` does not clear the output texture before copying regions into it, any uncovered pixels (e.g., from sub-pixel rounding gaps between tiles) will show ghost artifacts from the previous frame. Consider adding a clear pass (e.g., a `render_pass` with a clear color) before compositing, or using `encoder.clear_texture()` to zero the texture upon reuse.</violation>
</file>

_{Reply with feedback, questions, or to request a fix. Tag @cubic-dev-ai to re-run a review.}

[cubic-dev-ai]

P2: current_viewport_texture is written but never read anywhere in the codebase. This field stores a cloned ImageTexture every frame (keeping a GPU texture alive via Arc) without any code that recycles or accesses it. This is dead code that increases memory consumption — the opposite of the PR's stated goal of reducing memory pressure.

Prompt for AI agents

Check if this issue is valid — if so, understand the root cause and fix it. At editor/src/node_graph_executor/runtime.rs, line 63:

<comment>`current_viewport_texture` is written but never read anywhere in the codebase. This field stores a cloned `ImageTexture` every frame (keeping a GPU texture alive via `Arc`) without any code that recycles or accesses it. This is dead code that increases memory consumption — the opposite of the PR's stated goal of reducing memory pressure.</comment>

<file context>
@@ -59,6 +60,7 @@ pub struct NodeRuntime {
 	/// Cached surface for WASM viewport rendering (reused across frames)
 	#[cfg(all(target_family = "wasm", feature = "gpu"))]
 	wasm_viewport_surface: Option<wgpu_executor::WgpuSurface>,
+	current_viewport_texture: Option<ImageTexture>,
 }
 
</file context>

[TrueDoctor]

This is precisely in place such that the texture is not destroyed while it is still in use by the frontend

[cubic-dev-ai]

Thanks for the feedback! I've saved this as a new learning to improve future reviews.

[cubic-dev-ai]

P2: Reused textures from the pool retain stale pixel data from the previous frame. Unlike a freshly allocated texture, a pooled texture contains actual rendered content. Since composite_cached_regions does not clear the output texture before copying regions into it, any uncovered pixels (e.g., from sub-pixel rounding gaps between tiles) will show ghost artifacts from the previous frame. Consider adding a clear pass (e.g., a render_pass with a clear color) before compositing, or using encoder.clear_texture() to zero the texture upon reuse.

Prompt for AI agents

Check if this issue is valid — if so, understand the root cause and fix it. At node-graph/nodes/gstd/src/render_cache.rs, line 238:

<comment>Reused textures from the pool retain stale pixel data from the previous frame. Unlike a freshly allocated texture, a pooled texture contains actual rendered content. Since `composite_cached_regions` does not clear the output texture before copying regions into it, any uncovered pixels (e.g., from sub-pixel rounding gaps between tiles) will show ghost artifacts from the previous frame. Consider adding a clear pass (e.g., a `render_pass` with a clear color) before compositing, or using `encoder.clear_texture()` to zero the texture upon reuse.</comment>

<file context>
@@ -224,6 +226,36 @@ impl TileCacheImpl {
+		self.texture_cache.1.truncate(5);
+		for texture in &self.texture_cache.1 {
+			if Arc::strong_count(&texture) == 1 {
+				return Arc::clone(texture);
+			}
+		}
</file context>