warp-lang 1.2.2__py3-none-manylinux2014_aarch64.whl → 1.3.0__py3-none-manylinux2014_aarch64.whl

warp/native/vec.h

@@ -648,6 +648,30 @@ inline CUDA_CALLABLE unsigned argmax(vec_t<Length,Type> v)
     return ret;
 }
 
+template<unsigned Length, typename Type>
+inline CUDA_CALLABLE vec_t<Length,Type> abs(vec_t<Length,Type> v)
+{
+    vec_t<Length,Type> ret;
+    for (unsigned i=0; i < Length; ++i)
+    {
+        ret[i] = abs(v[i]);
+    }
+
+    return ret;
+}
+
+template<unsigned Length, typename Type>
+inline CUDA_CALLABLE vec_t<Length,Type> sign(vec_t<Length,Type> v)
+{
+    vec_t<Length,Type> ret;
+    for (unsigned i=0; i < Length; ++i)
+    {
+        ret[i] = v[i] < Type(0) ? Type(-1) : Type(1);
+    }
+
+    return ret;
+}
+
 template<unsigned Length, typename Type>
 inline CUDA_CALLABLE void expect_near(const vec_t<Length, Type>& actual, const vec_t<Length, Type>& expected, const Type& tolerance)
 {
@@ -1046,6 +1070,46 @@ inline CUDA_CALLABLE void adj_max(const vec_t<Length,Type> &v, vec_t<Length,Type
     adj_v[i] += adj_ret;
 }
 
+template<unsigned Length, typename Type>
+inline CUDA_CALLABLE void adj_abs(
+    const vec_t<Length,Type>& v,
+    vec_t<Length,Type>& adj_v,
+    const vec_t<Length,Type>& adj_ret
+)
+{
+    for (unsigned i=0; i < Length; ++i)
+    {
+        if (v[i] < Type(0))
+        {
+            adj_v[i] -= adj_ret[i];
+        }
+        else
+        {
+            adj_v[i] += adj_ret[i];
+        }
+    }
+}
+
+template<unsigned Length, typename Type>
+inline CUDA_CALLABLE void adj_sign(
+    const vec_t<Length,Type>& v,
+    vec_t<Length,Type>& adj_v,
+    const vec_t<Length,Type>& adj_ret
+)
+{
+    for (unsigned i=0; i < Length; ++i)
+    {
+        if (v[i] < Type(0))
+        {
+            adj_v[i] -= adj_ret[i];
+        }
+        else
+        {
+            adj_v[i] += adj_ret[i];
+        }
+    }
+}
+
 // Do I need to specialize these for different lengths?
 template<unsigned Length, typename Type>
 inline CUDA_CALLABLE vec_t<Length, Type> atomic_add(vec_t<Length, Type> * addr, vec_t<Length, Type> value)

warp/native/volume.cpp

@@ -34,10 +34,7 @@ struct VolumeDesc
     // CUDA context for this volume (NULL if CPU)
     void *context;
 
-    pnanovdb_buf_t as_pnano() const
-    {
-        return pnanovdb_make_buf(static_cast<uint32_t *>(buffer), size_in_bytes);
-    }
+    pnanovdb_buf_t as_pnano() const { return pnanovdb_make_buf(static_cast<uint32_t *>(buffer), size_in_bytes); }
 };
 
 // Host-side volume descriptors. Maps each CPU/GPU volume buffer address (id) to a CPU desc
@@ -62,14 +59,18 @@ bool volume_exists(const void *id)
     return volume_get_descriptor((uint64_t)id, volume);
 }
 
-void volume_add_descriptor(uint64_t id, VolumeDesc &&volumeDesc)
-{
-    g_volume_descriptors[id] = std::move(volumeDesc);
-}
+void volume_add_descriptor(uint64_t id, VolumeDesc &&volumeDesc) { g_volume_descriptors[id] = std::move(volumeDesc); }
 
