gsplat 1.0.0

data/ext/gsplat_native/intersections.c

@@ -0,0 +1,211 @@
+#include <math.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+#include "common.h"
+
+typedef struct {
+    uint64_t *keys;
+    int32_t *flatten_ids;
+    size_t count;
+} gs_sort_args;
+
+static int
+gs_tile_bits(int width, int height)
+{
+    uint64_t count = (uint64_t)width * (uint64_t)height;
+    int bits = 0;
+    uint64_t capacity = 1;
+    while (capacity < count) {
+        capacity <<= 1;
+        bits += 1;
+    }
+    return bits;
+}
+
+static int
+gs_clamp_tile(int value, int maximum)
+{
+    if (value < 0) return 0;
+    if (value > maximum) return maximum;
+    return value;
+}
+
+static void
+gs_bounds(
+    const float *means,
+    const float *radii,
+    int elliptical,
+    int tile_size,
+    int tile_width,
+    int tile_height,
+    int *bounds
+)
+{
+    float radius_x = radii[0];
+    float radius_y = elliptical ? radii[1] : radius_x;
+    if (radius_x <= 0.0f || radius_y <= 0.0f) {
+        memset(bounds, 0, 4 * sizeof(int));
+        return;
+    }
+    bounds[0] = gs_clamp_tile((int)floorf((means[0] - radius_x) / tile_size), tile_width);
+    bounds[1] = gs_clamp_tile((int)floorf((means[1] - radius_y) / tile_size), tile_height);
+    bounds[2] = gs_clamp_tile((int)ceilf((means[0] + radius_x) / tile_size), tile_width);
+    bounds[3] = gs_clamp_tile((int)ceilf((means[1] + radius_y) / tile_size), tile_height);
+}
+
+static void *
+gs_radix_sort_without_gvl(void *opaque)
+{
+    gs_sort_args *args = (gs_sort_args *)opaque;
+    uint64_t *temporary_keys = malloc(args->count * sizeof(uint64_t));
+    int32_t *temporary_ids = malloc(args->count * sizeof(int32_t));
+    if (temporary_keys == NULL || temporary_ids == NULL) {
+        free(temporary_keys);
+        free(temporary_ids);
+        return (void *)1;
+    }
+    uint64_t *source_keys = args->keys;
+    uint64_t *destination_keys = temporary_keys;
+    int32_t *source_ids = args->flatten_ids;
+    int32_t *destination_ids = temporary_ids;
+    for (int pass = 0; pass < 8; ++pass) {
+        size_t counts[256] = {0};
+        int shift = pass * 8;
+        for (size_t index = 0; index < args->count; ++index) {
+            counts[(source_keys[index] >> shift) & 0xffu] += 1;
+        }
+        size_t running = 0;
+        for (int bucket = 0; bucket < 256; ++bucket) {
+            size_t value = counts[bucket];
+            counts[bucket] = running;
+            running += value;
+        }
+        for (size_t index = 0; index < args->count; ++index) {
+            int bucket = (source_keys[index] >> shift) & 0xffu;
+            size_t output_index = counts[bucket]++;
+            destination_keys[output_index] = source_keys[index];
+            destination_ids[output_index] = source_ids[index];
+        }
+        uint64_t *key_swap = source_keys;
+        source_keys = destination_keys;
+        destination_keys = key_swap;
+        int32_t *id_swap = source_ids;
+        source_ids = destination_ids;
+        destination_ids = id_swap;
+    }
+    free(temporary_keys);
+    free(temporary_ids);
+    return NULL;
+}
+
+static VALUE
+gs_isect_tiles(int argc, VALUE *argv, VALUE self)
+{
+    (void)self;
+    if (argc != 7) rb_raise(rb_eArgError, "expected 7 intersection arguments");
+    VALUE means2d = argv[0], radii = argv[1], depths = argv[2];
+    gs_require_sfloat(means2d, "means2d");
+    gs_require_sfloat(radii, "radii");
+    gs_require_sfloat(depths, "depths");
+    int tile_size = NUM2INT(argv[3]), tile_width = NUM2INT(argv[4]), tile_height = NUM2INT(argv[5]);
+    int sort = RTEST(argv[6]);
+    narray_t *mean_array = gs_narray(means2d);
+    narray_t *radius_array = gs_narray(radii);
+    size_t cameras = mean_array->shape[0], gaussians = mean_array->shape[1];
+    int elliptical = radius_array->ndim == 3;
+    size_t shape_cn[2] = {cameras, gaussians};
+    VALUE tiles_per = nary_new(numo_cInt32, 2, shape_cn);
+    int32_t *tile_counts = (int32_t *)na_get_pointer_for_write(tiles_per);
+    const float *mean_values = GS_SFLOAT_READ(means2d);
+    const float *radius_values = GS_SFLOAT_READ(radii);
+    size_t total = 0;
+    for (size_t index = 0; index < cameras * gaussians; ++index) {
+        int bounds[4];
+        gs_bounds(
+            mean_values + index * 2,
+            radius_values + index * (elliptical ? 2 : 1),
+            elliptical, tile_size, tile_width, tile_height, bounds
+        );
+        int count = (bounds[2] - bounds[0]) * (bounds[3] - bounds[1]);
+        tile_counts[index] = count;
+        total += count;
+    }
+    size_t shape_total[1] = {total};
+    VALUE keys = nary_new(numo_cInt64, 1, shape_total);
+    VALUE flatten_ids = nary_new(numo_cInt32, 1, shape_total);
+    uint64_t *key_values = (uint64_t *)na_get_pointer_for_write(keys);
+    int32_t *id_values = (int32_t *)na_get_pointer_for_write(flatten_ids);
+    const float *depth_values = GS_SFLOAT_READ(depths);
+    int tile_bits = gs_tile_bits(tile_width, tile_height);
+    size_t write_index = 0;
+    for (size_t camera = 0; camera < cameras; ++camera) {
+        for (size_t gaussian = 0; gaussian < gaussians; ++gaussian) {
+            size_t index = camera * gaussians + gaussian;
+            if (tile_counts[index] == 0) continue;
+            int bounds[4];
+            gs_bounds(
+                mean_values + index * 2,
+                radius_values + index * (elliptical ? 2 : 1),
+                elliptical, tile_size, tile_width, tile_height, bounds
+            );
+            union { float value; uint32_t bits; } depth = {depth_values[index]};
+            uint64_t upper_camera = camera << tile_bits;
+            for (int tile_y = bounds[1]; tile_y < bounds[3]; ++tile_y) {
+                for (int tile_x = bounds[0]; tile_x < bounds[2]; ++tile_x) {
+                    uint64_t tile_id = (uint64_t)tile_y * tile_width + tile_x;
+                    key_values[write_index] = ((upper_camera | tile_id) << 32) | depth.bits;
+                    id_values[write_index] = (int32_t)index;
+                    write_index += 1;
+                }
+            }
+        }
+    }
+    if (sort && total > 1) {
+        gs_sort_args args = {key_values, id_values, total};
+        void *failed = rb_thread_call_without_gvl(gs_radix_sort_without_gvl, &args, RUBY_UBF_IO, NULL);
+        if (failed != NULL) rb_raise(rb_eNoMemError, "native radix sort allocation failed");
+    }
+    return rb_ary_new_from_args(3, tiles_per, keys, flatten_ids);
+}
+
+static VALUE
+gs_offset_encode(VALUE self, VALUE keys, VALUE cameras_value, VALUE width_value, VALUE height_value)
+{
+    (void)self;
+    int cameras = NUM2INT(cameras_value), width = NUM2INT(width_value), height = NUM2INT(height_value);
+    int tile_bits = gs_tile_bits(width, height);
+    uint64_t tile_mask = tile_bits == 0 ? 0 : ((1ULL << tile_bits) - 1);
+    size_t tile_count = (size_t)cameras * width * height;
+    size_t *counts = ALLOC_N(size_t, tile_count);
+    memset(counts, 0, tile_count * sizeof(size_t));
+    narray_t *key_array = gs_narray(keys);
+    const uint64_t *key_values = (const uint64_t *)na_get_pointer_for_read(keys);
+    for (size_t index = 0; index < key_array->size; ++index) {
+        uint64_t upper = key_values[index] >> 32;
+        uint64_t camera = upper >> tile_bits;
+        uint64_t tile = upper & tile_mask;
+        if (camera >= (uint64_t)cameras || tile >= (uint64_t)(width * height)) {
+            xfree(counts);
+            rb_raise(rb_eArgError, "intersection key is outside the tile grid");
+        }
+        counts[camera * width * height + tile] += 1;
+    }
+    size_t shape[3] = {(size_t)cameras, (size_t)height, (size_t)width};
+    VALUE offsets = nary_new(numo_cInt32, 3, shape);
+    int32_t *offset_values = (int32_t *)na_get_pointer_for_write(offsets);
+    size_t running = 0;
+    for (size_t index = 0; index < tile_count; ++index) {
+        offset_values[index] = (int32_t)running;
+        running += counts[index];
+    }
+    xfree(counts);
+    return offsets;
+}
+
+void
+gs_init_intersections(VALUE native)
+{
+    rb_define_singleton_method(native, "isect_tiles_sfloat", gs_isect_tiles, -1);
+    rb_define_singleton_method(native, "isect_offset_encode_int64", gs_offset_encode, 4);
+}

