RC0: Embree 4 Support

.github/workflows/wheels.yml

@@ -8,16 +8,16 @@ jobs:
     runs-on: ${{ matrix.os }}
     strategy:
       matrix:
-        os: [ubuntu-latest, windows-latest, macos-15-intel]
+        os: [ubuntu-latest, windows-latest, macos-15-intel, macos-latest]
     steps:
     - uses: actions/checkout@v3
     - uses: actions/setup-python@v4
       name: Install Python
       with:
-        python-version: '3.13'
+        python-version: '3.14'
     - name: Install cibuildwheel
       run: |
-        python -m pip install cibuildwheel==3.2.1
+        python -m pip install cibuildwheel==3.4.0
     - name: Build wheel
       run: |
         python -m cibuildwheel --output-dir dist

embreex/mesh_construction.pyx

@@ -1,11 +1,11 @@
+# cython: embedsignature=True
 # distutils: language=c++
 
 cimport numpy as np
 cimport rtcore as rtc
 cimport rtcore_ray as rtcr
 cimport rtcore_scene as rtcs
 cimport rtcore_geometry as rtcg
-cimport rtcore_geometry_user as rtcgu
 from rtcore cimport Vertex, Triangle
 
 
@@ -69,27 +69,31 @@ cdef class TriangleMesh:
         # In this scheme, we don't share any vertices.  This leads to cracks,
         # but also means we have exactly three times as many vertices as
         # triangles.
-        cdef unsigned int mesh = rtcg.rtcNewTriangleMesh(scene.scene_i,
-                    rtcg.RTC_GEOMETRY_STATIC, nt, nt*3, 1)
+        cdef rtcg.RTCGeometry geom = rtcg.rtcNewGeometry(scene.device.device,
+                    rtcg.RTC_GEOMETRY_TYPE_TRIANGLE)
 
-        cdef Vertex* vertices = <Vertex*> rtcg.rtcMapBuffer(scene.scene_i, mesh,
-                        rtcg.RTC_VERTEX_BUFFER)
+        cdef Vertex* vertices = <Vertex*> rtcg.rtcSetNewGeometryBuffer(geom,
+                        rtcg.RTC_BUFFER_TYPE_VERTEX, 0, rtcg.RTC_FORMAT_FLOAT3,
+                        4 * sizeof(float), nt * 3)
 
         for i in range(nt):
             for j in range(3):
                 vertices[i*3 + j].x = tri_vertices[i,j,0]
                 vertices[i*3 + j].y = tri_vertices[i,j,1]
                 vertices[i*3 + j].z = tri_vertices[i,j,2]
-        rtcg.rtcUnmapBuffer(scene.scene_i, mesh, rtcg.RTC_VERTEX_BUFFER)
 
-        cdef Triangle* triangles = <Triangle*> rtcg.rtcMapBuffer(scene.scene_i,
-                        mesh, rtcg.RTC_INDEX_BUFFER)
+        cdef Triangle* triangles = <Triangle*> rtcg.rtcSetNewGeometryBuffer(geom,
+                        rtcg.RTC_BUFFER_TYPE_INDEX, 0, rtcg.RTC_FORMAT_UINT3,
+                        3 * sizeof(unsigned int), nt)
         for i in range(nt):
             triangles[i].v0 = i*3 + 0
             triangles[i].v1 = i*3 + 1
             triangles[i].v2 = i*3 + 2
 
-        rtcg.rtcUnmapBuffer(scene.scene_i, mesh, rtcg.RTC_INDEX_BUFFER)
+        rtcg.rtcCommitGeometry(geom)
+        cdef unsigned int mesh = rtcg.rtcAttachGeometry(scene.scene_i, geom)
+        rtcg.rtcReleaseGeometry(geom)
+
         self.vertices = vertices
         self.indices = triangles
         self.mesh = mesh
@@ -101,30 +105,34 @@ cdef class TriangleMesh:
         cdef int nv = tri_vertices.shape[0]
         cdef int nt = tri_indices.shape[0]
 