-void volume_rem_descriptor(uint64_t id)
+void volume_rem_descriptor(uint64_t id) { g_volume_descriptors.erase(id); }
+
+void volume_set_map(nanovdb::Map &map, const float transform[9], const float translation[3])
 {
-    g_volume_descriptors.erase(id);
+    // Need to transpose as Map::set is transposing again
+    const mat_t<3, 3, double> transpose(transform[0], transform[3], transform[6], transform[1], transform[4], transform[7],
+                                  transform[2], transform[5], transform[8]);
+    const mat_t<3, 3, double> inv = inverse(transpose);
+
+    map.set(transpose.data, inv.data, translation);
 }
 
 } // anonymous namespace
@@ -380,74 +381,69 @@ void volume_destroy_device(uint64_t id)
 }
 
 #if WP_ENABLE_CUDA
-uint64_t volume_f_from_tiles_device(void *context, void *points, int num_points, float voxel_size, float bg_value,
-                                    float tx, float ty, float tz, bool points_in_world_space)
+
+uint64_t volume_f_from_tiles_device(void *context, void *points, int num_points, float transform[9],
+                                    float translation[3], bool points_in_world_space, float bg_value)
 {
     nanovdb::FloatGrid *grid;
     size_t gridSize;
     BuildGridParams<float> params;
-    params.voxel_size = voxel_size;
     params.background_value = bg_value;
-    params.translation = nanovdb::Vec3f{tx, ty, tz};
+    volume_set_map(params.map, transform, translation);
 
     build_grid_from_points(grid, gridSize, points, num_points, points_in_world_space, params);
 
     return volume_create_device(context, grid, gridSize, false, true);
 }
 
-uint64_t volume_v_from_tiles_device(void *context, void *points, int num_points, float voxel_size, float bg_value_x,
-                                    float bg_value_y, float bg_value_z, float tx, float ty, float tz,
-                                    bool points_in_world_space)
+uint64_t volume_v_from_tiles_device(void *context, void *points, int num_points, float transform[9],
+                                    float translation[3], bool points_in_world_space, float bg_value[3])
 {
     nanovdb::Vec3fGrid *grid;
     size_t gridSize;
     BuildGridParams<nanovdb::Vec3f> params;
-    params.voxel_size = voxel_size;
-    params.background_value = nanovdb::Vec3f{bg_value_x, bg_value_y, bg_value_z};
-    params.translation = nanovdb::Vec3f{tx, ty, tz};
+    params.background_value = nanovdb::Vec3f{bg_value[0], bg_value[1], bg_value[2]};
+    volume_set_map(params.map, transform, translation);
 
     build_grid_from_points(grid, gridSize, points, num_points, points_in_world_space, params);
 
     return volume_create_device(context, grid, gridSize, false, true);
 }
 
-uint64_t volume_i_from_tiles_device(void *context, void *points, int num_points, float voxel_size, int bg_value,
-                                    float tx, float ty, float tz, bool points_in_world_space)
+uint64_t volume_i_from_tiles_device(void *context, void *points, int num_points, float transform[9],
+                                    float translation[3], bool points_in_world_space, int bg_value)
 {
     nanovdb::Int32Grid *grid;
     size_t gridSize;
     BuildGridParams<int32_t> params;
-    params.voxel_size = voxel_size;
     params.background_value = (int32_t)(bg_value);
-    params.translation = nanovdb::Vec3f{tx, ty, tz};
+    volume_set_map(params.map, transform, translation);
 
     build_grid_from_points(grid, gridSize, points, num_points, points_in_world_space, params);
 
     return volume_create_device(context, grid, gridSize, false, true);
 }
 
-uint64_t volume_index_from_tiles_device(void *context, void *points, int num_points, float voxel_size, float tx,
-                                        float ty, float tz, bool points_in_world_space)
+uint64_t volume_index_from_tiles_device(void *context, void *points, int num_points, float transform[9],
+                                        float translation[3], bool points_in_world_space)
 {
     nanovdb::IndexGrid *grid;
     size_t gridSize;
     BuildGridParams<nanovdb::ValueIndex> params;
-    params.voxel_size = voxel_size;
-    params.translation = nanovdb::Vec3f{tx, ty, tz};
+    volume_set_map(params.map, transform, translation);
 
     build_grid_from_points(grid, gridSize, points, num_points, points_in_world_space, params);
 
     return volume_create_device(context, grid, gridSize, false, true);
 }
 