data/ext/gsplat_native/projection.c

@@ -0,0 +1,199 @@
+#include <math.h>
+#include <string.h>
+#include "common.h"
+
+typedef struct {
+    size_t cameras;
+    size_t gaussians;
+    int width;
+    int height;
+    int orthographic;
+    int compensation;
+    float eps2d;
+    float near_plane;
+    float far_plane;
+    float radius_clip;
+    const float *means;
+    const float *covars;
+    const float *views;
+    const float *intrinsics;
+    int32_t *radii;
+    float *means2d;
+    float *depths;
+    float *conics;
+    float *compensations;
+} gs_projection_args;
+
+static void
+gs_mat3_product(const float *left, const float *right, float *output)
+{
+    for (int row = 0; row < 3; ++row) {
+        for (int column = 0; column < 3; ++column) {
+            float value = 0.0f;
+            for (int inner = 0; inner < 3; ++inner) {
+                value += left[row * 3 + inner] * right[inner * 3 + column];
+            }
+            output[row * 3 + column] = value;
+        }
+    }
+}
+
+static void
+gs_camera_covar(const float *rotation, const float *covar, float *output)
+{
+    float intermediate[9], transpose[9];
+    gs_mat3_product(rotation, covar, intermediate);
+    for (int row = 0; row < 3; ++row) {
+        for (int column = 0; column < 3; ++column) {
+            transpose[row * 3 + column] = rotation[column * 3 + row];
+        }
+    }
+    gs_mat3_product(intermediate, transpose, output);
+}
+
+static float
+gs_clip(float value, float minimum, float maximum)
+{
+    return fminf(fmaxf(value, minimum), maximum);
+}
+
+static void
+gs_project_one(gs_projection_args *args, size_t camera, size_t gaussian)
+{
+    const float *view = args->views + camera * 16;
+    const float *intrinsic = args->intrinsics + camera * 9;
+    const float *mean = args->means + gaussian * 3;
+    const float *covar = args->covars + gaussian * 9;
+    float rotation[9] = {
+        view[0], view[1], view[2],
+        view[4], view[5], view[6],
+        view[8], view[9], view[10]
+    };
+    float camera_mean[3];
+    for (int row = 0; row < 3; ++row) {
+        camera_mean[row] =
+            rotation[row * 3] * mean[0] +
+            rotation[row * 3 + 1] * mean[1] +
+            rotation[row * 3 + 2] * mean[2] +
+            view[row * 4 + 3];
+    }
+    float camera_covar[9];
+    gs_camera_covar(rotation, covar, camera_covar);
+    float depth = camera_mean[2];
+    float safe_z = (depth <= args->near_plane || depth >= args->far_plane) ? 1.0f : depth;
+    float jacobian[6] = {0};
+    float projected[2];
+    if (args->orthographic) {
+        jacobian[0] = intrinsic[0];
+        jacobian[4] = intrinsic[4];
+        projected[0] = camera_mean[0] * intrinsic[0] + intrinsic[2];
+        projected[1] = camera_mean[1] * intrinsic[4] + intrinsic[5];
+    } else {
+        float minimum_x = -(intrinsic[2] / intrinsic[0] + 0.15f * args->width / intrinsic[0]);
+        float maximum_x = (args->width - intrinsic[2]) / intrinsic[0] + 0.15f * args->width / intrinsic[0];
+        float minimum_y = -(intrinsic[5] / intrinsic[4] + 0.15f * args->height / intrinsic[4]);
+        float maximum_y = (args->height - intrinsic[5]) / intrinsic[4] + 0.15f * args->height / intrinsic[4];
+        float clipped_x = gs_clip(camera_mean[0] / safe_z, minimum_x, maximum_x) * safe_z;
+        float clipped_y = gs_clip(camera_mean[1] / safe_z, minimum_y, maximum_y) * safe_z;
+        jacobian[0] = intrinsic[0] / safe_z;
+        jacobian[2] = -intrinsic[0] * clipped_x / (safe_z * safe_z);
+        jacobian[4] = intrinsic[4] / safe_z;
+        jacobian[5] = -intrinsic[4] * clipped_y / (safe_z * safe_z);
+        projected[0] =
+            (intrinsic[0] * camera_mean[0] + intrinsic[1] * camera_mean[1] + intrinsic[2] * safe_z) / safe_z;
+        projected[1] =
+            (intrinsic[3] * camera_mean[0] + intrinsic[4] * camera_mean[1] + intrinsic[5] * safe_z) / safe_z;
+    }
+    float covar2d[4] = {0};
+    for (int row = 0; row < 2; ++row) {
+        for (int column = 0; column < 2; ++column) {
+            for (int left = 0; left < 3; ++left) {
+                for (int right = 0; right < 3; ++right) {
+                    covar2d[row * 2 + column] +=
+                        jacobian[row * 3 + left] * camera_covar[left * 3 + right] *
+                        jacobian[column * 3 + right];
+                }
+            }
+        }
+    }
+    float original_det = covar2d[0] * covar2d[3] - covar2d[1] * covar2d[2];
+    covar2d[0] += args->eps2d;
+    covar2d[3] += args->eps2d;
+    float determinant = covar2d[0] * covar2d[3] - covar2d[1] * covar2d[2];
+    float safe_det = determinant <= 0.0f ? 1e-10f : determinant;
+    int32_t radius_x = (int32_t)ceilf(3.33f * sqrtf(fmaxf(covar2d[0], 0.0f)));
+    int32_t radius_y = (int32_t)ceilf(3.33f * sqrtf(fmaxf(covar2d[3], 0.0f)));
+    int visible = determinant > 0.0f && depth > args->near_plane && depth < args->far_plane &&
+                  (radius_x > args->radius_clip || radius_y > args->radius_clip) &&
+                  projected[0] + radius_x > 0.0f && projected[0] - radius_x < args->width &&
+                  projected[1] + radius_y > 0.0f && projected[1] - radius_y < args->height;
+    size_t index = camera * args->gaussians + gaussian;
+    args->radii[index * 2] = visible ? radius_x : 0;
+    args->radii[index * 2 + 1] = visible ? radius_y : 0;
+    args->means2d[index * 2] = projected[0];
+    args->means2d[index * 2 + 1] = projected[1];
+    args->depths[index] = depth;
+    args->conics[index * 3] = covar2d[3] / safe_det;
+    args->conics[index * 3 + 1] = -(covar2d[1] + covar2d[2]) / (2.0f * safe_det);
+    args->conics[index * 3 + 2] = covar2d[0] / safe_det;
+    if (args->compensation) {
+        args->compensations[index] = sqrtf(fmaxf(original_det / safe_det, 0.0f));
+    }
+}
+
+static void *
+gs_projection_without_gvl(void *opaque)
+{
+    gs_projection_args *args = (gs_projection_args *)opaque;
+    size_t count = args->cameras * args->gaussians;
+#ifdef GSPLAT_OPENMP
+#pragma omp parallel for
+#endif
+    for (size_t index = 0; index < count; ++index) {
+        gs_project_one(args, index / args->gaussians, index % args->gaussians);
+    }
+    return NULL;
+}
+
+static VALUE
+gs_projection_forward(int argc, VALUE *argv, VALUE self)
+{
+    (void)self;
+    if (argc != 12) rb_raise(rb_eArgError, "expected 12 projection arguments");
+    VALUE means = argv[0], covars = argv[1], views = argv[2], intrinsics = argv[3];
+    VALUE width = argv[4], height = argv[5], eps2d = argv[6], near_plane = argv[7];
+    VALUE far_plane = argv[8], radius_clip = argv[9], compensation = argv[10], orthographic = argv[11];
+    gs_require_sfloat(means, "means");
+    gs_require_sfloat(covars, "covars");
+    gs_require_sfloat(views, "viewmats");
+    gs_require_sfloat(intrinsics, "intrinsics");
+    narray_t *mean_array = gs_narray(means);
+    narray_t *view_array = gs_narray(views);
+    size_t cameras = view_array->shape[0], gaussians = mean_array->shape[0];
+    size_t shape_cn[2] = {cameras, gaussians};
+    size_t shape_cn2[3] = {cameras, gaussians, 2};
+    size_t shape_cn3[3] = {cameras, gaussians, 3};
+    VALUE radii = nary_new(numo_cInt32, 3, shape_cn2);
+    VALUE means2d = nary_new(numo_cSFloat, 3, shape_cn2);
+    VALUE depths = nary_new(numo_cSFloat, 2, shape_cn);
+    VALUE conics = nary_new(numo_cSFloat, 3, shape_cn3);
+    VALUE compensations = RTEST(compensation) ? nary_new(numo_cSFloat, 2, shape_cn) : Qnil;
+    gs_projection_args args = {
+        cameras, gaussians, NUM2INT(width), NUM2INT(height),
+        RTEST(orthographic), RTEST(compensation),
+        NUM2DBL(eps2d), NUM2DBL(near_plane), NUM2DBL(far_plane), NUM2DBL(radius_clip),
+        GS_SFLOAT_READ(means), GS_SFLOAT_READ(covars), GS_SFLOAT_READ(views),
+        GS_SFLOAT_READ(intrinsics),
+        (int32_t *)na_get_pointer_for_write(radii),
+        GS_SFLOAT_WRITE(means2d), GS_SFLOAT_WRITE(depths), GS_SFLOAT_WRITE(conics),
+        NIL_P(compensations) ? NULL : GS_SFLOAT_WRITE(compensations)
+    };
+    rb_thread_call_without_gvl(gs_projection_without_gvl, &args, RUBY_UBF_IO, NULL);
+    return rb_ary_new_from_args(5, radii, means2d, depths, conics, compensations);
+}
+
+void
+gs_init_projection(VALUE native)
+{
+    rb_define_singleton_method(native, "projection_forward_sfloat", gs_projection_forward, -1);
+}

