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

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

3


4
#pragma once

5


6
#include "grid_soa.h"

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

8
#include "triangle_intersector_pluecker.h"

9


10
namespace embree

11
{

12
  namespace isa

13
  {

14
    class GridSOAIntersector1

15
    {

16
    public:

17
      typedef void Primitive;

18
      

19
      class Precalculations

20
      { 

21
      public:

22
        __forceinline Precalculations (const Ray& ray, const void* ptr)

23
          : grid(nullptr) {}

24
        

25
      public:

26
        GridSOA* grid;

27
        int itime;

28
        float ftime;

29
      };

30
      

31
      template<typename Loader>

32
        static __forceinline void intersect(RayHit& ray,

33
                                            RayQueryContext* context, 

34
                                            const float* const grid_x,

35
                                            const size_t line_offset,

36
                                            const size_t lines,

37
                                            Precalculations& pre)

38
      {

39
        typedef typename Loader::vfloat vfloat;

40
        const size_t dim_offset    = pre.grid->dim_offset;

41
        const float* const grid_y  = grid_x + 1 * dim_offset;

42
        const float* const grid_z  = grid_x + 2 * dim_offset;

43
        const float* const grid_uv = grid_x + 3 * dim_offset;

44
        Vec3<vfloat> v0, v1, v2;

45
        Loader::gather(grid_x,grid_y,grid_z,line_offset,lines,v0,v1,v2);       

46
        GridSOA::MapUV<Loader> mapUV(grid_uv,line_offset,lines);

47
        PlueckerIntersector1<Loader::M> intersector(ray,nullptr);

48
        intersector.intersect(ray,v0,v1,v2,mapUV,Intersect1EpilogMU<Loader::M,true>(ray,context,pre.grid->geomID(),pre.grid->primID()));

49
      };

50
      

51
      template<typename Loader>

52
        static __forceinline bool occluded(Ray& ray,

53
                                           RayQueryContext* context, 

54
                                           const float* const grid_x,

55
                                           const size_t line_offset,

56
                                           const size_t lines,

57
                                           Precalculations& pre)

58
      {

59
        typedef typename Loader::vfloat vfloat;

60
        const size_t dim_offset    = pre.grid->dim_offset;

61
        const float* const grid_y  = grid_x + 1 * dim_offset;

62
        const float* const grid_z  = grid_x + 2 * dim_offset;

63
        const float* const grid_uv = grid_x + 3 * dim_offset;

64


65
        Vec3<vfloat> v0, v1, v2;

66
        Loader::gather(grid_x,grid_y,grid_z,line_offset,lines,v0,v1,v2);

67
        

68
        GridSOA::MapUV<Loader> mapUV(grid_uv,line_offset,lines);

69
        PlueckerIntersector1<Loader::M> intersector(ray,nullptr);

70
        return intersector.intersect(ray,v0,v1,v2,mapUV,Occluded1EpilogMU<Loader::M,true>(ray,context,pre.grid->geomID(),pre.grid->primID()));

71
      }

72
      

73
      /*! Intersect a ray with the primitive. */

74
      static __forceinline void intersect(Precalculations& pre, RayHit& ray, RayQueryContext* context, const Primitive* prim, size_t& lazy_node) 

75
      {

76
        const size_t line_offset   = pre.grid->width;

77
        const size_t lines         = pre.grid->height;

78
        const float* const grid_x  = pre.grid->decodeLeaf(0,prim);

79
        

80
#if defined(__AVX__)

81
        intersect<GridSOA::Gather3x3>( ray, context, grid_x, line_offset, lines, pre);

82
#else

83
        intersect<GridSOA::Gather2x3>(ray, context, grid_x            , line_offset, lines, pre);

84
        if (likely(lines > 2))

85
          intersect<GridSOA::Gather2x3>(ray, context, grid_x+line_offset, line_offset, lines, pre);

86
#endif

87
      }

88
      

89
      /*! Test if the ray is occluded by the primitive */

90
      static __forceinline bool occluded(Precalculations& pre, Ray& ray, RayQueryContext* context, const Primitive* prim, size_t& lazy_node)

91
      {

92
        const size_t line_offset   = pre.grid->width;

93
        const size_t lines         = pre.grid->height;

94
        const float* const grid_x  = pre.grid->decodeLeaf(0,prim);

95
        

96
#if defined(__AVX__)

97
        return occluded<GridSOA::Gather3x3>( ray, context, grid_x, line_offset, lines, pre);

98
#else

99
        if (occluded<GridSOA::Gather2x3>(ray, context, grid_x            , line_offset, lines, pre)) return true;

100
        if (likely(lines > 2))

101
          if (occluded<GridSOA::Gather2x3>(ray, context, grid_x+line_offset, line_offset, lines, pre)) return true;

102
#endif

103
        return false;

104
      }      

105
    };

106


107
    class GridSOAMBIntersector1

108
    {

109
    public:

110
      typedef void Primitive;

111
      typedef GridSOAIntersector1::Precalculations Precalculations;

112
      

113
      template<typename Loader>

114
        static __forceinline void intersect(RayHit& ray, const float ftime,

115
                                            RayQueryContext* context, 

116
                                            const float* const grid_x,

117
                                            const size_t line_offset,

118
                                            const size_t lines,

119
                                            Precalculations& pre)

120
      {

121
        typedef typename Loader::vfloat vfloat;

122
        const size_t dim_offset    = pre.grid->dim_offset;

123
        const size_t grid_offset   = pre.grid->gridBytes >> 2;

124
        const float* const grid_y  = grid_x + 1 * dim_offset;

125
        const float* const grid_z  = grid_x + 2 * dim_offset;

126
        const float* const grid_uv = grid_x + 3 * dim_offset;

127


128
        Vec3<vfloat> a0, a1, a2;

129
        Loader::gather(grid_x,grid_y,grid_z,line_offset,lines,a0,a1,a2);

130


131
        Vec3<vfloat> b0, b1, b2;

132
        Loader::gather(grid_x+grid_offset,grid_y+grid_offset,grid_z+grid_offset,line_offset,lines,b0,b1,b2);

133


134
        Vec3<vfloat> v0 = lerp(a0,b0,vfloat(ftime));

135
        Vec3<vfloat> v1 = lerp(a1,b1,vfloat(ftime));

136
        Vec3<vfloat> v2 = lerp(a2,b2,vfloat(ftime));

137


138
        GridSOA::MapUV<Loader> mapUV(grid_uv,line_offset,lines);

139
        PlueckerIntersector1<Loader::M> intersector(ray,nullptr);

140
        intersector.intersect(ray,v0,v1,v2,mapUV,Intersect1EpilogMU<Loader::M,true>(ray,context,pre.grid->geomID(),pre.grid->primID()));

141
      };

142
      

143
      template<typename Loader>

144
        static __forceinline bool occluded(Ray& ray, const float ftime,

145
                                           RayQueryContext* context, 

146
                                           const float* const grid_x,

147
                                           const size_t line_offset,

148
                                           const size_t lines,

149
                                           Precalculations& pre)

150
      {

151
        typedef typename Loader::vfloat vfloat;

152
        const size_t dim_offset    = pre.grid->dim_offset;

153
        const size_t grid_offset   = pre.grid->gridBytes >> 2;

154
        const float* const grid_y  = grid_x + 1 * dim_offset;

155
        const float* const grid_z  = grid_x + 2 * dim_offset;

156
        const float* const grid_uv = grid_x + 3 * dim_offset;

157


158
        Vec3<vfloat> a0, a1, a2;

159
        Loader::gather(grid_x,grid_y,grid_z,line_offset,lines,a0,a1,a2);

160


161
        Vec3<vfloat> b0, b1, b2;

162
        Loader::gather(grid_x+grid_offset,grid_y+grid_offset,grid_z+grid_offset,line_offset,lines,b0,b1,b2);

163
       

164
        Vec3<vfloat> v0 = lerp(a0,b0,vfloat(ftime));

165
        Vec3<vfloat> v1 = lerp(a1,b1,vfloat(ftime));

166
        Vec3<vfloat> v2 = lerp(a2,b2,vfloat(ftime));

167
        

168
        GridSOA::MapUV<Loader> mapUV(grid_uv,line_offset,lines);

169
        PlueckerIntersector1<Loader::M> intersector(ray,nullptr);

170
        return intersector.intersect(ray,v0,v1,v2,mapUV,Occluded1EpilogMU<Loader::M,true>(ray,context,pre.grid->geomID(),pre.grid->primID()));

171
      }

172
      

173
      /*! Intersect a ray with the primitive. */

174
      static __forceinline void intersect(Precalculations& pre, RayHit& ray, RayQueryContext* context, const Primitive* prim, size_t& lazy_node) 

175
      { 

176
        const size_t line_offset   = pre.grid->width;

177
        const size_t lines         = pre.grid->height;

178
        const float* const grid_x  = pre.grid->decodeLeaf(pre.itime,prim);

179
        

180
#if defined(__AVX__)

181
        intersect<GridSOA::Gather3x3>( ray, pre.ftime, context, grid_x, line_offset, lines, pre);

182
#else

183
        intersect<GridSOA::Gather2x3>(ray, pre.ftime, context, grid_x, line_offset, lines, pre);

184
        if (likely(lines > 2))

185
          intersect<GridSOA::Gather2x3>(ray, pre.ftime, context, grid_x+line_offset, line_offset, lines, pre);

186
#endif

187
      }

188
      

189
      /*! Test if the ray is occluded by the primitive */

190
      static __forceinline bool occluded(Precalculations& pre, Ray& ray, RayQueryContext* context, const Primitive* prim, size_t& lazy_node)

191
      {

192
        const size_t line_offset   = pre.grid->width;

193
        const size_t lines         = pre.grid->height;

194
        const float* const grid_x  = pre.grid->decodeLeaf(pre.itime,prim);

195
        

196
#if defined(__AVX__)

197
        return occluded<GridSOA::Gather3x3>( ray, pre.ftime, context, grid_x, line_offset, lines, pre);

198
#else

199
        if (occluded<GridSOA::Gather2x3>(ray, pre.ftime, context, grid_x            , line_offset, lines, pre)) return true;

200
        if (likely(lines > 2))

201
          if (occluded<GridSOA::Gather2x3>(ray, pre.ftime, context, grid_x+line_offset, line_offset, lines, pre)) return true;

202
#endif

203
        return false;

204
      }      

205
    };

206
  }

207
}

208


209