-uint64_t volume_from_active_voxels_device(void *context, void *points, int num_points, float voxel_size, float tx,
-                                          float ty, float tz, bool points_in_world_space)
+uint64_t volume_from_active_voxels_device(void *context, void *points, int num_points, float transform[9],
+                                          float translation[3], bool points_in_world_space)
 {
     nanovdb::OnIndexGrid *grid;
     size_t gridSize;
     BuildGridParams<nanovdb::ValueOnIndex> params;
-    params.voxel_size = voxel_size;
-    params.translation = nanovdb::Vec3f{tx, ty, tz};
+    volume_set_map(params.map, transform, translation);
 
     build_grid_from_points(grid, gridSize, points, num_points, points_in_world_space, params);
 
@@ -487,43 +483,38 @@ void volume_get_voxels_device(uint64_t id, void *buf)
 
 #else
 // stubs for non-CUDA platforms
-uint64_t volume_f_from_tiles_device(void *context, void *points, int num_points, float voxel_size, float bg_value,
-                                    float tx, float ty, float tz, bool points_in_world_space)
+uint64_t volume_f_from_tiles_device(void *context, void *points, int num_points, float transform[9],
+                                    float translation[3], bool points_in_world_space, float bg_value)
 {
     return 0;
 }
 
-uint64_t volume_v_from_tiles_device(void *context, void *points, int num_points, float voxel_size, float bg_value_x,
-                                    float bg_value_y, float bg_value_z, float tx, float ty, float tz,
-                                    bool points_in_world_space)
+uint64_t volume_v_from_tiles_device(void *context, void *points, int num_points, float transform[9],
+                                    float translation[3], bool points_in_world_space, float bg_value[3])
 {
     return 0;
 }
 
-uint64_t volume_i_from_tiles_device(void *context, void *points, int num_points, float voxel_size, int bg_value,
-                                    float tx, float ty, float tz, bool points_in_world_space)
+uint64_t volume_i_from_tiles_device(void *context, void *points, int num_points, float transform[9],
+                                    float translation[3], bool points_in_world_space, int bg_value)
 {
     return 0;
 }
 
-uint64_t volume_index_from_tiles_device(void *context, void *points, int num_points, float voxel_size,
-                                        float tx, float ty, float tz, bool points_in_world_space)
+uint64_t volume_index_from_tiles_device(void *context, void *points, int num_points, float transform[9],
+                                        float translation[3], bool points_in_world_space)
 {
     return 0;
 }
 
-uint64_t volume_from_active_voxels_device(void *context, void *points, int num_points, float voxel_size, float tx,
-                                          float ty, float tz, bool points_in_world_space)
+uint64_t volume_from_active_voxels_device(void *context, void *points, int num_points, float transform[9],
+                                          float translation[3], bool points_in_world_space)
 {
     return 0;
 }
 
-void volume_get_tiles_device(uint64_t id, void *buf)
-{
-}
+void volume_get_tiles_device(uint64_t id, void *buf) {}
 
-void volume_get_voxels_device(uint64_t id, void *buf)
-{
-}
+void volume_get_voxels_device(uint64_t id, void *buf) {}
 
 #endif

warp/native/volume_builder.cu

@@ -403,8 +403,7 @@ void build_grid_from_points(nanovdb::Grid<nanovdb::NanoTree<BuildT>> *&out_grid,
     out_grid_size = 0;
 
     cudaStream_t stream = static_cast<cudaStream_t>(cuda_stream_get_current());
-    nanovdb::Map map(params.voxel_size, params.translation);
-    nanovdb::tools::cuda::PointsToGrid<BuildT, Allocator> p2g(map, stream);
+    nanovdb::tools::cuda::PointsToGrid<BuildT, Allocator> p2g(params.map, stream);
 
     // p2g.setVerbose(2);
     p2g.setGridName(params.name);
@@ -417,7 +416,7 @@ void build_grid_from_points(nanovdb::Grid<nanovdb::NanoTree<BuildT>> *&out_grid,
 
     if (points_in_world_space)
     {
-        grid_handle = p2g.getHandle(WorldSpacePointsPtr{static_cast<const nanovdb::Vec3f *>(points), map}, num_points,
+        grid_handle = p2g.getHandle(WorldSpacePointsPtr{static_cast<const nanovdb::Vec3f *>(points), params.map}, num_points,
                                     DeviceBuffer());
     }
     else

warp/native/volume_builder.h

@@ -2,33 +2,28 @@
 
 #include <nanovdb/NanoVDB.h>
 
-template<typename BuildT>
-struct BuildGridParams {
-    double voxel_size = 1.0;
+template <typename BuildT> struct BuildGridParams
+{
+    nanovdb::Map map;
     BuildT background_value{0};
-    nanovdb::Vec3d translation{0.0, 0.0, 0.0};
     char name[256] = "";
 };
 
-template<>
-struct BuildGridParams<nanovdb::ValueIndex> {
-    double voxel_size = 1.0;
+template <> struct BuildGridParams<nanovdb::ValueIndex>
+{
+    nanovdb::Map map;
     nanovdb::ValueIndex background_value;
-    nanovdb::Vec3d translation{0.0, 0.0, 0.0};
     char name[256] = "";
 };
 
-template<>
-struct BuildGridParams<nanovdb::ValueOnIndex> {
+template <> struct BuildGridParams<nanovdb::ValueOnIndex>
+{
+    nanovdb::Map map;
     double voxel_size = 1.0;
-    nanovdb::Vec3d translation{0.0, 0.0, 0.0};
     char name[256] = "";
 };
 
 template <typename BuildT>
-void build_grid_from_points(nanovdb::Grid<nanovdb::NanoTree<BuildT>> *&out_grid,
-                           size_t &out_grid_size,
-                           const void *points,
-                           size_t num_points,
-                           bool points_in_world_space,
-                           const BuildGridParams<BuildT> &params);
+void build_grid_from_points(nanovdb::Grid<nanovdb::NanoTree<BuildT>>*& out_grid, size_t& out_grid_size,
+                            const void* points, size_t num_points, bool points_in_world_space,
+                            const BuildGridParams<BuildT>& params);

warp/native/warp.cu

@@ -755,7 +755,7 @@ bool memcpy_p2p(void* dst_context, void* dst, void* src_context, void* src, size
 
 __global__ void memset_kernel(int* dest, int value, size_t n)
 {
-    const size_t tid = wp::grid_index();
+    const size_t tid = static_cast<size_t>(blockDim.x) * static_cast<size_t>(blockIdx.x) + static_cast<size_t>(threadIdx.x);
     
     if (tid < n)
     {
@@ -789,7 +789,7 @@ void memset_device(void* context, void* dest, int value, size_t n)
 // fill memory buffer with a value: generic memtile kernel using memcpy for each element
 __global__ void memtile_kernel(void* dst, const void* src, size_t srcsize, size_t n)
 {
-    size_t tid = wp::grid_index();
+    size_t tid = static_cast<size_t>(blockDim.x) * static_cast<size_t>(blockIdx.x) + static_cast<size_t>(threadIdx.x);
     if (tid < n)
     {
         memcpy((int8_t*)dst + srcsize * tid, src, srcsize);
@@ -800,7 +800,7 @@ __global__ void memtile_kernel(void* dst, const void* src, size_t srcsize, size_
 template <typename T>
 __global__ void memtile_value_kernel(T* dst, T value, size_t n)
 {
-    size_t tid = wp::grid_index();
+    size_t tid = static_cast<size_t>(blockDim.x) * static_cast<size_t>(blockIdx.x) + static_cast<size_t>(threadIdx.x);
     if (tid < n)
     {
         dst[tid] = value;

warp/native/warp.h

@@ -107,11 +107,11 @@ extern "C"
     WP_API void volume_get_voxels_device(uint64_t id, void* buf);
     WP_API void volume_destroy_device(uint64_t id);
     
-    WP_API uint64_t volume_f_from_tiles_device(void* context, void* points, int num_points, float voxel_size, float bg_value, float tx, float ty, float tz, bool points_in_world_space);
-    WP_API uint64_t volume_v_from_tiles_device(void* context, void* points, int num_points, float voxel_size, float bg_value_x, float bg_value_y, float bg_value_z, float tx, float ty, float tz, bool points_in_world_space);
-    WP_API uint64_t volume_i_from_tiles_device(void* context, void* points, int num_points, float voxel_size, int bg_value, float tx, float ty, float tz, bool points_in_world_space);
-    WP_API uint64_t volume_index_from_tiles_device(void* context, void* points, int num_points, float voxel_size, float tx, float ty, float tz, bool points_in_world_space);
-    WP_API uint64_t volume_from_active_voxels_device(void* context, void* points, int num_points, float voxel_size, float tx, float ty, float tz, bool points_in_world_space);
+    WP_API uint64_t volume_f_from_tiles_device(void* context, void* points, int num_points, float transform[9], float translation[3], bool points_in_world_space, float bg_value);
+    WP_API uint64_t volume_v_from_tiles_device(void* context, void* points, int num_points, float transform[9], float translation[3], bool points_in_world_space, float bg_value[3]);
+    WP_API uint64_t volume_i_from_tiles_device(void* context, void* points, int num_points, float transform[9], float translation[3], bool points_in_world_space, int bg_value);
+    WP_API uint64_t volume_index_from_tiles_device(void* context, void* points, int num_points, float transform[9], float translation[3], bool points_in_world_space);
+    WP_API uint64_t volume_from_active_voxels_device(void* context, void* points, int num_points, float transform[9], float translation[3], bool points_in_world_space);
 
     WP_API void volume_get_buffer_info(uint64_t id, void** buf, uint64_t* size);
     WP_API void volume_get_voxel_size(uint64_t id, float* dx, float* dy, float* dz);
@@ -154,81 +154,91 @@ extern "C"
     WP_API void runlength_encode_int_host(uint64_t values, uint64_t run_values, uint64_t run_lengths, uint64_t run_count, int n);
     WP_API void runlength_encode_int_device(uint64_t values, uint64_t run_values, uint64_t run_lengths, uint64_t run_count, int n);
 
-    WP_API int bsr_matrix_from_triplets_float_host(
+    WP_API void bsr_matrix_from_triplets_float_host(
         int rows_per_block,
         int cols_per_block,
         int row_count,
-        int nnz,
-        uint64_t tpl_rows,
-        uint64_t tpl_columns,
-        uint64_t tpl_values,
-        uint64_t bsr_offsets,
-        uint64_t bsr_columns,
-        uint64_t bsr_values);
-    WP_API int bsr_matrix_from_triplets_double_host(
+        int tpl_nnz,
+        int* tpl_rows,
+        int* tpl_columns,
+        void* tpl_values,
+        bool prune_numerical_zeros,
+        int* bsr_offsets,
+        int* bsr_columns,
+        void* bsr_values,
+        int* bsr_nnz,
+        void* bsr_nnz_event);
+    WP_API void bsr_matrix_from_triplets_double_host(
         int rows_per_block,
         int cols_per_block,
         int row_count,
-        int nnz,
-        uint64_t tpl_rows,
-        uint64_t tpl_columns,
-        uint64_t tpl_values,
-        uint64_t bsr_offsets,
-        uint64_t bsr_columns,
-        uint64_t bsr_values);
-
-    WP_API int bsr_matrix_from_triplets_float_device(
+        int tpl_nnz,
+        int* tpl_rows,
+        int* tpl_columns,
+        void* tpl_values,
+        bool prune_numerical_zeros,
+        int* bsr_offsets,
+        int* bsr_columns,
+        void* bsr_values,
+        int* bsr_nnz,
+        void* bsr_nnz_event);
+    WP_API void bsr_matrix_from_triplets_float_device(
         int rows_per_block,
         int cols_per_block,
         int row_count,
-        int nnz,
-        uint64_t tpl_rows,
-        uint64_t tpl_columns,
-        uint64_t tpl_values,
-        uint64_t bsr_offsets,
-        uint64_t bsr_columns,
-        uint64_t bsr_values);
-    WP_API int bsr_matrix_from_triplets_double_device(
+        int tpl_nnz,
+        int* tpl_rows,
+        int* tpl_columns,
+        void* tpl_values,
+        bool prune_numerical_zeros,
+        int* bsr_offsets,
+        int* bsr_columns,
+        void* bsr_values,
+        int* bsr_nnz,
+        void* bsr_nnz_event);
+    WP_API void bsr_matrix_from_triplets_double_device(
         int rows_per_block,
         int cols_per_block,
         int row_count,
-        int nnz,
-        uint64_t tpl_rows,
-        uint64_t tpl_columns,
-        uint64_t tpl_values,
-        uint64_t bsr_offsets,
-        uint64_t bsr_columns,
-        uint64_t bsr_values);
+        int tpl_nnz,
+        int* tpl_rows,
+        int* tpl_columns,
+        void* tpl_values,
+        bool prune_numerical_zeros,
+        int* bsr_offsets,
+        int* bsr_columns,
+        void* bsr_values,
+        int* bsr_nnz,
+        void* bsr_nnz_event);
 
     WP_API void bsr_transpose_float_host(int rows_per_block, int cols_per_block,
         int row_count, int col_count, int nnz,
-        uint64_t bsr_offsets, uint64_t bsr_columns,
-        uint64_t bsr_values,
-        uint64_t transposed_bsr_offsets,
-        uint64_t transposed_bsr_columns,
-        uint64_t transposed_bsr_values);
+        int* bsr_offsets, int* bsr_columns,
+        void* bsr_values,
+        int* transposed_bsr_offsets,
+        int* transposed_bsr_columns,
+        void* transposed_bsr_values);
     WP_API void bsr_transpose_double_host(int rows_per_block, int cols_per_block,
         int row_count, int col_count, int nnz,
-        uint64_t bsr_offsets, uint64_t bsr_columns,
-        uint64_t bsr_values,
-        uint64_t transposed_bsr_offsets,
-        uint64_t transposed_bsr_columns,
-        uint64_t transposed_bsr_values);
-
+        int* bsr_offsets, int* bsr_columns,
+        void* bsr_values,
+        int* transposed_bsr_offsets,
+        int* transposed_bsr_columns,
+        void* transposed_bsr_values);
     WP_API void bsr_transpose_float_device(int rows_per_block, int cols_per_block,
         int row_count, int col_count, int nnz,
-        uint64_t bsr_offsets, uint64_t bsr_columns,
-        uint64_t bsr_values,
-        uint64_t transposed_bsr_offsets,
-        uint64_t transposed_bsr_columns,
-        uint64_t transposed_bsr_values);
+        int* bsr_offsets, int* bsr_columns,
+        void* bsr_values,
+        int* transposed_bsr_offsets,
+        int* transposed_bsr_columns,
+        void* transposed_bsr_values);
     WP_API void bsr_transpose_double_device(int rows_per_block, int cols_per_block,
         int row_count, int col_count, int nnz,
-        uint64_t bsr_offsets, uint64_t bsr_columns,
-        uint64_t bsr_values,
-        uint64_t transposed_bsr_offsets,
-        uint64_t transposed_bsr_columns,
-        uint64_t transposed_bsr_values);
+        int* bsr_offsets, int* bsr_columns,
+        void* bsr_values,
+        int* transposed_bsr_offsets,
+        int* transposed_bsr_columns,
+        void* transposed_bsr_values);
 
 
     WP_API int cuda_driver_version();   // CUDA driver version

warp/render/render_opengl.py

@@ -150,7 +150,7 @@ layout (location = 1) in vec3 aNormal;
 layout (location = 2) in vec2 aTexCoord;
 
 uniform mat4 view;
-uniform mat4 model;
+uniform mat4 inv_model;
 uniform mat4 projection;
 uniform vec3 viewPos;
 
@@ -160,7 +160,8 @@ out vec2 TexCoord;
 void main()
 {
     vec4 worldPos = vec4(aPos + viewPos, 1.0);
-    gl_Position = projection * view * worldPos;
+    gl_Position = projection * view * inv_model * worldPos;
+
     FragPos = vec3(worldPos);
     TexCoord = aTexCoord;
 }
@@ -666,12 +667,16 @@ class ShapeInstancer:
         [3D point, 3D normal, UV texture coordinates]
     """
 
+    def __new__(cls, *args, **kwargs):
+        instance = super(ShapeInstancer, cls).__new__(cls)
+        instance.instance_transform_gl_buffer = None
+        instance.vao = None
+        return instance
+
     def __init__(self, shape_shader, device):
         self.shape_shader = shape_shader
         self.device = device
         self.face_count = 0
-        self.vao = None
-        self.instance_transform_gl_buffer = None
         self.instance_color1_buffer = None
         self.instance_color2_buffer = None
         self.color1 = (1.0, 1.0, 1.0)
@@ -1074,6 +1079,7 @@ class OpenGLRenderer:
         self._scaling = scaling
 
         self._model_matrix = self.compute_model_matrix(self._camera_axis, scaling)
+        self._inv_model_matrix = np.linalg.inv(self._model_matrix.reshape(4, 4)).flatten()
         self.update_view_matrix(cam_pos=camera_pos, cam_front=camera_front, cam_up=camera_up)
         self.update_projection_matrix()
 
@@ -1212,7 +1218,7 @@ class OpenGLRenderer:
 
         with self._sky_shader:
             self._loc_sky_view = gl.glGetUniformLocation(self._sky_shader.id, str_buffer("view"))
-            self._loc_sky_model = gl.glGetUniformLocation(self._sky_shader.id, str_buffer("model"))
+            self._loc_sky_inv_model = gl.glGetUniformLocation(self._sky_shader.id, str_buffer("inv_model"))
             self._loc_sky_projection = gl.glGetUniformLocation(self._sky_shader.id, str_buffer("projection"))
 
             self._loc_sky_color1 = gl.glGetUniformLocation(self._sky_shader.id, str_buffer("color1"))
@@ -1748,26 +1754,28 @@ class OpenGLRenderer:
         if camera_axis == 0:
             return np.array((0, 0, scaling, 0, scaling, 0, 0, 0, 0, scaling, 0, 0, 0, 0, 0, 1), dtype=np.float32)
         elif camera_axis == 2:
-            return np.array((-scaling, 0, 0, 0, 0, 0, scaling, 0, 0, scaling, 0, 0, 0, 0, 0, 1), dtype=np.float32)
+            return np.array((0, scaling, 0, 0, 0, 0, scaling, 0, scaling, 0, 0, 0, 0, 0, 0, 1), dtype=np.float32)
 
         return np.array((scaling, 0, 0, 0, 0, scaling, 0, 0, 0, 0, scaling, 0, 0, 0, 0, 1), dtype=np.float32)
 
     def update_model_matrix(self, model_matrix: Optional[Mat44] = None):
         from pyglet import gl
 
-        # fmt: off
         if model_matrix is None:
             self._model_matrix = self.compute_model_matrix(self._camera_axis, self._scaling)
         else:
             self._model_matrix = np.array(model_matrix).flatten()
-        # fmt: on
+        self._inv_model_matrix = np.linalg.inv(self._model_matrix.reshape((4, 4))).flatten()
+        # update model view matrix in shaders
         ptr = arr_pointer(self._model_matrix)
         gl.glUseProgram(self._shape_shader.id)
         gl.glUniformMatrix4fv(self._loc_shape_model, 1, gl.GL_FALSE, ptr)
         gl.glUseProgram(self._grid_shader.id)
         gl.glUniformMatrix4fv(self._loc_grid_model, 1, gl.GL_FALSE, ptr)
+        # sky shader needs inverted model view matrix
         gl.glUseProgram(self._sky_shader.id)
-        gl.glUniformMatrix4fv(self._loc_sky_model, 1, gl.GL_FALSE, ptr)
+        inv_ptr = arr_pointer(self._inv_model_matrix)
+        gl.glUniformMatrix4fv(self._loc_sky_inv_model, 1, gl.GL_FALSE, inv_ptr)
 
     @property
     def num_tiles(self):