gsplat 1.0.0

data/lib/gsplat/math/small_matrix_primitives.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+module Gsplat
+  module Math
+    # Internal shape, casting, and closed-form primitives for Mat.
+    module SmallMatrixPrimitives
+      private
+
+      def prepare_matrix(matrices, size, dtype)
+        typed = cast_float(matrices, dtype)
+        validate_rank!(typed, 2)
+        unless typed.shape[-2, 2] == [size, size]
+          raise ShapeError, "expected [...,#{size},#{size}], got #{typed.shape.inspect}"
+        end
+
+        leading_shape = typed.shape[0...-2]
+        batch_size = leading_shape.empty? ? 1 : leading_shape.inject(:*)
+        [typed, leading_shape, typed.reshape(batch_size, size, size)]
+      end
+
+      def cast_float(array, dtype)
+        raise ArgumentError, "expected a Numo::NArray" unless array.is_a?(Numo::NArray)
+
+        type = case dtype
+               when nil then array.class
+               when :float32 then Numo::SFloat
+               when :float64 then Numo::DFloat
+               else dtype
+               end
+        unless [Numo::SFloat, Numo::DFloat].include?(type)
+          raise ArgumentError, "dtype must be Numo::SFloat or Numo::DFloat"
+        end
+
+        type.cast(array)
+      end
+
+      def validate_rank!(array, trailing_dimensions)
+        return if array.ndim >= trailing_dimensions
+
+        raise ShapeError, "expected at least #{trailing_dimensions} dimensions, got #{array.shape.inspect}"
+      end
+
+      def reshape_vector(vector, leading_shape)
+        return vector.class.cast(vector[0]) if leading_shape.empty?
+
+        vector.reshape(*leading_shape)
+      end
+
+      def reshape_matrix(matrix, leading_shape, *trailing_shape)
+        matrix.reshape(*(leading_shape + trailing_shape))
+      end
+
+      def ensure_invertible!(determinant, epsilon)
+        return unless determinant.abs.le(epsilon).any?
+
+        raise Gsplat::Error, "matrix is singular within epsilon #{epsilon}"
+      end
+
+      def default_epsilon(type)
+        type == Numo::DFloat ? 1e-12 : 1e-6
+      end
+
+      def determinant3(matrix)
+        a = matrix[true, 0, 0]
+        b = matrix[true, 0, 1]
+        c = matrix[true, 0, 2]
+        d = matrix[true, 1, 0]
+        e = matrix[true, 1, 1]
+        f = matrix[true, 1, 2]
+        g = matrix[true, 2, 0]
+        h = matrix[true, 2, 1]
+        i = matrix[true, 2, 2]
+        (a * ((e * i) - (f * h))) - (b * ((d * i) - (f * g))) + (c * ((d * h) - (e * g)))
+      end
+
+      # rubocop:disable Metrics/AbcSize
+      def fill_inverse3!(output, matrix, determinant)
+        a = matrix[true, 0, 0]
+        b = matrix[true, 0, 1]
+        c = matrix[true, 0, 2]
+        d = matrix[true, 1, 0]
+        e = matrix[true, 1, 1]
+        f = matrix[true, 1, 2]
+        g = matrix[true, 2, 0]
+        h = matrix[true, 2, 1]
+        i = matrix[true, 2, 2]
+        output[true, 0, 0] = ((e * i) - (f * h)) / determinant
+        output[true, 0, 1] = ((c * h) - (b * i)) / determinant
+        output[true, 0, 2] = ((b * f) - (c * e)) / determinant
+        output[true, 1, 0] = ((f * g) - (d * i)) / determinant
+        output[true, 1, 1] = ((a * i) - (c * g)) / determinant
+        output[true, 1, 2] = ((c * d) - (a * f)) / determinant
+        output[true, 2, 0] = ((d * h) - (e * g)) / determinant
+        output[true, 2, 1] = ((b * g) - (a * h)) / determinant
+        output[true, 2, 2] = ((a * e) - (b * d)) / determinant
+      end
+      # rubocop:enable Metrics/AbcSize
+
+      def multiply_flat(left, right, rows, shared, columns)
+        output = left.class.zeros(left.shape[0], rows, columns)
+        rows.times do |row|
+          columns.times do |column|
+            shared.times do |inner|
+              output[true, row, column] += left[true, row, inner] * right[true, inner, column]
+            end
+          end
+        end
+        output
+      end
+    end
+  end
+end

