Book a Demo!
CoCalc Logo Icon
StoreFeaturesDocsShareSupportNewsAboutPoliciesSign UpSign In
godotengine
GitHub Repository: godotengine/godot
 Path: blob/master/thirdparty/embree/kernels/geometry/curve_intersector_ribbon.h
9905 views
1
// Copyright 2009-2021 Intel Corporation

2
// SPDX-License-Identifier: Apache-2.0

3


4
#pragma once

5


6
#include "../common/ray.h"

7
#include "quad_intersector.h"

8
#include "curve_intersector_precalculations.h"

9


10
#define Bezier1Intersector1 RibbonCurve1Intersector1

11
#define Bezier1IntersectorK RibbonCurve1IntersectorK

12


13
namespace embree

14
{

15
  namespace isa

16
  {

17
    template<typename NativeCurve3ff, int M>

18
    struct RibbonHit

19
    {

20
      __forceinline RibbonHit() {}

21


22
      __forceinline RibbonHit(const vbool<M>& valid, const vfloat<M>& U, const vfloat<M>& V, const vfloat<M>& T, const int i, const int N,

23
                              const NativeCurve3ff& curve3D)

24
        : U(U), V(V), T(T), i(i), N(N), curve3D(curve3D), valid(valid) {}

25
      

26
      __forceinline void finalize() 

27
      {

28
        vu = (vfloat<M>(step)+U+vfloat<M>(float(i)))*(1.0f/float(N));

29
        vv = V;

30
        vt = T;

31
      }

32
      

33
      __forceinline Vec2f uv (const size_t i) const { return Vec2f(vu[i],vv[i]); }

34
      __forceinline float t  (const size_t i) const { return vt[i]; }

35
      __forceinline Vec3fa Ng(const size_t i) const { return curve3D.eval_du(vu[i]); }

36


37
      __forceinline Vec2vf<M> uv() const { return Vec2vf<M>(vu,vv); }

38
      __forceinline vfloat<M> t () const { return vt; }

39
      __forceinline Vec3vf<M> Ng() const { return (Vec3vf<M>) curve3D.template veval_du<M>(vu); }

40
      

41
    public:

42
      vfloat<M> U;

43
      vfloat<M> V;

44
      vfloat<M> T;

45
      int i, N;

46
      NativeCurve3ff curve3D;

47
      

48
    public:

49
      vbool<M> valid;

50
      vfloat<M> vu;

51
      vfloat<M> vv;

52
      vfloat<M> vt;

53
    };

54


55
    /* calculate squared distance of point p0 to line p1->p2 */

56
    template<int M>

57
    __forceinline std::pair<vfloat<M>,vfloat<M>> sqr_point_line_distance(const Vec2vf<M>& p0, const Vec2vf<M>& p1, const Vec2vf<M>& p2)

58
    {

59
      const vfloat<M> num = det(p2-p1,p1-p0);

60
      const vfloat<M> den2 = dot(p2-p1,p2-p1);

61
      return std::make_pair(num*num,den2);

62
    }

63
    

64
    /* performs culling against a cylinder */

65
     template<int M>

66
     __forceinline vbool<M> cylinder_culling_test(const Vec2vf<M>& p0, const Vec2vf<M>& p1, const Vec2vf<M>& p2, const vfloat<M>& r)

67
    {

68
      const std::pair<vfloat<M>,vfloat<M>> d = sqr_point_line_distance<M>(p0,p1,p2);

69
      return d.first <= r*r*d.second;

70
    }

71


72
    template<int M = VSIZEX, typename NativeCurve3ff, typename Epilog>

73
    __forceinline bool intersect_ribbon(const Vec3fa& ray_org, const Vec3fa& ray_dir, const float ray_tnear, const float& ray_tfar,

74
                                        const LinearSpace3fa& ray_space, const float& depth_scale,

75
                                        const NativeCurve3ff& curve3D, const int N,

76
                                        const Epilog& epilog)

77
    {

78
      /* transform control points into ray space */

79
      const NativeCurve3ff curve2D = curve3D.xfm_pr(ray_space,ray_org);

80
      float eps = 4.0f*float(ulp)*reduce_max(max(abs(curve2D.v0),abs(curve2D.v1),abs(curve2D.v2),abs(curve2D.v3)));

81


82
      int i=0;

83
      bool ishit = false;

84
      

85
#if !defined(__SYCL_DEVICE_ONLY__)

86
      {

87
        /* evaluate the bezier curve */

88
        vbool<M> valid = vfloat<M>(step) < vfloat<M>(float(N));

89
        const Vec4vf<M> p0 = curve2D.template eval0<M>(0,N);

90
        const Vec4vf<M> p1 = curve2D.template eval1<M>(0,N);

91
        valid &= cylinder_culling_test<M>(zero,Vec2vf<M>(p0.x,p0.y),Vec2vf<M>(p1.x,p1.y),max(p0.w,p1.w));

92
        

93
        if (any(valid)) 

94
        {

95
          Vec3vf<M> dp0dt = curve2D.template derivative0<M>(0,N);

96
          Vec3vf<M> dp1dt = curve2D.template derivative1<M>(0,N);

97
          dp0dt = select(reduce_max(abs(dp0dt)) < vfloat<M>(eps),Vec3vf<M>(p1-p0),dp0dt);

98
          dp1dt = select(reduce_max(abs(dp1dt)) < vfloat<M>(eps),Vec3vf<M>(p1-p0),dp1dt);

99
          const Vec3vf<M> n0(dp0dt.y,-dp0dt.x,0.0f);

100
          const Vec3vf<M> n1(dp1dt.y,-dp1dt.x,0.0f);

101
          const Vec3vf<M> nn0 = normalize(n0);

102
          const Vec3vf<M> nn1 = normalize(n1);

103
          const Vec3vf<M> lp0 = madd(p0.w,nn0,Vec3vf<M>(p0));

104
          const Vec3vf<M> lp1 = madd(p1.w,nn1,Vec3vf<M>(p1));

105
          const Vec3vf<M> up0 = nmadd(p0.w,nn0,Vec3vf<M>(p0));

106
          const Vec3vf<M> up1 = nmadd(p1.w,nn1,Vec3vf<M>(p1));

107
          

108
          vfloat<M> vu,vv,vt;

109
          vbool<M> valid0 = intersect_quad_backface_culling<M>(valid,zero,Vec3fa(0,0,1),ray_tnear,ray_tfar,lp0,lp1,up1,up0,vu,vv,vt);

110
          

111
          if (any(valid0))

112
          {

113
            /* ignore self intersections */

114
            if (EMBREE_CURVE_SELF_INTERSECTION_AVOIDANCE_FACTOR != 0.0f) {

115
              vfloat<M> r = lerp(p0.w, p1.w, vu);

116
              valid0 &= vt > float(EMBREE_CURVE_SELF_INTERSECTION_AVOIDANCE_FACTOR)*r*depth_scale;

117
            }

118
            

119
            if (any(valid0))

120
            {

121
              vv = madd(2.0f,vv,vfloat<M>(-1.0f));

122
              RibbonHit<NativeCurve3ff,M> bhit(valid0,vu,vv,vt,0,N,curve3D);

123
              ishit |= epilog(bhit.valid,bhit);

124
            }

125
          }

126
        }

127
        i += M;

128
      }

129
      

130
      if (unlikely(i < N))

131
#endif

132
      {

133
        /* process SIMD-size many segments per iteration */

134
        for (; i<N; i+=M)

135
        {

136
          /* evaluate the bezier curve */

137
          vbool<M> valid = vint<M>(i)+vint<M>(step) < vint<M>(N);

138
          const Vec4vf<M> p0 = curve2D.template eval0<M>(i,N);

139
          const Vec4vf<M> p1 = curve2D.template eval1<M>(i,N);

140
          valid &= cylinder_culling_test<M>(zero,Vec2vf<M>(p0.x,p0.y),Vec2vf<M>(p1.x,p1.y),max(p0.w,p1.w));

141
          if (none(valid)) continue;

142
          

143
          Vec3vf<M> dp0dt = curve2D.template derivative0<M>(i,N);

144
          Vec3vf<M> dp1dt = curve2D.template derivative1<M>(i,N);

145
          dp0dt = select(reduce_max(abs(dp0dt)) < vfloat<M>(eps),Vec3vf<M>(p1-p0),dp0dt);

146
          dp1dt = select(reduce_max(abs(dp1dt)) < vfloat<M>(eps),Vec3vf<M>(p1-p0),dp1dt);

147
          const Vec3vf<M> n0(dp0dt.y,-dp0dt.x,0.0f);

148
          const Vec3vf<M> n1(dp1dt.y,-dp1dt.x,0.0f);

149
          const Vec3vf<M> nn0 = normalize(n0);

150
          const Vec3vf<M> nn1 = normalize(n1);

151
          const Vec3vf<M> lp0 = madd(p0.w,nn0,Vec3vf<M>(p0));

152
          const Vec3vf<M> lp1 = madd(p1.w,nn1,Vec3vf<M>(p1));

153
          const Vec3vf<M> up0 = nmadd(p0.w,nn0,Vec3vf<M>(p0));

154
          const Vec3vf<M> up1 = nmadd(p1.w,nn1,Vec3vf<M>(p1));

155
          

156
          vfloat<M> vu,vv,vt;

157
          vbool<M> valid0 = intersect_quad_backface_culling<M>(valid,zero,Vec3fa(0,0,1),ray_tnear,ray_tfar,lp0,lp1,up1,up0,vu,vv,vt);

158


159
          if (any(valid0))

160
          {

161
            /* ignore self intersections */

162
            if (EMBREE_CURVE_SELF_INTERSECTION_AVOIDANCE_FACTOR != 0.0f) {

163
              vfloat<M> r = lerp(p0.w, p1.w, vu);

164
              valid0 &= vt > float(EMBREE_CURVE_SELF_INTERSECTION_AVOIDANCE_FACTOR)*r*depth_scale;

165
            }

166
            

167
            if (any(valid0))

168
            {

169
              vv = madd(2.0f,vv,vfloat<M>(-1.0f));

170
              RibbonHit<NativeCurve3ff,M> bhit(valid0,vu,vv,vt,i,N,curve3D);

171
              ishit |= epilog(bhit.valid,bhit);

172
            }

173
          }

174
        }

175
      }

176
      return ishit;

177
    }

178
        

179
    template<template<typename Ty> class NativeCurve, int M = VSIZEX>

180
    struct RibbonCurve1Intersector1

181
    {

182
      typedef NativeCurve<Vec3ff> NativeCurve3ff;

183
      

184
      template<typename Ray, typename Epilog>

185
      __forceinline bool intersect(const CurvePrecalculations1& pre, Ray& ray,

186
                                   RayQueryContext* context,

187
                                   const CurveGeometry* geom, const unsigned int primID,

188
                                   const Vec3ff& v0, const Vec3ff& v1, const Vec3ff& v2, const Vec3ff& v3,

189
                                   const Epilog& epilog)

190
      {

191
        const int N = geom->tessellationRate;

192
        NativeCurve3ff curve(v0,v1,v2,v3);

193
        curve = enlargeRadiusToMinWidth(context,geom,ray.org,curve);

194
        return intersect_ribbon<M,NativeCurve3ff>(ray.org,ray.dir,ray.tnear(),ray.tfar,

195
                                                pre.ray_space,pre.depth_scale,

196
                                                curve,N,

197
                                                epilog);

198
      }

199
    };

200
    

201
    template<template<typename Ty> class NativeCurve, int K, int M = VSIZEX>

202
    struct RibbonCurve1IntersectorK

203
    {

204
      typedef NativeCurve<Vec3ff> NativeCurve3ff;

205
      

206
      template<typename Epilog>

207
      __forceinline bool intersect(const CurvePrecalculationsK<K>& pre, RayK<K>& ray, size_t k,

208
                                   RayQueryContext* context,

209
                                   const CurveGeometry* geom, const unsigned int primID,

210
                                   const Vec3ff& v0, const Vec3ff& v1, const Vec3ff& v2, const Vec3ff& v3,

211
                                   const Epilog& epilog)

212
      {

213
        const int N = geom->tessellationRate;

214
        const Vec3fa ray_org(ray.org.x[k],ray.org.y[k],ray.org.z[k]);

215
        const Vec3fa ray_dir(ray.dir.x[k],ray.dir.y[k],ray.dir.z[k]);

216
        NativeCurve3ff curve(v0,v1,v2,v3);

217
        curve = enlargeRadiusToMinWidth(context,geom,ray_org,curve);

218
        return intersect_ribbon<M,NativeCurve3ff>(ray_org,ray_dir,ray.tnear()[k],ray.tfar[k],

219
                                                pre.ray_space[k],pre.depth_scale[k],

220
                                                curve,N,

221
                                                epilog);

222
      }

223
    };

224
  }

225
}

226


227