cuda.core: update texture examples for OpaqueArray / cuda.core.texture rename

The examples still imported `from cuda.core.textures import (CUDAArray, ...)`,
which broke after the namespace/class rename. test_basic_examples runs
texture_sample.py as a subprocess (no system requirement gating it), so the
dead import failed "Run cuda.core tests" across the GPU matrix.

Renamed cuda.core.textures -> cuda.core.texture and CUDAArray -> OpaqueArray in
all four texture examples. Verified: texture_sample.py runs to completion on a
GPU (texel-center + half-integer samples verified, exit 0).

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: rparolin

cuda_core/examples/gl_interop_fluid.py

@@ -4,7 +4,7 @@
 
 # ################################################################################
 #
-# This example demonstrates cuda.core.CUDAArray, TextureObject, and SurfaceObject
+# This example demonstrates cuda.core.OpaqueArray, TextureObject, and SurfaceObject
 # in combination with GraphicsResource for CUDA/OpenGL interop. It runs a
 # real-time Stable Fluids (Jos Stam) smoke/ink solver entirely on the GPU:
 # velocity, pressure, and dye fields live in ping-ponged CUDA arrays, are read
@@ -107,10 +107,10 @@
     ProgramOptions,
     launch,
 )
-from cuda.core.textures import (
+from cuda.core.texture import (
     AddressMode,
     ArrayFormat,
-    CUDAArray,
+    OpaqueArray,
     FilterMode,
     ReadMode,
     ResourceDescriptor,
@@ -164,7 +164,7 @@
 # ============================= Helper functions =============================
 #
 # The functions below set up CUDA and OpenGL. If you're here to learn about
-# CUDAArray/TextureObject/SurfaceObject, skip ahead to main() -- the interesting
+# OpaqueArray/TextureObject/SurfaceObject, skip ahead to main() -- the interesting
 # part is there. These helpers exist so that main() reads like a short story
 # instead of a wall of boilerplate.
 # ============================================================================
@@ -248,7 +248,7 @@ def create_window():
     window = pyglet.window.Window(
         WIDTH,
         HEIGHT,
-        caption="cuda.core CUDAArray/Texture/Surface - Stable Fluids",
+        caption="cuda.core OpaqueArray/Texture/Surface - Stable Fluids",
         vsync=False,
     )
     return window, _gl, pyglet
@@ -397,11 +397,11 @@ def draw_fullscreen_quad(gl, shader_prog, vao_id, tex_id):
 
 # ============================ API MAP (cuda.core) ===========================
 #
-# The three helpers below are where every CUDAArray / ResourceDescriptor /
+# The three helpers below are where every OpaqueArray / ResourceDescriptor /
 # TextureDescriptor / TextureObject / SurfaceObject knob in this example is set.
 # Each visible setting maps to a concrete piece of cuda.core / CUDA behavior:
 #
-#   CUDAArray.from_descriptor(...)   -> allocates a CUDA *array* (opaque, tiled
+#   OpaqueArray.from_descriptor(...)   -> allocates a CUDA *array* (opaque, tiled
 #                                       layout optimized for 2D texture fetches),
 #                                       not linear device memory.
 #   ArrayFormat.FLOAT32              -> each channel is a 32-bit float texel.
@@ -414,7 +414,7 @@ def draw_fullscreen_quad(gl, shader_prog, vao_id, tex_id):
 #                                       is what lets each field be sampled and
 #                                       then written back in the ping-pong.
 #
-#   ResourceDescriptor.from_array(arr) -> wraps the CUDAArray as the resource a
+#   ResourceDescriptor.from_array(arr) -> wraps the OpaqueArray as the resource a
 #                                         TextureObject reads from.
 #   FilterMode.LINEAR                -> free HARDWARE bilinear interpolation;
 #                                       this is what makes semi-Lagrangian
@@ -438,7 +438,7 @@ def draw_fullscreen_quad(gl, shader_prog, vao_id, tex_id):
 
 def make_velocity_array():
     """Allocate a `float2` velocity CUDA array (channel 0 = vx, channel 1 = vy)."""
-    return CUDAArray.from_descriptor(
+    return OpaqueArray.from_descriptor(
         shape=(WIDTH, HEIGHT),
         format=ArrayFormat.FLOAT32,
         num_channels=2,
@@ -448,7 +448,7 @@ def make_velocity_array():
 
 def make_scalar_array():
     """Allocate a single-channel `float` CUDA array (pressure / divergence / dye)."""
-    return CUDAArray.from_descriptor(
+    return OpaqueArray.from_descriptor(
         shape=(WIDTH, HEIGHT),
         format=ArrayFormat.FLOAT32,
         num_channels=1,
@@ -464,7 +464,7 @@ def make_color_array():
     surface-write machinery as the scalar fields -- only the channel count
     (and the surf2Dwrite byte stride, sizeof(float4) = 16) differ.
     """
-    return CUDAArray.from_descriptor(
+    return OpaqueArray.from_descriptor(
         shape=(WIDTH, HEIGHT),
         format=ArrayFormat.FLOAT32,
         num_channels=4,
@@ -876,7 +876,7 @@ def on_draw():
         if now - fps_time >= 1.0:
             fps = frame_count / (now - fps_time)
             window.set_caption(
-                "cuda.core CUDAArray/Texture/Surface - Stable Fluids"
+                "cuda.core OpaqueArray/Texture/Surface - Stable Fluids"
                 f" ({WIDTH}x{HEIGHT}, {fps:.0f} FPS,"
                 f" {PRESSURE_ITERS} pressure iters)"
                 " | TextureObject[LINEAR|CLAMP|norm|float2]"

cuda_core/examples/gl_interop_fluid_numba_cuda_mlir.py

@@ -21,7 +21,7 @@
 # =======================================
 #   cuda.core / CUDA C++                  ->  numba-cuda (this file)
 #   --------------------------------------    -----------------------------------
-#   CUDAArray(num_channels=2) as texture  ->  cuda.device_array((H, W, 2), f32)
+#   OpaqueArray(num_channels=2) as texture  ->  cuda.device_array((H, W, 2), f32)
 #   tex2D<float2>(tex, u, v)  [HW LINEAR] ->  sample_vec(arr, px, py)  [manual lerp]
 #   AddressMode.CLAMP                     ->  index clamp inside sample_*()
 #   surf2Dwrite(v, surf, x*8, y)          ->  arr[y, x, 0] = v.x; arr[y, x, 1] = v.y

cuda_core/examples/gl_interop_mipmap_lod.py

@@ -45,7 +45,7 @@
 #         |      +---- one SurfaceObject per level, used at BUILD time only
 #         |            to let a kernel write pixels into that level.
 #         |
-#         +----------- get_level(L) returns a NON-OWNING CUDAArray view of level L;
+#         +----------- get_level(L) returns a NON-OWNING OpaqueArray view of level L;
 #                      the storage belongs to the parent MipmappedArray.
 #
 #   STARTUP -- one-time mipmap build
@@ -100,7 +100,7 @@
     ProgramOptions,
     launch,
 )
-from cuda.core.textures import (
+from cuda.core.texture import (
     AddressMode,
     ArrayFormat,
     FilterMode,
@@ -577,7 +577,7 @@ def on_close():
 // --------------------------------------------------------------------------
 // seed_base: write a procedural high-frequency pattern to level 0.
 //
-// surf is a SurfaceObject bound to the level-0 CUDAArray (float4 RGBA). The
+// surf is a SurfaceObject bound to the level-0 OpaqueArray (float4 RGBA). The
 // pattern is a colorful blend of concentric rings, a diagonal grid, and a
 // radial sweep, designed to have plenty of fine detail so the difference
 // between mip levels is visually obvious.

cuda_core/examples/texture_sample.py

@@ -4,7 +4,7 @@
 
 # ################################################################################
 #
-# This example demonstrates building a 2D CUDA CUDAArray, binding it as a
+# This example demonstrates building a 2D CUDA OpaqueArray, binding it as a
 # bindless TextureObject, and sampling it from a kernel with both POINT-exact
 # and LINEAR-interpolated coordinates.
 #
@@ -29,10 +29,10 @@
     ProgramOptions,
     launch,
 )
-from cuda.core.textures import (
+from cuda.core.texture import (
     AddressMode,
     ArrayFormat,
-    CUDAArray,
+    OpaqueArray,
     FilterMode,
     ReadMode,
     ResourceDescriptor,
@@ -65,12 +65,12 @@ def main():
 
     pinned_mr = LegacyPinnedMemoryResource()
     try:
-        # Allocate a 2D CUDAArray: shape=(W, H), single-channel float32.
-        # Note: CUDAArray.from_descriptor takes shape=(width, height), so the host
+        # Allocate a 2D OpaqueArray: shape=(W, H), single-channel float32.
+        # Note: OpaqueArray.from_descriptor takes shape=(width, height), so the host
         # buffer fed into copy_from must be laid out as H rows of W elements
         # (row-major), i.e. host_pattern.shape == (H, W).
         width, height = 16, 16
-        with CUDAArray.from_descriptor(
+        with OpaqueArray.from_descriptor(
             shape=(width, height),
             format=ArrayFormat.FLOAT32,
             num_channels=1,