data/lib/gsplat/math/spherical_harmonic_basis.rb

@@ -0,0 +1,148 @@
+# frozen_string_literal: true
+
+module Gsplat
+  module Math
+    # Real SH bases and normalized-direction derivatives in gsplat/Inria order.
+    module SphericalHarmonicBasis
+      C0 = 0.2820947917738781
+      C1 = 0.48860251190292
+      C2 = [1.092548430592079, 0.3153915652525201, 0.5462742152960395].freeze
+      C3 = [0.5900435899266435, 2.890611442640554, 0.4570457994644658,
+            0.3731763325901154, 1.445305721320277].freeze
+      C4 = [2.5033429417967046, -1.770130769779931, 0.9461746957575601,
+            -0.6690465435572892, 0.1057855469152043, 0.47308734787878,
+            0.6258357354491763].freeze
+
+      module_function
+
+      # Evaluates bases and derivatives with respect to already-normalized directions.
+      #
+      # Constants and ordering match gsplat 1.5.3 cuda/_torch_impl.py.
+      #
+      # @param directions [Numo::NArray] [N,3] normalized directions
+      # @param degree [Integer] 0..4
+      # @param basis_count [Integer] coefficient basis width
+      # @return [Array<Numo::NArray>] bases [N,K], derivatives [N,K,3]
+      def evaluate(directions, degree, basis_count)
+        count = directions.shape[0]
+        bases = directions.class.zeros(count, basis_count)
+        derivatives = directions.class.zeros(count, basis_count, 3)
+        x_coord = directions[true, 0]
+        y_coord = directions[true, 1]
+        z_coord = directions[true, 2]
+        bases[true, 0] = C0
+        fill_degree_one!(bases, derivatives, x_coord, y_coord, z_coord) if degree >= 1
+        fill_degree_two!(bases, derivatives, x_coord, y_coord, z_coord) if degree >= 2
+        fill_degree_three!(bases, derivatives, x_coord, y_coord, z_coord) if degree >= 3
+        fill_degree_four!(bases, derivatives, x_coord, y_coord, z_coord) if degree >= 4
+        [bases, derivatives]
+      end
+
+      def fill_degree_one!(bases, derivatives, x_coord, y_coord, z_coord)
+        bases[true, 1] = -C1 * y_coord
+        bases[true, 2] = C1 * z_coord
+        bases[true, 3] = -C1 * x_coord
+        derivatives[true, 1, 1] = -C1
+        derivatives[true, 2, 2] = C1
+        derivatives[true, 3, 0] = -C1
+      end
+      private_class_method :fill_degree_one!
+
+      # rubocop:disable Metrics/AbcSize
+      def fill_degree_two!(bases, derivatives, x_coord, y_coord, z_coord)
+        bases[true, 4] = C2[0] * x_coord * y_coord
+        bases[true, 5] = -C2[0] * y_coord * z_coord
+        bases[true, 6] = C2[1] * ((3 * (z_coord**2)) - 1)
+        bases[true, 7] = -C2[0] * x_coord * z_coord
+        bases[true, 8] = C2[2] * ((x_coord**2) - (y_coord**2))
+        derivatives[true, 4, 0] = C2[0] * y_coord
+        derivatives[true, 4, 1] = C2[0] * x_coord
+        derivatives[true, 5, 1] = -C2[0] * z_coord
+        derivatives[true, 5, 2] = -C2[0] * y_coord
+        derivatives[true, 6, 2] = 6 * C2[1] * z_coord
+        derivatives[true, 7, 0] = -C2[0] * z_coord
+        derivatives[true, 7, 2] = -C2[0] * x_coord
+        derivatives[true, 8, 0] = 2 * C2[2] * x_coord
+        derivatives[true, 8, 1] = -2 * C2[2] * y_coord
+      end
+      private_class_method :fill_degree_two!
+
+      def fill_degree_three!(bases, derivatives, x_coord, y_coord, z_coord)
+        bases[true, 9] = -C3[0] * y_coord * ((3 * (x_coord**2)) - (y_coord**2))
+        bases[true, 10] = C3[1] * x_coord * y_coord * z_coord
+        bases[true, 11] = -C3[2] * y_coord * ((5 * (z_coord**2)) - 1)
+        bases[true, 12] = C3[3] * z_coord * ((5 * (z_coord**2)) - 3)
+        bases[true, 13] = -C3[2] * x_coord * ((5 * (z_coord**2)) - 1)
+        bases[true, 14] = C3[4] * z_coord * ((x_coord**2) - (y_coord**2))
+        bases[true, 15] = -C3[0] * x_coord * ((x_coord**2) - (3 * (y_coord**2)))
+        fill_degree_three_derivatives!(derivatives, x_coord, y_coord, z_coord)
+      end
+      private_class_method :fill_degree_three!
+
+      def fill_degree_three_derivatives!(derivatives, x_coord, y_coord, z_coord)
+        derivatives[true, 9, 0] = -6 * C3[0] * x_coord * y_coord
+        derivatives[true, 9, 1] = -3 * C3[0] * ((x_coord**2) - (y_coord**2))
+        derivatives[true, 10, 0] = C3[1] * y_coord * z_coord
+        derivatives[true, 10, 1] = C3[1] * x_coord * z_coord
+        derivatives[true, 10, 2] = C3[1] * x_coord * y_coord
+        derivatives[true, 11, 1] = -C3[2] * ((5 * (z_coord**2)) - 1)
+        derivatives[true, 11, 2] = -10 * C3[2] * y_coord * z_coord
+        derivatives[true, 12, 2] = C3[3] * ((15 * (z_coord**2)) - 3)
+        derivatives[true, 13, 0] = -C3[2] * ((5 * (z_coord**2)) - 1)
+        derivatives[true, 13, 2] = -10 * C3[2] * x_coord * z_coord
+        derivatives[true, 14, 0] = 2 * C3[4] * x_coord * z_coord
+        derivatives[true, 14, 1] = -2 * C3[4] * y_coord * z_coord
+        derivatives[true, 14, 2] = C3[4] * ((x_coord**2) - (y_coord**2))
+        derivatives[true, 15, 0] = -3 * C3[0] * ((x_coord**2) - (y_coord**2))
+        derivatives[true, 15, 1] = 6 * C3[0] * x_coord * y_coord
+      end
+      private_class_method :fill_degree_three_derivatives!
+
+      def fill_degree_four!(bases, derivatives, x_coord, y_coord, z_coord)
+        x2 = x_coord**2
+        y2 = y_coord**2
+        z2 = z_coord**2
+        bases[true, 16] = C4[0] * x_coord * y_coord * (x2 - y2)
+        bases[true, 17] = C4[1] * y_coord * z_coord * ((3 * x2) - y2)
+        bases[true, 18] = C4[2] * x_coord * y_coord * ((7 * z2) - 1)
+        bases[true, 19] = C4[3] * y_coord * z_coord * ((7 * z2) - 3)
+        bases[true, 20] = C4[4] * ((z2 * ((35 * z2) - 30)) + 3)
+        bases[true, 21] = C4[3] * x_coord * z_coord * ((7 * z2) - 3)
+        bases[true, 22] = C4[5] * (x2 - y2) * ((7 * z2) - 1)
+        bases[true, 23] = C4[1] * x_coord * z_coord * (x2 - (3 * y2))
+        bases[true, 24] = C4[6] * ((x2**2) - (6 * x2 * y2) + (y2**2))
+        fill_degree_four_derivatives!(derivatives, x_coord, y_coord, z_coord)
+      end
+      private_class_method :fill_degree_four!
+
+      def fill_degree_four_derivatives!(derivatives, x_coord, y_coord, z_coord)
+        x_squared = x_coord**2
+        y_squared = y_coord**2
+        z_squared = z_coord**2
+        derivatives[true, 16, 0] = C4[0] * y_coord * ((3 * x_squared) - y_squared)
+        derivatives[true, 16, 1] = C4[0] * x_coord * (x_squared - (3 * y_squared))
+        derivatives[true, 17, 0] = 6 * C4[1] * x_coord * y_coord * z_coord
+        derivatives[true, 17, 1] = 3 * C4[1] * z_coord * (x_squared - y_squared)
+        derivatives[true, 17, 2] = C4[1] * y_coord * ((3 * x_squared) - y_squared)
+        derivatives[true, 18, 0] = C4[2] * y_coord * ((7 * z_squared) - 1)
+        derivatives[true, 18, 1] = C4[2] * x_coord * ((7 * z_squared) - 1)
+        derivatives[true, 18, 2] = 14 * C4[2] * x_coord * y_coord * z_coord
+        derivatives[true, 19, 1] = C4[3] * z_coord * ((7 * z_squared) - 3)
+        derivatives[true, 19, 2] = C4[3] * y_coord * ((21 * z_squared) - 3)
+        derivatives[true, 20, 2] = C4[4] * ((140 * (z_coord**3)) - (60 * z_coord))
+        derivatives[true, 21, 0] = C4[3] * z_coord * ((7 * z_squared) - 3)
+        derivatives[true, 21, 2] = C4[3] * x_coord * ((21 * z_squared) - 3)
+        derivatives[true, 22, 0] = 2 * C4[5] * x_coord * ((7 * z_squared) - 1)
+        derivatives[true, 22, 1] = -2 * C4[5] * y_coord * ((7 * z_squared) - 1)
+        derivatives[true, 22, 2] = 14 * C4[5] * z_coord * (x_squared - y_squared)
+        derivatives[true, 23, 0] = 3 * C4[1] * z_coord * (x_squared - y_squared)
+        derivatives[true, 23, 1] = -6 * C4[1] * x_coord * y_coord * z_coord
+        derivatives[true, 23, 2] = C4[1] * x_coord * (x_squared - (3 * y_squared))
+        derivatives[true, 24, 0] = 4 * C4[6] * x_coord * (x_squared - (3 * y_squared))
+        derivatives[true, 24, 1] = 4 * C4[6] * y_coord * (y_squared - (3 * x_squared))
+      end
+      # rubocop:enable Metrics/AbcSize
+      private_class_method :fill_degree_four_derivatives!
+    end
+  end
+end