data/ext/gsplat_native/raster_backward.c

@@ -0,0 +1,129 @@
+#include <math.h>
+#include "rasterization.h"
+
+#ifdef GSPLAT_OPENMP
+#define GS_ATOMIC_ADD(target, value) do { \
+    _Pragma("omp atomic update") \
+    (target) += (value); \
+} while (0)
+#else
+#define GS_ATOMIC_ADD(target, value) ((target) += (value))
+#endif
+
+static void
+gs_raster_backward_pixel(
+    gs_raster_backward_args *args,
+    size_t camera,
+    int x,
+    int y,
+    size_t range_start,
+    size_t range_end
+)
+{
+    gs_raster_forward_args *forward = &args->forward;
+    size_t pixel = (camera * forward->height + (size_t)y) * forward->width + (size_t)x;
+    const float *pixel_color_grad = args->grad_render_colors + pixel * forward->channels;
+    float current_transmittance = 1.0f - args->render_alphas[pixel];
+    float after_transmittance = 1.0f;
+    float remaining_color[forward->channels];
+    for (size_t channel = 0; channel < forward->channels; ++channel) {
+        remaining_color[channel] = forward->backgrounds == NULL ?
+            0.0f : forward->backgrounds[camera * forward->channels + channel];
+        if (args->grad_backgrounds != NULL) {
+            GS_ATOMIC_ADD(
+                args->grad_backgrounds[camera * forward->channels + channel],
+                pixel_color_grad[channel] * current_transmittance
+            );
+        }
+    }
+    size_t tile = (camera * forward->tile_height + y / forward->tile_size) *
+        forward->tile_width + x / forward->tile_size;
+    if (forward->masks != NULL && forward->masks[tile] == 0) return;
+    for (size_t cursor = range_end; cursor > range_start; --cursor) {
+        size_t intersection = cursor - 1;
+        int32_t gaussian = forward->flatten_ids[intersection];
+        float delta_x = forward->means[gaussian * 2] - ((float)x + 0.5f);
+        float delta_y = forward->means[gaussian * 2 + 1] - ((float)y + 0.5f);
+        const float *conic = forward->conics + gaussian * 3;
+        float sigma = 0.5f * (
+            conic[0] * delta_x * delta_x + conic[2] * delta_y * delta_y
+        ) + conic[1] * delta_x * delta_y;
+        float response = expf(-sigma);
+        float raw_alpha = forward->opacities[gaussian] * response;
+        float alpha = raw_alpha > GS_ALPHA_CLAMP ? GS_ALPHA_CLAMP : raw_alpha;
+        int valid = args->render_alphas[pixel] > 0.0f && sigma >= 0.0f &&
+            alpha >= GS_ALPHA_SKIP && args->last_ids[pixel] >= (int32_t)intersection &&
+            current_transmittance < 1.0f && alpha < 1.0f;
+        if (!valid) continue;
+        float transmittance_before = current_transmittance / (1.0f - alpha);
+        float visibility = transmittance_before * alpha;
+        const float *color = forward->colors + gaussian * forward->channels;
+        float color_dot = 0.0f;
+        for (size_t channel = 0; channel < forward->channels; ++channel) {
+            GS_ATOMIC_ADD(
+                args->grad_colors[gaussian * forward->channels + channel],
+                pixel_color_grad[channel] * visibility
+            );
+            color_dot += pixel_color_grad[channel] * (color[channel] - remaining_color[channel]);
+        }
+        float grad_alpha = transmittance_before * (
+            color_dot + args->grad_render_alphas[pixel] * after_transmittance
+        );
+        float grad_raw_alpha = raw_alpha < GS_ALPHA_CLAMP ? grad_alpha : 0.0f;
+        GS_ATOMIC_ADD(args->grad_opacities[gaussian], grad_raw_alpha * response);
+        float grad_sigma = -grad_raw_alpha * raw_alpha;
+        float mean_x = grad_sigma * (conic[0] * delta_x + conic[1] * delta_y);
+        float mean_y = grad_sigma * (conic[2] * delta_y + conic[1] * delta_x);
+        GS_ATOMIC_ADD(args->grad_means[gaussian * 2], mean_x);
+        GS_ATOMIC_ADD(args->grad_means[gaussian * 2 + 1], mean_y);
+        if (args->grad_means_abs != NULL) {
+            GS_ATOMIC_ADD(args->grad_means_abs[gaussian * 2], fabsf(mean_x));
+            GS_ATOMIC_ADD(args->grad_means_abs[gaussian * 2 + 1], fabsf(mean_y));
+        }
+        GS_ATOMIC_ADD(args->grad_conics[gaussian * 3], grad_sigma * 0.5f * delta_x * delta_x);
+        GS_ATOMIC_ADD(args->grad_conics[gaussian * 3 + 1], grad_sigma * delta_x * delta_y);
+        GS_ATOMIC_ADD(args->grad_conics[gaussian * 3 + 2], grad_sigma * 0.5f * delta_y * delta_y);
+        for (size_t channel = 0; channel < forward->channels; ++channel) {
+            remaining_color[channel] =
+                alpha * color[channel] + (1.0f - alpha) * remaining_color[channel];
+        }
+        after_transmittance *= 1.0f - alpha;
+        current_transmittance = transmittance_before;
+    }
+}
+
+void *
+gs_raster_backward_without_gvl(void *opaque)
+{
+    gs_raster_backward_args *args = (gs_raster_backward_args *)opaque;
+    gs_raster_forward_args *forward = &args->forward;
+    size_t tiles_per_camera = (size_t)forward->tile_width * forward->tile_height;
+    size_t total_tiles = forward->cameras * tiles_per_camera;
+#ifdef GSPLAT_OPENMP
+#pragma omp parallel for schedule(dynamic, 1)
+#endif
+    for (size_t tile = 0; tile < total_tiles; ++tile) {
+        size_t camera = tile / tiles_per_camera;
+        size_t local_tile = tile % tiles_per_camera;
+        int tile_y = (int)(local_tile / forward->tile_width);
+        int tile_x = (int)(local_tile % forward->tile_width);
+        int x_start = tile_x * forward->tile_size;
+        int y_start = tile_y * forward->tile_size;
+        int x_end = x_start + forward->tile_size;
+        int y_end = y_start + forward->tile_size;
+        if (x_end > forward->width) x_end = forward->width;
+        if (y_end > forward->height) y_end = forward->height;
+        if (x_start >= forward->width || y_start >= forward->height) continue;
+        size_t range_start = (size_t)forward->offsets[tile];
+        size_t range_end = tile + 1 < total_tiles ?
+            (size_t)forward->offsets[tile + 1] : forward->intersection_count;
+        int masked = forward->masks != NULL && forward->masks[tile] == 0;
+        if ((masked || range_start == range_end) && args->grad_backgrounds == NULL) continue;
+        for (int y = y_start; y < y_end; ++y) {
+            for (int x = x_start; x < x_end; ++x) {
+                gs_raster_backward_pixel(args, camera, x, y, range_start, range_end);
+            }
+        }
+    }
+    return NULL;
+}