-        cdef unsigned int mesh = rtcg.rtcNewTriangleMesh(scene.scene_i,
-                    rtcg.RTC_GEOMETRY_STATIC, nt, nv, 1)
+        cdef rtcg.RTCGeometry geom = rtcg.rtcNewGeometry(scene.device.device,
+                    rtcg.RTC_GEOMETRY_TYPE_TRIANGLE)
 
         # set up vertex and triangle arrays. In this case, we just read
         # them directly from the inputs
-        cdef Vertex* vertices = <Vertex*> rtcg.rtcMapBuffer(scene.scene_i, mesh,
-                                                    rtcg.RTC_VERTEX_BUFFER)
+        cdef Vertex* vertices = <Vertex*> rtcg.rtcSetNewGeometryBuffer(geom,
+                                                    rtcg.RTC_BUFFER_TYPE_VERTEX, 0,
+                                                    rtcg.RTC_FORMAT_FLOAT3,
+                                                    4 * sizeof(float), nv)
 
         for i in range(nv):
             vertices[i].x = tri_vertices[i, 0]
             vertices[i].y = tri_vertices[i, 1]
             vertices[i].z = tri_vertices[i, 2]
 
-        rtcg.rtcUnmapBuffer(scene.scene_i, mesh, rtcg.RTC_VERTEX_BUFFER)
 
-        cdef Triangle* triangles = <Triangle*> rtcg.rtcMapBuffer(scene.scene_i,
-                        mesh, rtcg.RTC_INDEX_BUFFER)
+        cdef Triangle* triangles = <Triangle*> rtcg.rtcSetNewGeometryBuffer(geom,
+                        rtcg.RTC_BUFFER_TYPE_INDEX, 0, rtcg.RTC_FORMAT_UINT3,
+                        3 * sizeof(unsigned int), nt)
 
         for i in range(nt):
             triangles[i].v0 = tri_indices[i][0]
             triangles[i].v1 = tri_indices[i][1]
             triangles[i].v2 = tri_indices[i][2]
 
-        rtcg.rtcUnmapBuffer(scene.scene_i, mesh, rtcg.RTC_INDEX_BUFFER)
+        rtcg.rtcCommitGeometry(geom)
+        cdef unsigned int mesh = rtcg.rtcAttachGeometry(scene.scene_i, geom)
+        rtcg.rtcReleaseGeometry(geom)
 
         self.vertices = vertices
         self.indices = triangles
@@ -187,30 +195,34 @@ cdef class ElementMesh(TriangleMesh):
         # into two triangles.
         cdef int nt = 6*2*ne
 
-        cdef unsigned int mesh = rtcg.rtcNewTriangleMesh(scene.scene_i,
-                    rtcg.RTC_GEOMETRY_STATIC, nt, nv, 1)
+        cdef rtcg.RTCGeometry geom = rtcg.rtcNewGeometry(scene.device.device,
+                    rtcg.RTC_GEOMETRY_TYPE_TRIANGLE)
 
         # first just copy over the vertices
-        cdef Vertex* vertices = <Vertex*> rtcg.rtcMapBuffer(scene.scene_i, mesh,
-                        rtcg.RTC_VERTEX_BUFFER)
+        cdef Vertex* vertices = <Vertex*> rtcg.rtcSetNewGeometryBuffer(geom,
+                        rtcg.RTC_BUFFER_TYPE_VERTEX, 0, rtcg.RTC_FORMAT_FLOAT3,
+                        4 * sizeof(float), nv)
 
         for i in range(nv):
             vertices[i].x = quad_vertices[i, 0]
             vertices[i].y = quad_vertices[i, 1]
             vertices[i].z = quad_vertices[i, 2]
-        rtcg.rtcUnmapBuffer(scene.scene_i, mesh, rtcg.RTC_VERTEX_BUFFER)
 
         # now build up the triangles
-        cdef Triangle* triangles = <Triangle*> rtcg.rtcMapBuffer(scene.scene_i,
-                        mesh, rtcg.RTC_INDEX_BUFFER)
+        cdef Triangle* triangles = <Triangle*> rtcg.rtcSetNewGeometryBuffer(geom,
+                        rtcg.RTC_BUFFER_TYPE_INDEX, 0, rtcg.RTC_FORMAT_UINT3,
+                        3 * sizeof(unsigned int), nt)
 
         for i in range(ne):
             for j in range(12):
                 triangles[12*i+j].v0 = quad_indices[i][triangulate_hex[j][0]]
                 triangles[12*i+j].v1 = quad_indices[i][triangulate_hex[j][1]]
                 triangles[12*i+j].v2 = quad_indices[i][triangulate_hex[j][2]]
 