data/lib/gsplat/math/ssim.rb

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+module Gsplat
+  module Math
+    # SSIM forward and analytic VJP with a grouped Gaussian convolution.
+    module Ssim
+      # Intermediate tensors retained by {.backward}.
+      Cache = Data.define(
+        :image_a, :image_b, :mu_a, :mu_b, :ssim_map,
+        :numerator_mean, :numerator_variance,
+        :denominator_mean, :denominator_variance, :kernel, :layout
+      )
+
+      module_function
+
+      # rubocop:disable Metrics/AbcSize
+      def forward(image_a, image_b, layout:)
+        first, resolved_layout = to_nchw(image_a, layout)
+        second, second_layout = to_nchw(image_b, layout)
+        validate_inputs!(first, second, resolved_layout, second_layout)
+        kernel = gaussian_kernel(first.class)
+        mu_a = convolve(first, kernel)
+        mu_b = convolve(second, kernel)
+        variance_a = convolve(first**2, kernel) - (mu_a**2)
+        variance_b = convolve(second**2, kernel) - (mu_b**2)
+        covariance = convolve(first * second, kernel) - (mu_a * mu_b)
+        numerator_mean = (2 * mu_a * mu_b) + (0.01**2)
+        numerator_variance = (2 * covariance) + (0.03**2)
+        denominator_mean = (mu_a**2) + (mu_b**2) + (0.01**2)
+        denominator_variance = variance_a + variance_b + (0.03**2)
+        ssim_map = (numerator_mean * numerator_variance) /
+                   (denominator_mean * denominator_variance)
+        cache = Cache.new(
+          image_a: first, image_b: second, mu_a: mu_a, mu_b: mu_b, ssim_map: ssim_map,
+          numerator_mean: numerator_mean, numerator_variance: numerator_variance,
+          denominator_mean: denominator_mean, denominator_variance: denominator_variance,
+          kernel: kernel, layout: resolved_layout
+        )
+        [ssim_map.mean.to_f, cache]
+      end
+      # rubocop:enable Metrics/AbcSize
+
+      # rubocop:disable Metrics/AbcSize
+      def backward(cache, grad_output)
+        factor = grad_output.to_f / cache.ssim_map.size
+        denominator = cache.denominator_mean * cache.denominator_variance
+        grad_num_mean = factor * cache.numerator_variance / denominator
+        grad_num_variance = factor * cache.numerator_mean / denominator
+        grad_den_mean = -factor * cache.ssim_map / cache.denominator_mean
+        grad_den_variance = -factor * cache.ssim_map / cache.denominator_variance
+        grad_mu_a = (2 * cache.mu_b * grad_num_mean) -
+                    (2 * cache.mu_b * grad_num_variance) +
+                    (2 * cache.mu_a * grad_den_mean) -
+                    (2 * cache.mu_a * grad_den_variance)
+        grad_mu_b = (2 * cache.mu_a * grad_num_mean) -
+                    (2 * cache.mu_a * grad_num_variance) +
+                    (2 * cache.mu_b * grad_den_mean) -
+                    (2 * cache.mu_b * grad_den_variance)
+        grad_cross = 2 * grad_num_variance
+        filtered_variance = convolve(grad_den_variance, cache.kernel)
+        filtered_cross = convolve(grad_cross, cache.kernel)
+        grad_a = convolve(grad_mu_a, cache.kernel) +
+                 (2 * cache.image_a * filtered_variance) +
+                 (cache.image_b * filtered_cross)
+        grad_b = convolve(grad_mu_b, cache.kernel) +
+                 (2 * cache.image_b * filtered_variance) +
+                 (cache.image_a * filtered_cross)
+        [from_nchw(grad_a, cache.layout), from_nchw(grad_b, cache.layout)]
+      end
+      # rubocop:enable Metrics/AbcSize
+
+      def gaussian_kernel(type)
+        coordinates = (-5..5).map { |value| ::Math.exp(-(value**2) / (2 * (1.5**2))) }
+        total = coordinates.sum
+        vector = coordinates.map { |value| value / total }
+        type.cast(vector.product(vector).map { |left, right| left * right }).reshape(11, 11)
+      end
+      private_class_method :gaussian_kernel
+
+      def convolve(input, kernel)
+        output = input.class.zeros(*input.shape)
+        height = input.shape[2]
+        width = input.shape[3]
+        11.times do |kernel_y|
+          next if (kernel_y - 5).abs >= height
+
+          destination_y, source_y = shifted_ranges(height, kernel_y - 5)
+          11.times do |kernel_x|
+            next if (kernel_x - 5).abs >= width
+
+            destination_x, source_x = shifted_ranges(width, kernel_x - 5)
+            destination = [true, true, destination_y, destination_x]
+            source = [true, true, source_y, source_x]
+            output[*destination] = output[*destination] + (input[*source] * kernel[kernel_y, kernel_x])
+          end
+        end
+        output
+      end
+      private_class_method :convolve
+
+      def shifted_ranges(length, offset)
+        if offset >= 0
+          [0...(length - offset), offset...length]
+        else
+          [(-offset)...length, 0...(length + offset)]
+        end
+      end
+      private_class_method :shifted_ranges
+
+      def to_nchw(image, layout)
+        unless [Numo::SFloat, Numo::DFloat].include?(image.class)
+          raise ArgumentError, "images must be Numo floating-point arrays"
+        end
+
+        resolved = layout == :auto ? infer_layout(image) : layout
+        converted = case resolved
+                    when :nchw then image
+                    when :nhwc then image.transpose(0, 3, 1, 2)
+                    when :chw then image.reshape(1, *image.shape)
+                    when :hwc then image.transpose(2, 0, 1).reshape(1, image.shape[2], image.shape[0], image.shape[1])
+                    else raise ArgumentError, "layout must be :auto, :nchw, :nhwc, :chw, or :hwc"
+                    end
+        [converted, resolved]
+      end
+      private_class_method :to_nchw
+
+      def from_nchw(image, layout)
+        case layout
+        when :nchw then image
+        when :nhwc then image.transpose(0, 2, 3, 1)
+        when :chw then image[0, true, true, true].dup
+        when :hwc then image[0, true, true, true].transpose(1, 2, 0)
+        end
+      end
+      private_class_method :from_nchw
+
+      def infer_layout(image)
+        return image.shape[-1] <= 4 && image.shape[1] > 4 ? :nhwc : :nchw if image.ndim == 4
+        return image.shape[-1] <= 4 && image.shape[0] > 4 ? :hwc : :chw if image.ndim == 3
+
+        raise ShapeError, "expected a 3D or 4D image, got #{image.shape.inspect}"
+      end
+      private_class_method :infer_layout
+
+      def validate_inputs!(first, second, first_layout, second_layout)
+        return if first.shape == second.shape && first_layout == second_layout && first.ndim == 4
+
+        raise ShapeError, "SSIM image shapes/layouts differ: #{first.shape.inspect} and #{second.shape.inspect}"
+      end
+      private_class_method :validate_inputs!
+    end
+  end
+end

