conquer3d 0.1.9__tar.gz → 0.2.1__tar.gz

conquer3d-0.2.1/MANIFEST.in

@@ -0,0 +1 @@
+recursive-include conquer3d/csrc *.h *.hpp *.cuh *.cpp *.cu

{conquer3d-0.1.9 → conquer3d-0.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: conquer3d
-Version: 0.1.9
+Version: 0.2.1
 Summary: Geometric Cuda Tool Box
 Author-email: Do Hoang Khoi <khoido8899@gmail.com>
 License: MIT
@@ -9,7 +9,7 @@ Project-URL: Repository, https://github.com/KhoiDOO/conquer3d.git
 Project-URL: Documentation, https://github.com/KhoiDOO/conquer3d#readme
 Project-URL: Issues, https://github.com/KhoiDOO/conquer3d/issues
 Keywords: geometry
-Requires-Python: >=3.10
+Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: torch>=2.0.0
@@ -58,8 +58,9 @@ pip install plotly open3d jupyter trimesh
 # Development
 ```bash
 pip install build twine
+rm -rf dist
 python -m build --sdist
-twine upload dist/*
+twine upload dist/* --verbose
 ```
 
 # Reference

{conquer3d-0.1.9 → conquer3d-0.2.1}/README.md

@@ -34,8 +34,9 @@ pip install plotly open3d jupyter trimesh
 # Development
 ```bash
 pip install build twine
+rm -rf dist
 python -m build --sdist
-twine upload dist/*
+twine upload dist/* --verbose
 ```
 
 # Reference

conquer3d-0.2.1/conquer3d/csrc/check.h

@@ -0,0 +1,29 @@
+#ifndef CHECK_H
+#define CHECK_H
+
+#include <cuda_runtime.h>
+#include <stdio.h>
+#include <stdint.h>
+
+// Helper macros to check tensor properties
+// These require <torch/extension.h> or <ATen/ATen.h> to be included in the translation unit
+#define CHECK_CUDA(x) \
+    TORCH_CHECK((x).device().is_cuda(), #x " must be a CUDA tensor")
+#define CHECK_CONTIGUOUS(x) \
+    TORCH_CHECK((x).is_contiguous(), #x " must be contiguous")
+#define CHECK_INPUT(x) \
+    CHECK_CUDA(x);     \
+    CHECK_CONTIGUOUS(x)
+
+inline bool check_cuda_result(cudaError_t code, const char *file, int line)
+{
+    if (code == cudaSuccess)
+        return true;
+
+    fprintf(stderr, "CUDA error %u: %s (%s:%d)\n", unsigned(code), cudaGetErrorString(code), file, line);
+    return false;
+}
+
+#define CUDA_CHECK(code) check_cuda_result((code), __FILE__, __LINE__)
+
+#endif // CHECK_H

conquer3d-0.2.1/conquer3d/csrc/constants.h

@@ -0,0 +1,26 @@
+#ifndef CONSTANTS_H
+#define CONSTANTS_H
+
+// ==========================================
+// CUDA
+// ==========================================
+#define NTHREADS 256
+
+// ==========================================
+// KD-Tree
+// ==========================================
+#define MAX_K 32
+
+// ==========================================
+// BVH
+// ==========================================
+#define BVH_STACK_SIZE 64
+#define BVH_MAX_CAPACITY 10000000
+
+// ==========================================
+// GAUSSIANS
+// ==========================================
+#define ISO 11.345
+#define TOL 0.125
+
+#endif // CONSTANTS_H

conquer3d-0.2.1/conquer3d/csrc/data_structure/bvh.h

@@ -0,0 +1,61 @@
+#ifndef BVH_H
+#define BVH_H
+
+#include "../maths/maths.h"
+#include "../constants.h"
+#include "../primitive/aabb.h"
+
+#include <torch/extension.h>
+#include <cuda_runtime.h>
+#include <cstdint>
+
+class BVH
+{
+protected:
+    uint32_t num_objects;
+    uint32_t num_nodes; // Will always be 2N - 1
+
+    torch::Tensor aabb_mins; // Size: [2N - 1, 3]
+    torch::Tensor aabb_maxs; // Size: [2N - 1, 3]
+    torch::Tensor bvh_children; // Size: [2N - 1, 2] -> x = left_child, y = right_child
+    torch::Tensor bvh_parents; // Size: [2N - 1] -> index of parent node
+    torch::Tensor object_ids; // Size: [N] -> Maps the sorted leaf index back to the original Gaussian index
+
+public:
+    BVH(const torch::Tensor &in_aabb_mins, const torch::Tensor &in_aabb_maxs);
+
+    std::tuple<torch::Tensor, torch::Tensor> query(
+        const torch::Tensor &query_aabb_mins,
+        const torch::Tensor &query_aabb_maxs);
+};
+
+namespace bvh
+{
+    __host__ void build(
+        const uint32_t num_objects,
+        const uint32_t num_nodes,
+        const float3 *__restrict__ in_aabb_mins, // Unsorted input
+        const float3 *__restrict__ in_aabb_maxs, // Unsorted input
+        float3 *__restrict__ bvh_aabb_mins,      // Size 2N-1
+        float3 *__restrict__ bvh_aabb_maxs,      // Size 2N-1
+        int2 *__restrict__ bvh_children,         // Size 2N-1
+        int *__restrict__ bvh_parents,           // Size 2N-1
+        int *__restrict__ object_ids             // Size N
+    );
+
+    __host__ void query(
+        const uint32_t num_queries,
+        const uint32_t num_objects,
+        const float3 *__restrict__ query_mins,
+        const float3 *__restrict__ query_maxs,
+        const float3 *__restrict__ bvh_aabb_mins,
+        const float3 *__restrict__ bvh_aabb_maxs,
+        const int2 *__restrict__ bvh_children,
+        const int *__restrict__ object_ids,
+        int64_t *__restrict__ out_query_ids,
+        int64_t *__restrict__ out_object_ids,
+        int64_t *__restrict__ hit_counter,
+        const int64_t max_capacity);
+}
+
+#endif // BVH_H

conquer3d-0.2.1/conquer3d/csrc/data_structure/gs_bvh.h

@@ -0,0 +1,49 @@
+#ifndef GS_BVH_H
+#define GS_BVH_H
+
+#include "bvh.h"
+#include "../primitive/gs.h"
+
+#include <variant>
+
+class GSBVH : public BVH
+{
+public:
+    // Inherit the base constructor (this automatically builds the tree!)
+    using BVH::BVH;
+    using BVH::query;
+
+    // Add Gaussian-specific queries
+    std::tuple<torch::Tensor, torch::Tensor, torch::Tensor, std::optional<torch::Tensor>, std::optional<torch::Tensor>> query_voxel_pair(
+        const torch::Tensor &vx_aabb_mins,
+        const torch::Tensor &vx_aabb_maxs,
+        const torch::Tensor &means,
+        const torch::Tensor &covis,
+        const torch::Tensor &opacities,
+        const torch::Tensor &gs_aabb_mins,
+        const torch::Tensor &gs_aabb_maxs,
+        const torch::Tensor &contact_points,
+        const std::variant<float, torch::Tensor> &isos,
+        const float ar_threshold,
+        const float p_threshold,
+        const bool return_centroids,
+        const int64_t max_capacity);
+
+    std::tuple<torch::Tensor, torch::Tensor, torch::Tensor> query_edge_pair(
+        const torch::Tensor &edge_starts,
+        const torch::Tensor &edge_ends,
+        const torch::Tensor &means,
+        const torch::Tensor &covis,
+        const std::variant<float, torch::Tensor> &isos,
+        const int64_t max_capacity);
+
+    std::tuple<torch::Tensor, torch::Tensor> query_edge(
+        const torch::Tensor &edge_starts,
+        const torch::Tensor &edge_ends,
+        const torch::Tensor &means,
+        const torch::Tensor &opacities,
+        const torch::Tensor &covis,
+        const std::variant<float, torch::Tensor> &isos);
+};
+
+#endif // GS_BVH_H

conquer3d-0.2.1/conquer3d/csrc/data_structure/kdtree.h

@@ -0,0 +1,111 @@
+#ifndef KDTREE_H
+#define KDTREE_H
+
+#include "../maths/maths.h"
+#include "../constants.h"
+
+#include <torch/extension.h>
+#include <cuda_runtime.h>
+#include <cstdint>
+
+class KDTree {
+private:
+    uint32_t num_points;
+    
+    torch::Tensor points;
+    torch::Tensor oinds;
+
+public:
+    KDTree(const torch::Tensor& points);
+
+    std::tuple<torch::Tensor, torch::Tensor> query(
+        const torch::Tensor& query_points, 
+        const int k,
+        bool exclude_self=false
+    );
+};
+
+namespace kdtree {
+    void build(
+        const uint32_t num_points,
+        float3 *__restrict__ points,
+        int64_t *__restrict__ original_inds);
+
+    void query(
+        const uint32_t num_queries,
+        const uint32_t num_points,
+        const uint32_t k,
+        const float3 *__restrict__ query_points,
+        const float3 *__restrict__ tree_points,
+        const int64_t *__restrict__ tree_inds,
+        float *__restrict__ out_dists,
+        int64_t *__restrict__ out_inds);
+    
+    __device__ __forceinline__ void push_pq(
+        float dist, 
+        int64_t id, 
+        float* best_dists, 
+        int64_t* best_inds, 
+        const int k)
+    {
+        if (dist >= best_dists[k - 1]) return;
+        int i = k - 2;
+        while (i >= 0 && best_dists[i] > dist) {
+            best_dists[i + 1] = best_dists[i];
+            best_inds[i + 1]  = best_inds[i];
+            i--;
+        }
+        best_dists[i + 1] = dist;
+        best_inds[i + 1]  = id;
+    }
+
+    __device__ __forceinline__ void query_kdtree_loop(
+        const float3& qp,
+        const uint32_t num_points,
+        const float3* __restrict__ tree_points,
+        const int64_t* __restrict__ tree_inds,
+        const int k,
+        float* best_dists,
+        int64_t* best_inds)
+    {
+        int stack[64];
+        int stack_ptr = 0;
+
+        stack[stack_ptr++] = 0;
+
+        while (stack_ptr > 0) {
+            int curr = stack[--stack_ptr];
+            if (curr >= num_points) continue;
+            
+            float3 p = tree_points[curr];
+            
+            #ifdef __CUDA_ARCH__
+                int axis = (31 - __clz(curr + 1)) % 3;
+            #else
+                int axis = (31 - __builtin_clz((unsigned int)(curr + 1))) % 3;
+            #endif
+
+            float3 d = qp - p;
+            float dist_sq = maths::dot(d, d);
+
+            push_pq(dist_sq, tree_inds[curr], best_dists, best_inds, k);
+
+            float axis_dist = (axis == 0) ? d.x : ((axis == 1) ? d.y : d.z);
+
+            int left_child = 2 * curr + 1;
+            int right_child = 2 * curr + 2;
+
+            int near_child = (axis_dist <= 0) ? left_child : right_child;
+            int far_child  = (axis_dist <= 0) ? right_child : left_child;
+
+            if (far_child < num_points && (axis_dist * axis_dist <= best_dists[k - 1])) {
+                stack[stack_ptr++] = far_child;
+            }
+            if (near_child < num_points) {
+                stack[stack_ptr++] = near_child;
+            }
+        }
+    }
+}
+
+#endif // KDTREE_H

conquer3d-0.2.1/conquer3d/csrc/data_structure/pgs_bvh.h

@@ -0,0 +1,40 @@
+#ifndef PGS_BVH_H
+#define PGS_BVH_H
+
+#include "bvh.h"
+#include "../primitive/pgs.h"
+
+#include <variant>
+
+class PGSBVH : public BVH
+{
+public:
+    // Inherit the base constructor (this automatically builds the tree!)
+    using BVH::BVH;
+    using BVH::query;
+
+    // Add Gaussian-specific queries
+    std::tuple<torch::Tensor, torch::Tensor, torch::Tensor, std::optional<torch::Tensor>, std::optional<torch::Tensor>> query_voxel_pair(
+        const torch::Tensor &vx_aabb_mins,
+        const torch::Tensor &vx_aabb_maxs,
+        const torch::Tensor &means,
+        const torch::Tensor &normals,
+        const torch::Tensor &covis,
+        const torch::Tensor &gs_aabb_mins,
+        const torch::Tensor &gs_aabb_maxs,
+        const std::variant<float, torch::Tensor> &isos,
+        const bool return_centroids,
+        const bool return_centroid_densities,
+        const int64_t max_capacity);
+
+    std::tuple<torch::Tensor, torch::Tensor> query_edge(
+        const torch::Tensor &edge_starts,
+        const torch::Tensor &edge_ends,
+        const torch::Tensor &means,
+        const torch::Tensor &normals,
+        const torch::Tensor &opacities,
+        const torch::Tensor &covis,
+        const std::variant<float, torch::Tensor> &isos);
+};
+
+#endif // PGS_BVH_H

conquer3d-0.2.1/conquer3d/csrc/data_structure/zcurve.h

@@ -0,0 +1,30 @@
+#ifndef ZCURVE_H
+#define ZCURVE_H
+
+#include "../maths/maths.h"
+#include "cuda_runtime.h"
+
+namespace zcurve
+{
+    __device__ unsigned int expandBits(unsigned int v)
+    {
+        v = (v * 0x00010001u) & 0xFF0000FFu;
+        v = (v * 0x00000101u) & 0x0F00F00Fu;
+        v = (v * 0x00000011u) & 0xC30C30C3u;
+        v = (v * 0x00000005u) & 0x49249249u;
+        return v;
+    }
+
+    __device__ unsigned int morton3D(float x, float y, float z)
+    {
+        x = min(max(x * 1024.0f, 0.0f), 1023.0f);
+        y = min(max(y * 1024.0f, 0.0f), 1023.0f);
+        z = min(max(z * 1024.0f, 0.0f), 1023.0f);
+        unsigned int xx = expandBits((unsigned int)x);
+        unsigned int yy = expandBits((unsigned int)y);
+        unsigned int zz = expandBits((unsigned int)z);
+        return xx * 4 + yy * 2 + zz;
+    }
+}
+
+#endif // ZCURVE_H

conquer3d-0.2.1/conquer3d/csrc/maths/f2x2.h

@@ -0,0 +1,90 @@
+#ifndef F2X2_H
+#define F2X2_H
+
+#include "ops.h"
+
+#include <stdint.h>
+#include <cmath>
+#include <vector_types.h>
+#include <vector_functions.h>
+#include <math_constants.h>
+
+typedef struct
+{
+    float m[2][2];
+} float2x2;
+
+static __inline__ __host__ __device__ float2x2 make_float2x2(
+    float a00, float a01,
+    float a10, float a11) {
+    float2x2 a;
+    a.m[0][0] = a00; a.m[0][1] = a01;
+    a.m[1][0] = a10; a.m[1][1] = a11;
+    return a;
+}
+
+// [2, 2] x [2, 2] = [2, 2]
+static __inline__ __host__ __device__ float2x2 operator* (const float2x2& a, const float2x2& b)
+{
+    float2x2 c;
+
+    c.m[0][0] = a.m[0][0] * b.m[0][0] + a.m[0][1] * b.m[1][0];
+    c.m[0][1] = a.m[0][0] * b.m[0][1] + a.m[0][1] * b.m[1][1];
+    c.m[1][0] = a.m[1][0] * b.m[0][0] + a.m[1][1] * b.m[1][0];
+    c.m[1][1] = a.m[1][0] * b.m[0][1] + a.m[1][1] * b.m[1][1];
+
+    return c;
+}
+
+// [2, 1]^T x [2, 2] = [2, 1]^T
+static __inline__ __host__ __device__ float2 operator*(const float2& a, const float2x2& m) {
+    return make_float2(
+        a.x * m.m[0][0] + a.y * m.m[1][0],
+        a.x * m.m[0][1] + a.y * m.m[1][1]
+    );
+}
+
+// [2, 2] x [2, 1] = [2, 1]
+static __inline__ __host__ __device__ float2 operator*(const float2x2& m, const float2& a) {
+    return make_float2(
+        m.m[0][0] * a.x + m.m[0][1] * a.y,
+        m.m[1][0] * a.x + m.m[1][1] * a.y
+    );
+}
+
+namespace maths
+{
+    static __inline__ __host__ __device__ float2x2 transpose(const float2x2& a) {
+        float2x2 b;
+        b.m[0][0] = a.m[0][0]; b.m[0][1] = a.m[1][0];
+        b.m[1][0] = a.m[0][1]; b.m[1][1] = a.m[1][1];
+        return b;
+    }
+
+    static __inline__ __host__ __device__ float det(const float2x2& a) {
+        return a.m[0][0] * a.m[1][1] - a.m[0][1] * a.m[1][0];
+    }
+
+    static inline __host__ __device__ void copy(float2x2 &a, float2x2 b) {
+        a.m[0][0] = b.m[0][0]; a.m[0][1] = b.m[0][1];
+        a.m[1][0] = b.m[1][0]; a.m[1][1] = b.m[1][1];
+    }
+
+    static __host__ __device__ __forceinline__ bool invert(const float2x2& m, float2x2& out_inv) 
+    {
+        float det_val = m.m[0][0] * m.m[1][1] - m.m[0][1] * m.m[1][0];
+
+        if (fabsf(det_val) < 1e-8f) return false;
+
+        float inv_det = 1.0f / det_val;
+
+        out_inv.m[0][0] =  m.m[1][1] * inv_det;
+        out_inv.m[0][1] = -m.m[0][1] * inv_det;
+        out_inv.m[1][0] = -m.m[1][0] * inv_det;
+        out_inv.m[1][1] =  m.m[0][0] * inv_det;
+
+        return true;
+    }
+}
+
+#endif // F2X2_H

conquer3d-0.2.1/conquer3d/csrc/maths/f3x1.h

@@ -0,0 +1,82 @@
+#ifndef F3x1_H
+#define F3x1_H
+
+#include "ops.h"
+
+#include <stdint.h>
+#include <cmath>
+#include <vector_types.h>
+#include <vector_functions.h>
+#include <math_constants.h>
+
+static inline __host__ __device__ float3 operator+(float3 a, float3 b) {
+    return make_float3(a.x + b.x, a.y + b.y, a.z + b.z);
+}
+
+static inline __host__ __device__ void operator+=(float3 &a, float3 b) {
+    a.x += b.x; a.y += b.y; a.z += b.z;
+}
+
+static inline __host__ __device__ float3 operator-(float3 a, float3 b) {
+    return make_float3(a.x - b.x, a.y - b.y, a.z - b.z);
+}
+
+static inline __host__ __device__ void operator-=(float3 &a, float3 b) {
+    a.x -= b.x; a.y -= b.y; a.z -= b.z;
+}
+
+static inline __host__ __device__ float3 operator*(float3 a, float b) {
+    return make_float3(a.x * b, a.y * b, a.z * b);
+}
+
+static inline __host__ __device__ float3 operator*(float b, float3 a) {
+    return make_float3(b * a.x, b * a.y, b * a.z);
+}
+
+static inline __host__ __device__ void operator*=(float3 &a, float b) {
+    a.x *= b; a.y *= b; a.z *= b;
+}
+
+static inline __host__ __device__ float3 operator/(float3 a, const float b) {
+    float inv = 1.0f / b;
+    return make_float3(a.x * inv, a.y * inv, a.z * inv);
+}
+
+static inline __host__ __device__ void operator/=(float3 &a, float b) {
+    float inv = 1.0f / b;
+    a.x *= inv; a.y *= inv; a.z *= inv;
+}
+
+namespace maths
+{
+    static inline __host__ __device__ float dot(float3 a, float3 b) {
+        return a.x * b.x + a.y * b.y + a.z * b.z;
+    }
+
+    static inline __host__ __device__ float dot2(float3 a) {
+        return dot(a, a);
+    }
+
+    static inline __host__ __device__ float norm(float3 a) {
+        return sqrtf(dot2(a));
+    }
+
+    static inline __host__ __device__ float3 cross(float3 a, float3 b) {
+        return make_float3(
+            a.y * b.z - a.z * b.y,
+            a.z * b.x - a.x * b.z,
+            a.x * b.y - a.y * b.x
+        );
+    }
+
+    static inline __host__ __device__ float3 normalize(float3 v) {
+        float invLen = rsqrtf(dot2(v));
+        return v * invLen;
+    }
+
+    static inline __host__ __device__ bool equals(float3 a, float3 b) {
+        return a.x == b.x && a.y == b.y && a.z == b.z;
+    }
+}
+
+#endif // F3x1_H

conquer3d-0.2.1/conquer3d/csrc/maths/f3x3.h

@@ -0,0 +1,118 @@
+#ifndef F3X3_H
+#define F3X3_H
+
+#include "f2x2.h"
+#include "ops.h"
+
+#include <stdint.h>
+#include <cmath>
+#include <vector_types.h>
+#include <vector_functions.h>
+#include <math_constants.h>
+
+typedef struct
+{
+    float m[3][3];
+} float3x3;
+
+static __inline__ __host__ __device__ float3x3 make_float3x3(
+    float a00, float a01, float a02,
+    float a10, float a11, float a12,
+    float a20, float a21, float a22) {
+    float3x3 a;
+    a.m[0][0] = a00; a.m[0][1] = a01; a.m[0][2] = a02;
+    a.m[1][0] = a10; a.m[1][1] = a11; a.m[1][2] = a12;
+    a.m[2][0] = a20; a.m[2][1] = a21; a.m[2][2] = a22;
+    return a;
+}
+
+// [3, 3] x [3, 3] = [3, 3]
+static __inline__ __host__ __device__ float3x3 operator* (const float3x3& a, const float3x3& b)
+{
+    float3x3 c;
+
+    c.m[0][0] = a.m[0][0] * b.m[0][0] + a.m[0][1] * b.m[1][0] + a.m[0][2] * b.m[2][0];
+    c.m[0][1] = a.m[0][0] * b.m[0][1] + a.m[0][1] * b.m[1][1] + a.m[0][2] * b.m[2][1];
+    c.m[0][2] = a.m[0][0] * b.m[0][2] + a.m[0][1] * b.m[1][2] + a.m[0][2] * b.m[2][2];
+
+    c.m[1][0] = a.m[1][0] * b.m[0][0] + a.m[1][1] * b.m[1][0] + a.m[1][2] * b.m[2][0];
+    c.m[1][1] = a.m[1][0] * b.m[0][1] + a.m[1][1] * b.m[1][1] + a.m[1][2] * b.m[2][1];
+    c.m[1][2] = a.m[1][0] * b.m[0][2] + a.m[1][1] * b.m[1][2] + a.m[1][2] * b.m[2][2];
+
+    c.m[2][0] = a.m[2][0] * b.m[0][0] + a.m[2][1] * b.m[1][0] + a.m[2][2] * b.m[2][0];
+    c.m[2][1] = a.m[2][0] * b.m[0][1] + a.m[2][1] * b.m[1][1] + a.m[2][2] * b.m[2][1];
+    c.m[2][2] = a.m[2][0] * b.m[0][2] + a.m[2][1] * b.m[1][2] + a.m[2][2] * b.m[2][2];
+
+    return c;
+}
+
+// [3, 1]^T x [3, 3] = [3, 1]^T
+static __inline__ __host__ __device__ float3 operator*(const float3& a, const float3x3& m) {
+    return make_float3(
+        a.x * m.m[0][0] + a.y * m.m[1][0] + a.z * m.m[2][0],
+        a.x * m.m[0][1] + a.y * m.m[1][1] + a.z * m.m[2][1],
+        a.x * m.m[0][2] + a.y * m.m[1][2] + a.z * m.m[2][2]
+    );
+}
+
+// [3, 3] x [3, 1] = [3, 1]
+static __inline__ __host__ __device__ float3 operator*(const float3x3& m, const float3& a) {
+    return make_float3(
+        m.m[0][0] * a.x + m.m[0][1] * a.y + m.m[0][2] * a.z,
+        m.m[1][0] * a.x + m.m[1][1] * a.y + m.m[1][2] * a.z,
+        m.m[2][0] * a.x + m.m[2][1] * a.y + m.m[2][2] * a.z
+    );
+}
+
+namespace maths
+{
+    static __inline__ __host__ __device__ float3x3 transpose(const float3x3& a) {
+        float3x3 b;
+        b.m[0][0] = a.m[0][0]; b.m[0][1] = a.m[1][0]; b.m[0][2] = a.m[2][0];
+        b.m[1][0] = a.m[0][1]; b.m[1][1] = a.m[1][1]; b.m[1][2] = a.m[2][1];
+        b.m[2][0] = a.m[0][2]; b.m[2][1] = a.m[1][2]; b.m[2][2] = a.m[2][2];
+        return b;
+    }
+
+    static __inline__ __host__ __device__ float det(const float3x3& a) {
+        return a.m[0][0] * (a.m[1][1] * a.m[2][2] - a.m[1][2] * a.m[2][1])
+            - a.m[0][1] * (a.m[1][0] * a.m[2][2] - a.m[1][2] * a.m[2][0])
+            + a.m[0][2] * (a.m[1][0] * a.m[2][1] - a.m[1][1] * a.m[2][0]);
+    }
+
+    static inline __host__ __device__ void copy(float3x3 &a, float3x3 b) {
+        a.m[0][0] = b.m[0][0]; a.m[0][1] = b.m[0][1]; a.m[0][2] = b.m[0][2];
+        a.m[1][0] = b.m[1][0]; a.m[1][1] = b.m[1][1]; a.m[1][2] = b.m[1][2];
+        a.m[2][0] = b.m[2][0]; a.m[2][1] = b.m[2][1]; a.m[2][2] = b.m[2][2];
+    }
+
+    static __host__ __device__ __forceinline__ bool invert(const float3x3& m, float3x3& out_inv) 
+    {
+        float a = m.m[0][0], b = m.m[0][1], c = m.m[0][2];
+        float d = m.m[1][0], e = m.m[1][1], f = m.m[1][2];
+        float g = m.m[2][0], h = m.m[2][1], i = m.m[2][2];
+
+        float A = e * i - f * h;
+        float B = f * g - d * i;
+        float C = d * h - e * g;
+
+        float det_val = a * A + b * B + c * C;
+
+        if (fabsf(det_val) < 1e-8f) return false; 
+
+        float inv_det = 1.0f / det_val;
+
+        out_inv.m[0][0] = A * inv_det;
+        out_inv.m[0][1] = (c * h - b * i) * inv_det;
+        out_inv.m[0][2] = (b * f - c * e) * inv_det;
+        out_inv.m[1][0] = B * inv_det;
+        out_inv.m[1][1] = (a * i - c * g) * inv_det;
+        out_inv.m[1][2] = (c * d - a * f) * inv_det;
+        out_inv.m[2][0] = C * inv_det;
+        out_inv.m[2][1] = (b * g - a * h) * inv_det;
+        out_inv.m[2][2] = (a * e - b * d) * inv_det;
+
+        return true;
+    }
+}
+#endif // F3X3_H