-        rtcg.rtcUnmapBuffer(scene.scene_i, mesh, rtcg.RTC_INDEX_BUFFER)
+        rtcg.rtcCommitGeometry(geom)
+        cdef unsigned int mesh = rtcg.rtcAttachGeometry(scene.scene_i, geom)
+        rtcg.rtcReleaseGeometry(geom)
+
         self.vertices = vertices
         self.indices = triangles
         self.mesh = mesh
@@ -226,29 +238,33 @@ cdef class ElementMesh(TriangleMesh):
         # There are four triangle faces for each tetrahedron.
         cdef int nt = 4*ne
 
-        cdef unsigned int mesh = rtcg.rtcNewTriangleMesh(scene.scene_i,
-                    rtcg.RTC_GEOMETRY_STATIC, nt, nv, 1)
+        cdef rtcg.RTCGeometry geom = rtcg.rtcNewGeometry(scene.device.device,
+                    rtcg.RTC_GEOMETRY_TYPE_TRIANGLE)
 
         # Just copy over the vertices
-        cdef Vertex* vertices = <Vertex*> rtcg.rtcMapBuffer(scene.scene_i, mesh,
-                        rtcg.RTC_VERTEX_BUFFER)
+        cdef Vertex* vertices = <Vertex*> rtcg.rtcSetNewGeometryBuffer(geom,
+                        rtcg.RTC_BUFFER_TYPE_VERTEX, 0, rtcg.RTC_FORMAT_FLOAT3,
+                        4 * sizeof(float), nv)
 
         for i in range(nv):
             vertices[i].x = tetra_vertices[i, 0]
             vertices[i].y = tetra_vertices[i, 1]
             vertices[i].z = tetra_vertices[i, 2]
-        rtcg.rtcUnmapBuffer(scene.scene_i, mesh, rtcg.RTC_VERTEX_BUFFER)
 
         # Now build up the triangles
-        cdef Triangle* triangles = <Triangle*> rtcg.rtcMapBuffer(scene.scene_i,
-                        mesh, rtcg.RTC_INDEX_BUFFER)
+        cdef Triangle* triangles = <Triangle*> rtcg.rtcSetNewGeometryBuffer(geom,
+                        rtcg.RTC_BUFFER_TYPE_INDEX, 0, rtcg.RTC_FORMAT_UINT3,
+                        3 * sizeof(unsigned int), nt)
         for i in range(ne):
             for j in range(4):
                 triangles[4*i+j].v0 = tetra_indices[i][triangulate_tetra[j][0]]
                 triangles[4*i+j].v1 = tetra_indices[i][triangulate_tetra[j][1]]
                 triangles[4*i+j].v2 = tetra_indices[i][triangulate_tetra[j][2]]
 
-        rtcg.rtcUnmapBuffer(scene.scene_i, mesh, rtcg.RTC_INDEX_BUFFER)
+        rtcg.rtcCommitGeometry(geom)
+        cdef unsigned int mesh = rtcg.rtcAttachGeometry(scene.scene_i, geom)
+        rtcg.rtcReleaseGeometry(geom)
+
         self.vertices = vertices
         self.indices = triangles
         self.mesh = mesh

embreex/rtcore.pxd

@@ -4,44 +4,37 @@ cimport cython
 cimport numpy as np
 
 
-cdef extern from "embree2/rtcore.h":
-    cdef int RTCORE_VERSION_MAJOR
-    cdef int RTCORE_VERSION_MINOR
-    cdef int RTCORE_VERSION_PATCH
+cdef extern from "embree4/rtcore.h":
+    cdef int RTC_VERSION_MAJOR
+    cdef int RTC_VERSION_MINOR
+    cdef int RTC_VERSION_PATCH
 
     void rtcInit(const char* cfg)
     void rtcExit()
 
     cdef enum RTCError:
-        RTC_NO_ERROR
-        RTC_UNKNOWN_ERROR
-        RTC_INVALID_ARGUMENT
-        RTC_INVALID_OPERATION
-        RTC_OUT_OF_MEMORY
-        RTC_UNSUPPORTED_CPU
-        RTC_CANCELLED
+        RTC_ERROR_NONE
+        RTC_ERROR_UNKNOWN
+        RTC_ERROR_INVALID_ARGUMENT
+        RTC_ERROR_INVALID_OPERATION
+        RTC_ERROR_OUT_OF_MEMORY
+        RTC_ERROR_UNSUPPORTED_CPU
+        RTC_ERROR_CANCELLED
 
     # typedef struct __RTCDevice {}* RTCDevice;
     ctypedef void* RTCDevice
 
     RTCDevice rtcNewDevice(const char* cfg)
-    void rtcDeleteDevice(RTCDevice device)
+    void rtcReleaseDevice(RTCDevice device)
 
-    RTCError rtcGetError()
-    ctypedef void (*RTCErrorFunc)(const RTCError code, const char* _str)
-    void rtcSetErrorFunction(RTCErrorFunc func)
-
-    # Embree 2.14.0-0
-    void rtcDeviceSetErrorFunction(RTCDevice device, RTCErrorFunc func)
-
-    # Embree 2.15.1
-    ctypedef void (*RTCErrorFunc2)(void* userPtr, const RTCError code, const char* str)
-    void rtcDeviceSetErrorFunction2(RTCDevice device, RTCErrorFunc2 func, void* userPtr)
+    RTCError rtcGetDeviceError(RTCDevice device)
+    ctypedef void (*RTCErrorFunc)(void* userPtr, RTCError code, const char* str)
+    void rtcSetDeviceErrorFunction(RTCDevice device, RTCErrorFunc func, void* userPtr)
 
     ctypedef bint RTCMemoryMonitorFunc(const ssize_t _bytes, const bint post)
     void rtcSetMemoryMonitorFunction(RTCMemoryMonitorFunc func)
 
-cdef extern from "embree2/rtcore_ray.h":
+cdef extern from "embree4/rtcore_ray.h":
     pass
 
 cdef struct Vertex:

embreex/rtcore.pyx

@@ -6,19 +6,19 @@ import logging
 log = logging.getLogger('embreex')
 
 cdef void print_error(RTCError code):
-    if code == RTC_NO_ERROR:
+    if code == RTC_ERROR_NONE:
         log.error("ERROR: No error")
-    elif code == RTC_UNKNOWN_ERROR:
+    elif code == RTC_ERROR_UNKNOWN:
         log.error("ERROR: Unknown error")
-    elif code == RTC_INVALID_ARGUMENT:
+    elif code == RTC_ERROR_INVALID_ARGUMENT:
         log.error("ERROR: Invalid argument")
-    elif code == RTC_INVALID_OPERATION:
+    elif code == RTC_ERROR_INVALID_OPERATION:
         log.error("ERROR: Invalid operation")
-    elif code == RTC_OUT_OF_MEMORY:
+    elif code == RTC_ERROR_OUT_OF_MEMORY:
         log.error("ERROR: Out of memory")
-    elif code == RTC_UNSUPPORTED_CPU:
+    elif code == RTC_ERROR_UNSUPPORTED_CPU:
         log.error("ERROR: Unsupported CPU")
-    elif code == RTC_CANCELLED:
+    elif code == RTC_ERROR_CANCELLED:
         log.error("ERROR: Cancelled")
     else:
         raise RuntimeError
@@ -29,9 +29,9 @@ cdef class EmbreeDevice:
         self.device = rtcNewDevice(NULL)
 
     def __dealloc__(self):
-        rtcDeleteDevice(self.device)
+        rtcReleaseDevice(self.device)
 
     def __repr__(self):
-        return 'Embree version:  {0}.{1}.{2}'.format(RTCORE_VERSION_MAJOR,
-                                                     RTCORE_VERSION_MINOR,
-                                                     RTCORE_VERSION_PATCH)
+        return 'Embree version:  {0}.{1}.{2}'.format(RTC_VERSION_MAJOR,
+                                                     RTC_VERSION_MINOR,
+                                                     RTC_VERSION_PATCH)