data/lib/gsplat/native.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Gsplat
+  # Optional C implementation entrypoint.
+  module Native
+    class << self
+      attr_reader :load_error
+
+      def available?
+        @available == true
+      end
+
+      def mark_available!
+        @available = true
+      end
+
+      def mark_unavailable!(error)
+        @available = false
+        @load_error = error
+      end
+    end
+  end
+end
+
+begin
+  require_relative "gsplat_native"
+  Gsplat::Native.mark_available!
+rescue LoadError => e
+  Gsplat::Native.mark_unavailable!(e)
+end

data/lib/gsplat/native_ops.rb

@@ -0,0 +1,148 @@
+# frozen_string_literal: true
+
+require_relative "native_raster_ops"
+
+# Native operation registration and validated Ruby fallbacks.
+module Gsplat
+  # Ruby-facing validation and fallback wrappers for native operations.
+  module NativeOps
+    module_function
+
+    def spherical_harmonics_forward(degree, directions, coefficients, masks: nil)
+      prepared = Backend::RubySphericalHarmonics.send(
+        :validate_inputs, degree, directions, coefficients, masks
+      )
+      typed_directions, typed_coefficients, typed_masks, = prepared
+      return Backend::RubySphericalHarmonics.forward(degree, directions, coefficients, masks: masks) if typed_masks
+      unless typed_directions.is_a?(Numo::SFloat)
+        return Backend::RubySphericalHarmonics.forward(degree, directions, coefficients, masks: masks)
+      end
+
+      Native.spherical_harmonics_forward_sfloat(
+        degree,
+        typed_directions.dup,
+        typed_coefficients.dup
+      )
+    end
+
+    # rubocop:disable Metrics/ParameterLists
+    def projection_forward(means, covars, quaternions, scales, viewmats, intrinsics, width, height,
+                           eps2d:, near_plane:, far_plane:, radius_clip:, calc_compensations:, camera_model:,
+                           radial_coeffs: nil, tangential_coeffs: nil, thin_prism_coeffs: nil,
+                           global_z_order: true)
+      # rubocop:enable Metrics/ParameterLists
+      extended = camera_model.to_s == "fisheye" ||
+                 [radial_coeffs, tangential_coeffs, thin_prism_coeffs].any?
+      unless means.is_a?(Numo::SFloat) && !extended && global_z_order
+        return Backend::RubyProjection.forward(
+          means, covars, quaternions, scales, viewmats, intrinsics, width, height,
+          eps2d: eps2d, near_plane: near_plane, far_plane: far_plane,
+          radius_clip: radius_clip, calc_compensations: calc_compensations,
+          camera_model: camera_model, radial_coeffs: radial_coeffs,
+          tangential_coeffs: tangential_coeffs, thin_prism_coeffs: thin_prism_coeffs,
+          global_z_order: global_z_order
+        )
+      end
+      prepared = Backend::RubyProjection.send(
+        :prepare_inputs,
+        means, covars, quaternions, scales, viewmats, intrinsics, width, height,
+        eps2d, near_plane, far_plane, radius_clip, camera_model
+      )
+      typed_means, typed_covars, typed_views, typed_intrinsics = prepared
+      Native.projection_forward_sfloat(
+        typed_means.dup,
+        typed_covars.dup,
+        typed_views.dup,
+        typed_intrinsics.dup,
+        width,
+        height,
+        eps2d,
+        near_plane,
+        far_plane,
+        radius_clip,
+        calc_compensations,
+        camera_model.to_s == "ortho"
+      )
+    end
+
+    # rubocop:disable Metrics/ParameterLists
+    def isect_tiles(means2d, radii, depths, tile_size, tile_width, tile_height, sort:)
+      # rubocop:enable Metrics/ParameterLists
+      prepared = Backend::RubyIsectTiles.send(
+        :validate_inputs, means2d, radii, depths, tile_size, tile_width, tile_height
+      )
+      typed_means, typed_radii, typed_depths = prepared
+      unless typed_means.is_a?(Numo::SFloat)
+        return Backend::RubyIsectTiles.forward(
+          means2d, radii, depths, tile_size, tile_width, tile_height, sort: sort
+        )
+      end
+      tile_bits = Backend::RubyIsectTiles.send(:tile_n_bits, tile_width, tile_height)
+      Backend::RubyIsectTiles.send(:validate_key_width!, typed_means.shape[0], tile_bits)
+
+      Native.isect_tiles_sfloat(
+        typed_means.dup,
+        typed_radii.dup,
+        typed_depths.dup,
+        tile_size,
+        tile_width,
+        tile_height,
+        sort
+      )
+    end
+
+    def isect_offset_encode(keys, camera_count, tile_width, tile_height)
+      Backend::RubyIsectTiles.send(:validate_grid!, camera_count, tile_width, tile_height)
+      unless keys.is_a?(Numo::Int64)
+        return Backend::RubyIsectTiles.offset_encode(keys, camera_count, tile_width, tile_height)
+      end
+      raise ShapeError, "expected isect_ids [M]" unless keys.ndim == 1
+
+      Native.isect_offset_encode_int64(keys.dup, camera_count, tile_width, tile_height)
+    end
+  end
+
+  if Native.available?
+    Backend.register(
+      :spherical_harmonics_forward,
+      :native,
+      NativeOps.method(:spherical_harmonics_forward)
+    )
+    Backend.register(
+      :spherical_harmonics_backward,
+      :native,
+      Backend::RubySphericalHarmonics.method(:backward)
+    )
+    Backend.register(
+      :fully_fused_projection_forward,
+      :native,
+      NativeOps.method(:projection_forward)
+    )
+    Backend.register(
+      :fully_fused_projection_backward,
+      :native,
+      Backend::RubyProjectionBackward.method(:backward)
+    )
+    Backend.register(:isect_tiles, :native, NativeOps.method(:isect_tiles))
+    Backend.register(
+      :isect_offset_encode,
+      :native,
+      NativeOps.method(:isect_offset_encode)
+    )
+    Backend.register(
+      :rasterize_to_pixels_forward,
+      :native,
+      NativeRasterOps.method(:forward)
+    )
+    Backend.register(
+      :rasterize_to_pixels_backward,
+      :native,
+      NativeRasterOps.method(:backward)
+    )
+    Backend.register(
+      :rasterize_to_indices_in_range,
+      :native,
+      Backend::RubyRasterizeToIndicesInRange.method(:forward)
+    )
+  end
+end

