1 files changed, 385 insertions, 0 deletions
diff --git a/thirdparty/embree/kernels/common/scene_instance_array.h b/thirdparty/embree/kernels/common/scene_instance_array.h
new file mode 100644
index 0000000000..3cf4d68feb
--- /dev/null
+++ b/thirdparty/embree/kernels/common/scene_instance_array.h
@@ -0,0 +1,385 @@
+// Copyright 2009-2021 Intel Corporation
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include "geometry.h"
+#include "accel.h"
+
+namespace embree
+{
+  struct MotionDerivativeCoefficients;
+
+  /*! Instanced acceleration structure */
+  struct InstanceArray : public Geometry
+  {
+    //ALIGNED_STRUCT_(16);
+    static const Geometry::GTypeMask geom_type = Geometry::MTY_INSTANCE_ARRAY;
+
+  public:
+    InstanceArray (Device* device, unsigned int numTimeSteps = 1);
+    ~InstanceArray();
+
+  private:
+    InstanceArray (const InstanceArray& other) DELETED; // do not implement
+    InstanceArray& operator= (const InstanceArray& other) DELETED; // do not implement
+
+  private:
+    LBBox3fa nonlinearBounds(size_t i,
+                             const BBox1f& time_range_in,
+                             const BBox1f& geom_time_range,
+                             float geom_time_segments) const;
+
+    BBox3fa boundSegment(size_t i, size_t itime,
+      BBox3fa const& obbox0, BBox3fa const& obbox1,
+      BBox3fa const& bbox0, BBox3fa const& bbox1,
+      float t_min, float t_max) const;
+
+    /* calculates the (correct) interpolated bounds */
+    __forceinline BBox3fa bounds(size_t i, size_t itime0, size_t itime1, float f) const
+    {
+      if (unlikely(gsubtype == GTY_SUBTYPE_INSTANCE_QUATERNION))
+        return xfmBounds(slerp(l2w(i, itime0), l2w(i, itime1), f),
+                         lerp(getObjectBounds(i, itime0), getObjectBounds(i, itime1), f));
+      return xfmBounds(lerp(l2w(i, itime0), l2w(i, itime1), f),
+                        lerp(getObjectBounds(i, itime0), getObjectBounds(i, itime1), f));
+    }
+
+  public:
+
+    virtual void setBuffer(RTCBufferType type, unsigned int slot, RTCFormat format, const Ref<Buffer>& buffer, size_t offset, size_t stride, unsigned int num) override;
+    virtual void* getBuffer(RTCBufferType type, unsigned int slot) override;
+    virtual void updateBuffer(RTCBufferType type, unsigned int slot) override;
+
+    virtual void setNumTimeSteps (unsigned int numTimeSteps) override;
+    virtual void setInstancedScene(const Ref<Scene>& scene) override;
+    virtual void setInstancedScenes(const RTCScene* scenes, size_t numScenes) override;
+    virtual AffineSpace3fa getTransform(size_t, float time) override;
+    virtual void setMask (unsigned mask) override;
+    virtual void build() {}
+    virtual void addElementsToCount (GeometryCounts & counts) const override;
+    virtual void commit() override;
+
+  public:
+
+     /*! calculates the bounds of instance */
+    __forceinline BBox3fa bounds(size_t i) const {
+      if (!valid(i))
+        return BBox3fa();
+
+      if (unlikely(gsubtype == GTY_SUBTYPE_INSTANCE_QUATERNION))
+        return xfmBounds(quaternionDecompositionToAffineSpace(l2w(i, 0)),getObject(i)->bounds.bounds());
+      return xfmBounds(l2w(i, 0),getObject(i)->bounds.bounds());
+    }
+
+    /*! gets the bounds of the instanced scene */
+    __forceinline BBox3fa getObjectBounds(size_t i, size_t itime) const {
+      if (!valid(i))
+        return BBox3fa();
+
+      return getObject(i)->getBounds(timeStep(itime));
+    }
+
+     /*! calculates the bounds of instance */
+    __forceinline BBox3fa bounds(size_t i, size_t itime) const {
+      if (!valid(i))
+        return BBox3fa();
+
+      if (unlikely(gsubtype == GTY_SUBTYPE_INSTANCE_QUATERNION))
+        return xfmBounds(quaternionDecompositionToAffineSpace(l2w(i, itime)),getObjectBounds(i, itime));
+      return xfmBounds(l2w(i, itime),getObjectBounds(i, itime));
+    }
+
+    /*! calculates the linear bounds of the i'th primitive for the specified time range */
+    __forceinline LBBox3fa linearBounds(size_t i, const BBox1f& dt) const {
+      if (!valid(i))
+        return LBBox3fa();
+
+      LBBox3fa lbbox = nonlinearBounds(i, dt, time_range, fnumTimeSegments);
+      return lbbox;
+    }
+
+    /*! calculates the build bounds of the i'th item, if it's valid */
+    __forceinline bool buildBounds(size_t i, BBox3fa* bbox = nullptr) const
+    {
+      if (!valid(i))
+        return false;
+
+      const BBox3fa b = bounds(i);
+      if (bbox) *bbox = b;
+      return isvalid(b);
+    }
+
+     /*! calculates the build bounds of the i'th item at the itime'th time segment, if it's valid */
+    __forceinline bool buildBounds(size_t i, size_t itime, BBox3fa& bbox) const
+    {
+      if (!valid(i))
+        return false;
+
+      const LBBox3fa bounds = linearBounds(i,itime);
+      bbox = bounds.bounds ();
+      return isvalid(bounds);
+    }
+
+    /* gets version info of topology */
+    unsigned int getTopologyVersion() const {
+      return numPrimitives;
+    }
+  
+    /* returns true if topology changed */
+    bool topologyChanged(unsigned int otherVersion) const {
+      return numPrimitives != otherVersion;
+    }
+
+    /*! check if the i'th primitive is valid between the specified time range */
+    __forceinline bool valid(size_t i) const
+    {
+      if (object) return true;
+      return (object_ids[i] != (unsigned int)(-1));
+    }
+
+    /*! check if the i'th primitive is valid between the specified time range */
+    __forceinline bool valid(size_t i, const range<size_t>& itime_range) const
+    {
+      for (size_t itime = itime_range.begin(); itime <= itime_range.end(); itime++)
+        if (!isvalid(bounds(i,itime))) return false;
+
+      return true;
+    }
+
+    __forceinline AffineSpace3fa getLocal2World(size_t i) const
+    {
+      if (unlikely(gsubtype == GTY_SUBTYPE_INSTANCE_QUATERNION))
+        return quaternionDecompositionToAffineSpace(l2w(i,0));
+      return l2w(i, 0);
+    }
+
+    __forceinline AffineSpace3fa getLocal2World(size_t i, float t) const
+    {
+      if (numTimeSegments() > 0) {
+        float ftime; const unsigned int itime = timeSegment(t, ftime);
+        if (unlikely(gsubtype == GTY_SUBTYPE_INSTANCE_QUATERNION))
+          return slerp(l2w(i, itime+0),l2w(i, itime+1),ftime);
+        return lerp(l2w(i, itime+0),l2w(i, itime+1),ftime);
+      }
+      return getLocal2World(i);
+    }
+
+    __forceinline AffineSpace3fa getWorld2Local(size_t i) const {
+      return rcp(getLocal2World(i));
+    }
+
+    __forceinline AffineSpace3fa getWorld2Local(size_t i, float t) const {
+      return rcp(getLocal2World(i, t));
+    }
+
+    template<int K>
+    __forceinline AffineSpace3vf<K> getWorld2Local(size_t i, const vbool<K>& valid, const vfloat<K>& t) const
+    {
+      if (unlikely(gsubtype == GTY_SUBTYPE_INSTANCE_QUATERNION))
+        return getWorld2LocalSlerp<K>(i, valid, t);
+      return getWorld2LocalLerp<K>(i, valid, t);
+    }
+
+    __forceinline float projectedPrimitiveArea(const size_t i) const {
+      return area(bounds(i));
+    }
+
+    inline Accel* getObject(size_t i) const {
+      if (object) {
+        return object;
+      }
+
+      assert(objects);
+      assert(i < numPrimitives);
+      if (object_ids[i] == (unsigned int)(-1))
+        return nullptr;
+
+      assert(object_ids[i] < numObjects);
+      return objects[object_ids[i]];
+    }
+
+    private:
+
+    template<int K>
+    __forceinline AffineSpace3vf<K> getWorld2LocalSlerp(size_t i, const vbool<K>& valid, const vfloat<K>& t) const
+    {
+      vfloat<K> ftime;
+      const vint<K> itime_k = timeSegment<K>(t, ftime);
+      assert(any(valid));
+      const size_t index = bsf(movemask(valid));
+      const int itime = itime_k[index];
+      if (likely(all(valid, itime_k == vint<K>(itime)))) {
+        return rcp(slerp(AffineSpace3vff<K>(l2w(i, itime+0)),
+                         AffineSpace3vff<K>(l2w(i, itime+1)),
+                         ftime));
+      }
+      else {
+        AffineSpace3vff<K> space0,space1;
+        vbool<K> valid1 = valid;
+        while (any(valid1)) {
+          vbool<K> valid2;
+          const int itime = next_unique(valid1, itime_k, valid2);
+          space0 = select(valid2, AffineSpace3vff<K>(l2w(i, itime+0)), space0);
+          space1 = select(valid2, AffineSpace3vff<K>(l2w(i, itime+1)), space1);
+        }
+        return rcp(slerp(space0, space1, ftime));
+      }
+    }
+
+    template<int K>
+    __forceinline AffineSpace3vf<K> getWorld2LocalLerp(size_t i, const vbool<K>& valid, const vfloat<K>& t) const
+    {
+      vfloat<K> ftime;
+      const vint<K> itime_k = timeSegment<K>(t, ftime);
+      assert(any(valid));
+      const size_t index = bsf(movemask(valid));
+      const int itime = itime_k[index];
+      if (likely(all(valid, itime_k == vint<K>(itime)))) {
+        return rcp(lerp(AffineSpace3vf<K>((AffineSpace3fa)l2w(i, itime+0)),
+                        AffineSpace3vf<K>((AffineSpace3fa)l2w(i, itime+1)),
+                        ftime));
+      } else {
+        AffineSpace3vf<K> space0,space1;
+        vbool<K> valid1 = valid;
+        while (any(valid1)) {
+          vbool<K> valid2;
+          const int itime = next_unique(valid1, itime_k, valid2);
+          space0 = select(valid2, AffineSpace3vf<K>((AffineSpace3fa)l2w(i, itime+0)), space0);
+          space1 = select(valid2, AffineSpace3vf<K>((AffineSpace3fa)l2w(i, itime+1)), space1);
+        }
+        return rcp(lerp(space0, space1, ftime));
+      }
+    }
+
+  private:
+
+    __forceinline AffineSpace3ff l2w(size_t i, size_t itime) const {
+      if (l2w_buf[itime].getFormat() == RTC_FORMAT_FLOAT4X4_COLUMN_MAJOR) {
+        return *(AffineSpace3ff*)(l2w_buf[itime].getPtr(i));
+      }
+      else if(l2w_buf[itime].getFormat() == RTC_FORMAT_QUATERNION_DECOMPOSITION) {
+        AffineSpace3ff transform;
+        QuaternionDecomposition* qd = (QuaternionDecomposition*)l2w_buf[itime].getPtr(i);
+        transform.l.vx.x = qd->scale_x;
+        transform.l.vy.y = qd->scale_y;
+        transform.l.vz.z = qd->scale_z;
+        transform.l.vy.x = qd->skew_xy;
+        transform.l.vz.x = qd->skew_xz;
+        transform.l.vz.y = qd->skew_yz;
+        transform.l.vx.y = qd->translation_x;
+        transform.l.vx.z = qd->translation_y;
+        transform.l.vy.z = qd->translation_z;
+        transform.p.x    = qd->shift_x;
+        transform.p.y    = qd->shift_y;
+        transform.p.z    = qd->shift_z;
+        // normalize quaternion
+        Quaternion3f q(qd->quaternion_r, qd->quaternion_i, qd->quaternion_j, qd->quaternion_k);
+        q = normalize(q);
+        transform.l.vx.w = q.i;
+        transform.l.vy.w = q.j;
+        transform.l.vz.w = q.k;
+        transform.p.w    = q.r;
+        return transform;
+      }
+      else if (l2w_buf[itime].getFormat() == RTC_FORMAT_FLOAT3X4_COLUMN_MAJOR) {
+        AffineSpace3f* l2w = reinterpret_cast<AffineSpace3f*>(l2w_buf[itime].getPtr(i));
+        return AffineSpace3ff(*l2w);
+      }
+      else if (l2w_buf[itime].getFormat() == RTC_FORMAT_FLOAT3X4_ROW_MAJOR) {
+        float* data = reinterpret_cast<float*>(l2w_buf[itime].getPtr(i));
+        AffineSpace3f l2w;
+        l2w.l.vx.x = data[0]; l2w.l.vy.x = data[1]; l2w.l.vz.x = data[2]; l2w.p.x = data[3];
+        l2w.l.vx.y = data[4]; l2w.l.vy.y = data[5]; l2w.l.vz.y = data[6]; l2w.p.y = data[7];
+        l2w.l.vx.z = data[8]; l2w.l.vy.z = data[9]; l2w.l.vz.z = data[10]; l2w.p.z = data[11];
+        return l2w;
+      }
+      assert(false);
+      return AffineSpace3ff();
+    }
+
+    inline AffineSpace3ff l2w(size_t i) const {
+      return l2w(i, 0);
+    }
+
+  private:
+    Accel* object;                   //!< fast path if only one scene is instanced
+    Accel** objects;
+    uint32_t numObjects;
+    Device::vector<RawBufferView> l2w_buf = device; //!< transformation from local space to world space for each timestep (either normal matrix or quaternion decomposition)
+    BufferView<uint32_t> object_ids; //!< array of scene ids per instance array primitive
+  };
+
+  namespace isa
+  {
+    struct InstanceArrayISA : public InstanceArray
+    {
+      InstanceArrayISA (Device* device)
+        : InstanceArray(device) {}
+
+      LBBox3fa vlinearBounds(size_t primID, const BBox1f& time_range) const {
+        return linearBounds(primID,time_range);
+      }
+
+      PrimInfo createPrimRefArray(PrimRef* prims, const range<size_t>& r, size_t k, unsigned int geomID) const
+      {
+        PrimInfo pinfo(empty);
+        for (size_t j = r.begin(); j < r.end(); j++) {
+          BBox3fa bounds = empty;
+          if (!buildBounds(j, &bounds) || !valid(j))
+            continue;
+          const PrimRef prim(bounds, geomID, unsigned(j));
+          pinfo.add_center2(prim);
+          prims[k++] = prim;
+        }
+        return pinfo;
+      }
+
+      PrimInfo createPrimRefArrayMB(mvector<PrimRef>& prims, size_t itime, const range<size_t>& r, size_t k, unsigned int geomID) const
+      {
+        PrimInfo pinfo(empty);
+        for (size_t j = r.begin(); j < r.end(); j++) {
+          BBox3fa bounds = empty;
+          if (!buildBounds(j, itime, bounds))
+            continue;
+          const PrimRef prim(bounds, geomID, unsigned(j));
+          pinfo.add_center2(prim);
+          prims[k++] = prim;
+        }
+        return pinfo;
+      }
+
+      PrimInfo createPrimRefArrayMB(PrimRef* prims, const BBox1f& time_range, const range<size_t>& r, size_t k, unsigned int geomID) const
+      {
+        PrimInfo pinfo(empty);
+        const BBox1f t0t1 = BBox1f::intersect(getTimeRange(), time_range);
+        if (t0t1.empty()) return pinfo;
+
+        for (size_t j = r.begin(); j < r.end(); j++) {
+          LBBox3fa lbounds = linearBounds(j, t0t1);
+          if (!isvalid(lbounds.bounds()))
+            continue;
+          const PrimRef prim(lbounds.bounds(), geomID, unsigned(j));
+          pinfo.add_center2(prim);
+          prims[k++] = prim;
+        }
+        return pinfo;
+      }
+
+      PrimInfoMB createPrimRefMBArray(mvector<PrimRefMB>& prims, const BBox1f& t0t1, const range<size_t>& r, size_t k, unsigned int geomID) const
+      {
+        PrimInfoMB pinfo(empty);
+        for (size_t j = r.begin(); j < r.end(); j++) {
+          if (!valid(j, timeSegmentRange(t0t1)))
+            continue;
+          const PrimRefMB prim(linearBounds(j, t0t1), this->numTimeSegments(), this->time_range, this->numTimeSegments(), geomID, unsigned(j));
+          pinfo.add_primref(prim);
+          prims[k++] = prim;
+        }
+        return pinfo;
+      }
+    };
+  }
+
+  DECLARE_ISA_FUNCTION(InstanceArray*, createInstanceArray, Device*);
+}