[add] ColorAttachmentTexture and DepthTextures to the high level API.

Author: vmarcella

crates/lambda-rs/src/render/mod.rs

@@ -161,14 +161,7 @@ impl RenderContextBuilder {
     let texture_usage = config.usage;
 
     // Initialize a depth texture matching the surface size.
-    let depth_format = platform::texture::DepthFormat::Depth32Float;
-    let depth_texture = Some(
-      platform::texture::DepthTextureBuilder::new()
-        .with_size(size.0.max(1), size.1.max(1))
-        .with_format(depth_format)
-        .with_label("lambda-depth")
-        .build(&gpu),
-    );
+    let depth_format = texture::DepthFormat::Depth32Float;
 
     return Ok(RenderContext {
       label: name,
@@ -179,7 +172,7 @@ impl RenderContextBuilder {
       present_mode,
       texture_usage,
       size,
-      depth_texture,
+      depth_texture: None,
       depth_format,
       depth_sample_count: 1,
       msaa_color: None,
@@ -219,10 +212,10 @@ pub struct RenderContext {
   present_mode: surface::PresentMode,
   texture_usage: texture::TextureUsages,
   size: (u32, u32),
-  depth_texture: Option<platform::texture::DepthTexture>,
-  depth_format: platform::texture::DepthFormat,
+  depth_texture: Option<texture::DepthTexture>,
+  depth_format: texture::DepthFormat,
   depth_sample_count: u32,
-  msaa_color: Option<platform::texture::ColorAttachmentTexture>,
+  msaa_color: Option<texture::ColorAttachmentTexture>,
   msaa_sample_count: u32,
   render_passes: Vec<RenderPassDesc>,
   render_pipelines: Vec<RenderPipeline>,
@@ -319,12 +312,12 @@ impl RenderContext {
 
     // Recreate depth texture to match new size.
     self.depth_texture = Some(
-      platform::texture::DepthTextureBuilder::new()
+      texture::DepthTextureBuilder::new()
         .with_size(self.size.0.max(1), self.size.1.max(1))
         .with_format(self.depth_format)
         .with_sample_count(self.depth_sample_count)
         .with_label("lambda-depth")
-        .build(self.gpu()),
+        .build(self),
     );
     // Drop MSAA color target so it is rebuilt on demand with the new size.
     self.msaa_color = None;
@@ -352,7 +345,7 @@ impl RenderContext {
     return self.config.format;
   }
 
-  pub(crate) fn depth_format(&self) -> platform::texture::DepthFormat {
+  pub(crate) fn depth_format(&self) -> texture::DepthFormat {
     return self.depth_format;
   }
 
@@ -368,12 +361,12 @@ impl RenderContext {
 
   pub(crate) fn supports_depth_sample_count(
     &self,
-    format: platform::texture::DepthFormat,
+    format: texture::DepthFormat,
     sample_count: u32,
   ) -> bool {
     return self
       .gpu
-      .supports_sample_count_for_depth(format, sample_count);
+      .supports_sample_count_for_depth(format.to_platform(), sample_count);
   }
 
   /// Device limit: maximum bytes that can be bound for a single uniform buffer binding.
@@ -409,21 +402,19 @@ impl RenderContext {
   fn ensure_msaa_color_texture(
     &mut self,
     sample_count: u32,
-  ) -> platform::surface::TextureViewRef<'_> {
+  ) -> surface::TextureView<'_> {
     let need_recreate = match &self.msaa_color {
       Some(_) => self.msaa_sample_count != sample_count,
       None => true,
     };
 
     if need_recreate {
       self.msaa_color = Some(
-        platform::texture::ColorAttachmentTextureBuilder::new(
-          self.config.format.to_platform(),
-        )
-        .with_size(self.size.0.max(1), self.size.1.max(1))
-        .with_sample_count(sample_count)
-        .with_label("lambda-msaa-color")
-        .build(self.gpu()),
+        texture::ColorAttachmentTextureBuilder::new(self.config.format)
+          .with_size(self.size.0.max(1), self.size.1.max(1))
+          .with_sample_count(sample_count)
+          .with_label("lambda-msaa-color")
+          .build(self),
       );
       self.msaa_sample_count = sample_count;
     }
@@ -520,10 +511,7 @@ impl RenderContext {
           // Create color attachments for the surface pass. The MSAA view is
           // retrieved here after the mutable borrow for texture creation ends.
           let msaa_view = if sample_count > 1 {
-            self
-              .msaa_color
-              .as_ref()
-              .map(|t| surface::TextureView::from_platform(t.view_ref()))
+            self.msaa_color.as_ref().map(|t| t.view_ref())
           } else {
             None
           };
@@ -547,8 +535,7 @@ impl RenderContext {
 
             // If stencil is requested on the pass, ensure we use a stencil-capable format.
             if pass.stencil_operations().is_some()
-              && self.depth_format
-                != platform::texture::DepthFormat::Depth24PlusStencil8
+              && self.depth_format != texture::DepthFormat::Depth24PlusStencil8
             {
               #[cfg(any(
                 debug_assertions,
@@ -558,8 +545,7 @@ impl RenderContext {
                 "Render pass has stencil ops but depth format {:?} lacks stencil; upgrading to Depth24PlusStencil8",
                 self.depth_format
               );
-              self.depth_format =
-                platform::texture::DepthFormat::Depth24PlusStencil8;
+              self.depth_format = texture::DepthFormat::Depth24PlusStencil8;
             }
 
             let format_mismatch = self
@@ -573,12 +559,12 @@ impl RenderContext {
               || format_mismatch
             {
               self.depth_texture = Some(
-                platform::texture::DepthTextureBuilder::new()
+                texture::DepthTextureBuilder::new()
                   .with_size(self.size.0.max(1), self.size.1.max(1))
                   .with_format(self.depth_format)
                   .with_sample_count(desired_samples)
                   .with_label("lambda-depth")
-                  .build(self.gpu()),
+                  .build(self),
               );
               self.depth_sample_count = desired_samples;
             }
@@ -587,7 +573,7 @@ impl RenderContext {
               .depth_texture
               .as_ref()
               .expect("depth texture should be present")
-              .view_ref();
+              .platform_view_ref();
 
             // Map depth operations when explicitly provided; leave depth
             // untouched for stencil-only passes.

crates/lambda-rs/src/render/pipeline.rs

@@ -580,15 +580,17 @@ impl RenderPipelineBuilder {
       // Derive the pass attachment depth format from pass configuration.
       let pass_has_stencil = _render_pass.stencil_operations().is_some();
       let pass_depth_format = if pass_has_stencil {
-        platform_texture::DepthFormat::Depth24PlusStencil8
+        texture::DepthFormat::Depth24PlusStencil8
       } else {
         render_context.depth_format()
       };
 
       // Align the pipeline depth format with the pass attachment format to
       // avoid hidden global state on the render context. When formats differ,
       // prefer the pass attachment format and log for easier debugging.
-      let final_depth_format = if requested_depth_format != pass_depth_format {
+      let final_depth_format = if requested_depth_format
+        != pass_depth_format.to_platform()
+      {
         #[cfg(any(
           debug_assertions,
           feature = "render-validation-depth",
@@ -599,9 +601,9 @@ impl RenderPipelineBuilder {
             requested_depth_format,
             pass_depth_format
           );
-        pass_depth_format
+        pass_depth_format.to_platform()
       } else {
-        pass_depth_format
+        pass_depth_format.to_platform()
       };
 
       rp_builder = rp_builder.with_depth_stencil(final_depth_format);

crates/lambda-rs/src/render/render_pass.rs

@@ -8,7 +8,10 @@
 use lambda_platform::wgpu as platform;
 use logging;
 
-use super::RenderContext;
+use super::{
+  texture,
+  RenderContext,
+};
 use crate::render::validation;
 
 /// Color load operation for the first color attachment.
@@ -303,13 +306,13 @@ impl RenderPassBuilder {
     &self,
     sample_count: u32,
     surface_format: platform::texture::TextureFormat,
-    depth_format: platform::texture::DepthFormat,
+    depth_format: texture::DepthFormat,
     supports_surface: FSurface,
     supports_depth: FDepth,
   ) -> u32
   where
     FSurface: Fn(u32) -> bool,
-    FDepth: Fn(platform::texture::DepthFormat, u32) -> bool,
+    FDepth: Fn(texture::DepthFormat, u32) -> bool,
   {
     let mut resolved_sample_count = sample_count.max(1);
 
@@ -330,7 +333,7 @@ impl RenderPassBuilder {
       self.depth_operations.is_some() || self.stencil_operations.is_some();
     if wants_depth_or_stencil && resolved_sample_count > 1 {
       let validated_depth_format = if self.stencil_operations.is_some() {
-        platform::texture::DepthFormat::Depth24PlusStencil8
+        texture::DepthFormat::Depth24PlusStencil8
       } else {
         depth_format
       };
@@ -392,7 +395,7 @@ mod tests {
     let resolved = builder.resolve_sample_count(
       4,
       surface_format(),
-      platform::texture::DepthFormat::Depth32Float,
+      texture::DepthFormat::Depth32Float,
       |_samples| {
         return false;
       },
@@ -412,7 +415,7 @@ mod tests {
     let resolved = builder.resolve_sample_count(
       8,
       surface_format(),
-      platform::texture::DepthFormat::Depth32Float,
+      texture::DepthFormat::Depth32Float,
       |_samples| {
         return true;
       },
@@ -428,13 +431,13 @@ mod tests {
   #[test]
   fn stencil_support_uses_stencil_capable_depth_format() {
     let builder = RenderPassBuilder::new().with_stencil().with_multi_sample(2);
-    let requested_formats: RefCell<Vec<platform::texture::DepthFormat>> =
+    let requested_formats: RefCell<Vec<texture::DepthFormat>> =
       RefCell::new(Vec::new());
 
     let resolved = builder.resolve_sample_count(
       2,
       surface_format(),
-      platform::texture::DepthFormat::Depth32Float,
+      texture::DepthFormat::Depth32Float,
       |_samples| {
         return true;
       },
@@ -447,7 +450,7 @@ mod tests {
     assert_eq!(resolved, 2);
     assert_eq!(
       requested_formats.borrow().first().copied(),
-      Some(platform::texture::DepthFormat::Depth24PlusStencil8)
+      Some(texture::DepthFormat::Depth24PlusStencil8)
     );
   }
 
@@ -459,7 +462,7 @@ mod tests {
     let resolved = builder.resolve_sample_count(
       4,
       surface_format(),
-      platform::texture::DepthFormat::Depth32Float,
+      texture::DepthFormat::Depth32Float,
       |_samples| {
         return true;
       },
@@ -479,7 +482,7 @@ mod tests {
     let resolved = builder.resolve_sample_count(
       0,
       surface_format(),
-      platform::texture::DepthFormat::Depth32Float,
+      texture::DepthFormat::Depth32Float,
       |_samples| {
         return true;
       },