data/lib/gsplat/native_raster_ops.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module Gsplat
+  # Validated float32 bridge for native tile rasterization.
+  module NativeRasterOps
+    module_function
+
+    # rubocop:disable Metrics/ParameterLists
+    def forward(means2d, conics, colors, opacities, backgrounds, masks, width, height,
+                tile_size, isect_offsets, flatten_ids)
+      # rubocop:enable Metrics/ParameterLists
+      prepared = Backend::RubyRasterizeToPixels.send(
+        :validate_inputs,
+        means2d, conics, colors, opacities, backgrounds, masks, width, height,
+        tile_size, isect_offsets, flatten_ids
+      )
+      unless means2d.is_a?(Numo::SFloat)
+        return Backend::RubyRasterizeToPixels.forward(
+          means2d, conics, colors, opacities, backgrounds, masks, width, height,
+          tile_size, isect_offsets, flatten_ids
+        )
+      end
+
+      typed_means, typed_conics, typed_colors, typed_opacities,
+        typed_backgrounds, typed_masks, typed_offsets, typed_ids = prepared
+      Native.rasterize_forward_sfloat(
+        typed_means.dup, typed_conics.dup, typed_colors.dup, typed_opacities.dup,
+        typed_backgrounds&.dup, native_masks(typed_masks), width, height, tile_size,
+        typed_offsets.dup, typed_ids.dup
+      )
+    end
+
+    # rubocop:disable Metrics/ParameterLists
+    def backward(means2d, conics, colors, opacities, backgrounds, masks, width, height,
+                 tile_size, isect_offsets, flatten_ids, render_alphas, last_ids,
+                 grad_render_colors, grad_render_alphas, absgrad:)
+      # rubocop:enable Metrics/ParameterLists
+      unless means2d.is_a?(Numo::SFloat)
+        return Backend::RubyRasterizeToPixelsBackward.backward(
+          means2d, conics, colors, opacities, backgrounds, masks, width, height,
+          tile_size, isect_offsets, flatten_ids, render_alphas, last_ids,
+          grad_render_colors, grad_render_alphas, absgrad: absgrad
+        )
+      end
+      prepared = Backend::RubyRasterizeToPixels.send(
+        :validate_inputs,
+        means2d, conics, colors, opacities, backgrounds, masks, width, height,
+        tile_size, isect_offsets, flatten_ids
+      )
+      typed_means, typed_conics, typed_colors, typed_opacities,
+        typed_backgrounds, typed_masks, typed_offsets, typed_ids = prepared
+      color_shape = [typed_means.shape[0], height, width, typed_colors.shape[-1]]
+      alpha_shape = [typed_means.shape[0], height, width, 1]
+      typed_color_grad = validate_gradient(grad_render_colors, color_shape)
+      typed_alpha_grad = validate_gradient(grad_render_alphas, alpha_shape)
+      Native.rasterize_backward_sfloat(
+        typed_means.dup, typed_conics.dup, typed_colors.dup, typed_opacities.dup,
+        typed_backgrounds&.dup, native_masks(typed_masks), width, height, tile_size,
+        typed_offsets.dup, typed_ids.dup, Numo::SFloat.cast(render_alphas).dup,
+        Numo::Int32.cast(last_ids).dup, typed_color_grad.dup, typed_alpha_grad.dup, absgrad
+      )
+    end
+
+    def native_masks(masks)
+      masks && Numo::Int32.cast(masks).dup
+    end
+    private_class_method :native_masks
+
+    def validate_gradient(gradient, shape)
+      Backend::RubyRasterizeToPixelsBackward.send(
+        :validate_gradient, Numo::SFloat, gradient, shape
+      )
+    end
+    private_class_method :validate_gradient
+  end
+end