data/ext/gsplat_native/raster_backward_bridge.c

@@ -0,0 +1,69 @@
+#include <string.h>
+#include "common.h"
+#include "rasterization.h"
+
+static VALUE
+gs_zero_sfloat(int dimensions, size_t *shape)
+{
+    VALUE output = nary_new(numo_cSFloat, dimensions, shape);
+    memset(GS_SFLOAT_WRITE(output), 0, gs_narray(output)->size * sizeof(float));
+    return output;
+}
+
+static VALUE
+gs_raster_backward(int argc, VALUE *argv, VALUE self)
+{
+    (void)self;
+    if (argc != 16) rb_raise(rb_eArgError, "expected 16 raster backward arguments");
+    int sfloat_indices[] = {0, 1, 2, 3, 11, 13, 14};
+    for (size_t index = 0; index < sizeof(sfloat_indices) / sizeof(int); ++index) {
+        gs_require_sfloat(argv[sfloat_indices[index]], "raster input");
+    }
+    if (!NIL_P(argv[4])) gs_require_sfloat(argv[4], "backgrounds");
+    if (!NIL_P(argv[5])) gs_require_int32(argv[5], "masks");
+    gs_require_int32(argv[9], "isect_offsets");
+    gs_require_int32(argv[10], "flatten_ids");
+    gs_require_int32(argv[12], "last_ids");
+    narray_t *means = gs_narray(argv[0]);
+    narray_t *colors = gs_narray(argv[2]);
+    narray_t *offsets = gs_narray(argv[9]);
+    size_t means_shape[3] = {means->shape[0], means->shape[1], 2};
+    size_t conic_shape[3] = {means->shape[0], means->shape[1], 3};
+    size_t color_shape[3] = {means->shape[0], means->shape[1], colors->shape[2]};
+    size_t opacity_shape[2] = {means->shape[0], means->shape[1]};
+    size_t background_shape[2] = {means->shape[0], colors->shape[2]};
+    VALUE grad_means = gs_zero_sfloat(3, means_shape);
+    VALUE grad_conics = gs_zero_sfloat(3, conic_shape);
+    VALUE grad_colors = gs_zero_sfloat(3, color_shape);
+    VALUE grad_opacities = gs_zero_sfloat(2, opacity_shape);
+    VALUE grad_backgrounds = NIL_P(argv[4]) ? Qnil : gs_zero_sfloat(2, background_shape);
+    VALUE grad_means_abs = RTEST(argv[15]) ? gs_zero_sfloat(3, means_shape) : Qnil;
+    gs_raster_backward_args args = {
+        {
+            GS_SFLOAT_READ(argv[0]), GS_SFLOAT_READ(argv[1]), GS_SFLOAT_READ(argv[2]),
+            GS_SFLOAT_READ(argv[3]), NIL_P(argv[4]) ? NULL : GS_SFLOAT_READ(argv[4]),
+            NIL_P(argv[5]) ? NULL : GS_INT32_READ(argv[5]), GS_INT32_READ(argv[9]),
+            GS_INT32_READ(argv[10]), NULL, NULL, NULL, means->shape[0], means->shape[1],
+            colors->shape[2], gs_narray(argv[10])->size, NUM2INT(argv[6]), NUM2INT(argv[7]),
+            NUM2INT(argv[8]), (int)offsets->shape[2], (int)offsets->shape[1]
+        },
+        GS_SFLOAT_READ(argv[11]), GS_INT32_READ(argv[12]), GS_SFLOAT_READ(argv[13]),
+        GS_SFLOAT_READ(argv[14]), GS_SFLOAT_WRITE(grad_means), GS_SFLOAT_WRITE(grad_conics),
+        GS_SFLOAT_WRITE(grad_colors), GS_SFLOAT_WRITE(grad_opacities),
+        NIL_P(grad_backgrounds) ? NULL : GS_SFLOAT_WRITE(grad_backgrounds),
+        NIL_P(grad_means_abs) ? NULL : GS_SFLOAT_WRITE(grad_means_abs)
+    };
+    rb_thread_call_without_gvl(gs_raster_backward_without_gvl, &args, RUBY_UBF_IO, NULL);
+    VALUE gradients = rb_ary_new_from_args(
+        5, grad_means, grad_conics, grad_colors, grad_opacities, grad_backgrounds
+    );
+    RB_GC_GUARD(argv[0]);
+    RB_GC_GUARD(gradients);
+    return rb_ary_new_from_args(2, gradients, grad_means_abs);
+}
+
+void
+gs_init_rasterization_backward(VALUE native)
+{
+    rb_define_singleton_method(native, "rasterize_backward_sfloat", gs_raster_backward, -1);
+}