CoCalc -- feature_adaptive_eval

GitHub Repository: godotengine/godot
Path: blob/master/thirdparty/embree/kernels/subdiv/feature_adaptive_eval_grid.h
⁹⁹¹³ views
1
// Copyright 2009-2021 Intel Corporation
2
// SPDX-License-Identifier: Apache-2.0
3

4
#pragma once
5

6
#include "patch.h"
7
#include "catmullclark_patch.h"
8
#include "bspline_patch.h"
9
#include "gregory_patch.h"
10
#include "tessellation.h"
11

12
namespace embree
13
{
14
  namespace isa 
15
  {
16
    struct FeatureAdaptiveEvalGrid
17
    {
18
      typedef CatmullClark1Ring3fa CatmullClarkRing;
19
      typedef CatmullClarkPatch3fa CatmullClarkPatch;
20
      typedef BilinearPatch3fa BilinearPatch;
21
      typedef BSplinePatch3fa BSplinePatch;
22
      typedef BezierPatch3fa BezierPatch;
23
      typedef GregoryPatch3fa GregoryPatch;
24

25
    private:
26
      const unsigned x0,x1;
27
      const unsigned y0,y1;
28
      const unsigned swidth,sheight;
29
      const float rcp_swidth, rcp_sheight;
30
      float* const Px;
31
      float* const Py;
32
      float* const Pz;
33
      float* const U;
34
      float* const V;
35
      float* const Nx;
36
      float* const Ny;
37
      float* const Nz;
38
      const unsigned dwidth;
39
      //const unsigned dheight;
40
      unsigned count;
41
      
42

43
    public:      
44
      FeatureAdaptiveEvalGrid (const GeneralCatmullClarkPatch3fa& patch, unsigned subPatch,
45
                               const unsigned x0, const unsigned x1, const unsigned y0, const unsigned y1, const unsigned swidth, const unsigned sheight, 
46
                               float* Px, float* Py, float* Pz, float* U, float* V, 
47
                               float* Nx, float* Ny, float* Nz,
48
                               const unsigned dwidth, const unsigned dheight)
49
      : x0(x0), x1(x1), y0(y0), y1(y1), swidth(swidth), sheight(sheight), rcp_swidth(1.0f/(swidth-1.0f)), rcp_sheight(1.0f/(sheight-1.0f)), 
50
        Px(Px), Py(Py), Pz(Pz), U(U), V(V), Nx(Nx), Ny(Ny), Nz(Nz), dwidth(dwidth), /*dheight(dheight),*/ count(0)
51
      {
52
        assert(swidth < (2<<20) && sheight < (2<<20));
53
        const BBox2f srange(Vec2f(0.0f,0.0f),Vec2f(float(swidth-1),float(sheight-1)));
54
        const BBox2f erange(Vec2f((float)x0,(float)y0),Vec2f((float)x1,(float)y1));
55
        
56
        /* convert into standard quad patch if possible */
57
        if (likely(patch.isQuadPatch())) 
58
        {
59
          CatmullClarkPatch3fa qpatch; patch.init(qpatch);
60
          eval(qpatch, srange, erange, 0);
61
          assert(count == (x1-x0+1)*(y1-y0+1));
62
          return;
63
        }
64
        
65
        /* subdivide patch */
66
        unsigned N;
67
        array_t<CatmullClarkPatch3fa,GeneralCatmullClarkPatch3fa::SIZE> patches; 
68
        patch.subdivide(patches,N);
69
        
70
        if (N == 4)
71
        {
72
          const Vec2f c = srange.center();
73
          const BBox2f srange0(srange.lower,c);
74
          const BBox2f srange1(Vec2f(c.x,srange.lower.y),Vec2f(srange.upper.x,c.y));
75
          const BBox2f srange2(c,srange.upper);
76
          const BBox2f srange3(Vec2f(srange.lower.x,c.y),Vec2f(c.x,srange.upper.y));
77

78
#if PATCH_USE_GREGORY == 2
79
          BezierCurve3fa borders[GeneralCatmullClarkPatch3fa::SIZE]; patch.getLimitBorder(borders);
80
          BezierCurve3fa border0l,border0r; borders[0].subdivide(border0l,border0r);
81
          BezierCurve3fa border1l,border1r; borders[1].subdivide(border1l,border1r);
82
          BezierCurve3fa border2l,border2r; borders[2].subdivide(border2l,border2r);
83
          BezierCurve3fa border3l,border3r; borders[3].subdivide(border3l,border3r);
84
          GeneralCatmullClarkPatch3fa::fix_quad_ring_order(patches);
85
          eval(patches[0],srange0,intersect(srange0,erange),1,&border0l,nullptr,nullptr,&border3r);
86
          eval(patches[1],srange1,intersect(srange1,erange),1,&border0r,&border1l,nullptr,nullptr);
87
          eval(patches[2],srange2,intersect(srange2,erange),1,nullptr,&border1r,&border2l,nullptr);
88
          eval(patches[3],srange3,intersect(srange3,erange),1,nullptr,nullptr,&border2r,&border3l);
89
#else
90
          GeneralCatmullClarkPatch3fa::fix_quad_ring_order(patches);
91
          eval(patches[0],srange0,intersect(srange0,erange),1);
92
          eval(patches[1],srange1,intersect(srange1,erange),1);
93
          eval(patches[2],srange2,intersect(srange2,erange),1);
94
          eval(patches[3],srange3,intersect(srange3,erange),1);
95
#endif
96
        }
97
        else
98
        {
99
          assert(subPatch < N);
100
          
101
#if PATCH_USE_GREGORY == 2
102
          BezierCurve3fa borders[2]; patch.getLimitBorder(borders,subPatch);
103
          BezierCurve3fa border0l,border0r; borders[0].subdivide(border0l,border0r);
104
          BezierCurve3fa border2l,border2r; borders[1].subdivide(border2l,border2r);
105
          eval(patches[subPatch], srange, erange, 1, &border0l, nullptr, nullptr, &border2r);
106
#else
107
          eval(patches[subPatch], srange, erange, 1);
108
#endif
109
          
110
        }
111
        assert(count == (x1-x0+1)*(y1-y0+1));
112
      }
113
      
114
      FeatureAdaptiveEvalGrid (const CatmullClarkPatch3fa& patch,
115
                               const BBox2f& srange, const BBox2f& erange, const unsigned depth,
116
                               const unsigned x0, const unsigned x1, const unsigned y0, const unsigned y1, const unsigned swidth, const unsigned sheight, 
117
                               float* Px, float* Py, float* Pz, float* U, float* V, 
118
                               float* Nx, float* Ny, float* Nz,
119
                               const unsigned dwidth, const unsigned dheight)
120
      : x0(x0), x1(x1), y0(y0), y1(y1), swidth(swidth), sheight(sheight), rcp_swidth(1.0f/(swidth-1.0f)), rcp_sheight(1.0f/(sheight-1.0f)), 
121
        Px(Px), Py(Py), Pz(Pz), U(U), V(V), Nx(Nx), Ny(Ny), Nz(Nz), dwidth(dwidth), /*dheight(dheight),*/ count(0)
122
      {
123
        eval(patch,srange,erange,depth);
124
      }
125

126
      template<typename Patch>
127
      void evalLocalGrid(const Patch& patch, const BBox2f& srange, const int lx0, const int lx1, const int ly0, const int ly1)
128
      {
129
        const float scale_x = rcp(srange.upper.x-srange.lower.x);
130
        const float scale_y = rcp(srange.upper.y-srange.lower.y);
131
        count += (lx1-lx0)*(ly1-ly0);
132
        
133
#if 0
134
        for (unsigned iy=ly0; iy<ly1; iy++) {
135
          for (unsigned ix=lx0; ix<lx1; ix++) {
136
            const float lu = select(ix == swidth -1, float(1.0f), (float(ix)-srange.lower.x)*scale_x);
137
            const float lv = select(iy == sheight-1, float(1.0f), (float(iy)-srange.lower.y)*scale_y);
138
            const Vec3fa p = patch.eval(lu,lv);
139
            const float u = float(ix)*rcp_swidth;
140
            const float v = float(iy)*rcp_sheight;
141
            const int ofs = (iy-y0)*dwidth+(ix-x0);
142
            Px[ofs] = p.x;
143
            Py[ofs] = p.y;
144
            Pz[ofs] = p.z;
145
            U[ofs] = u;
146
            V[ofs] = v;
147
          }
148
        }
149
#else
150
        foreach2(lx0,lx1,ly0,ly1,[&](const vboolx& valid, const vintx& ix, const vintx& iy) {
151
            const vfloatx lu = select(ix == swidth -1, vfloatx(1.0f), (vfloatx(ix)-srange.lower.x)*scale_x);
152
            const vfloatx lv = select(iy == sheight-1, vfloatx(1.0f), (vfloatx(iy)-srange.lower.y)*scale_y);
153
            const Vec3vfx p = patch.eval(lu,lv);
154
            Vec3vfx n = zero;
155
            if (unlikely(Nx != nullptr)) n = normalize_safe(patch.normal(lu,lv));
156
            const vfloatx u = vfloatx(ix)*rcp_swidth;
157
            const vfloatx v = vfloatx(iy)*rcp_sheight;
158
            const vintx ofs = (iy-y0)*dwidth+(ix-x0);
159
            if (likely(all(valid)) && all(iy==iy[0])) {
160
              const unsigned ofs2 = ofs[0];
161
              vfloatx::storeu(Px+ofs2,p.x);
162
              vfloatx::storeu(Py+ofs2,p.y);
163
              vfloatx::storeu(Pz+ofs2,p.z);
164
              vfloatx::storeu(U+ofs2,u);
165
              vfloatx::storeu(V+ofs2,v);
166
              if (unlikely(Nx != nullptr)) {
167
                vfloatx::storeu(Nx+ofs2,n.x);
168
                vfloatx::storeu(Ny+ofs2,n.y);
169
                vfloatx::storeu(Nz+ofs2,n.z);
170
              }
171
            } else {
172
              foreach_unique_index(valid,iy,[&](const vboolx& valid, const int iy0, const int j) {
173
                  const unsigned ofs2 = ofs[j]-j;
174
                  vfloatx::storeu(valid,Px+ofs2,p.x);
175
                  vfloatx::storeu(valid,Py+ofs2,p.y);
176
                  vfloatx::storeu(valid,Pz+ofs2,p.z);
177
                  vfloatx::storeu(valid,U+ofs2,u);
178
                  vfloatx::storeu(valid,V+ofs2,v);
179
                  if (unlikely(Nx != nullptr)) {
180
                    vfloatx::storeu(valid,Nx+ofs2,n.x);
181
                    vfloatx::storeu(valid,Ny+ofs2,n.y);
182
                    vfloatx::storeu(valid,Nz+ofs2,n.z);
183
                  }
184
                });
185
            }
186
          });
187
#endif
188
      }
189
      
190
      __forceinline bool final(const CatmullClarkPatch3fa& patch, const CatmullClarkRing::Type type, unsigned depth) 
191
      {
192
        const unsigned max_eval_depth = (type & CatmullClarkRing::TYPE_CREASES) ? PATCH_MAX_EVAL_DEPTH_CREASE : PATCH_MAX_EVAL_DEPTH_IRREGULAR;
193
//#if PATCH_MIN_RESOLUTION
194
//        return patch.isFinalResolution(PATCH_MIN_RESOLUTION) || depth>=max_eval_depth;
195
//#else
196
        return depth>=max_eval_depth;
197
//#endif
198
      }
199
      
200
      void eval(const CatmullClarkPatch3fa& patch, const BBox2f& srange, const BBox2f& erange, const unsigned depth, 
201
                const BezierCurve3fa* border0 = nullptr, const BezierCurve3fa* border1 = nullptr, const BezierCurve3fa* border2 = nullptr, const BezierCurve3fa* border3 = nullptr)
202
      {
203
        if (erange.empty())
204
          return;
205
        
206
        int lx0 = (int) ceilf(erange.lower.x);
207
        int lx1 = (int) ceilf(erange.upper.x) + (erange.upper.x == x1 && (srange.lower.x < erange.upper.x || erange.upper.x == 0));
208
        int ly0 = (int) ceilf(erange.lower.y);
209
        int ly1 = (int) ceilf(erange.upper.y) + (erange.upper.y == y1 && (srange.lower.y < erange.upper.y || erange.upper.y == 0));
210
        if (lx0 >= lx1 || ly0 >= ly1) return;
211

212
        CatmullClarkPatch::Type ty = patch.type();
213

214
        if (unlikely(final(patch,ty,depth)))
215
        {
216
          if (ty & CatmullClarkRing::TYPE_REGULAR) {
217
            RegularPatch rpatch(patch,border0,border1,border2,border3);
218
            evalLocalGrid(rpatch,srange,lx0,lx1,ly0,ly1);
219
            return;
220
          } else {
221
            IrregularFillPatch ipatch(patch,border0,border1,border2,border3);
222
            evalLocalGrid(ipatch,srange,lx0,lx1,ly0,ly1);
223
            return;
224
          }
225
        }
226
        else if (ty & CatmullClarkRing::TYPE_REGULAR_CREASES) { 
227
          assert(depth > 0); 
228
          RegularPatch rpatch(patch,border0,border1,border2,border3);
229
          evalLocalGrid(rpatch,srange,lx0,lx1,ly0,ly1);
230
          return;
231
        }
232
#if PATCH_USE_GREGORY == 2
233
        else if (ty & CatmullClarkRing::TYPE_GREGORY_CREASES) { 
234
          assert(depth > 0); 
235
          GregoryPatch gpatch(patch,border0,border1,border2,border3);
236
          evalLocalGrid(gpatch,srange,lx0,lx1,ly0,ly1);
237
        }
238
#endif
239
        else
240
        {
241
          array_t<CatmullClarkPatch3fa,4> patches; 
242
          patch.subdivide(patches);
243
          
244
          const Vec2f c = srange.center();
245
          const BBox2f srange0(srange.lower,c);
246
          const BBox2f srange1(Vec2f(c.x,srange.lower.y),Vec2f(srange.upper.x,c.y));
247
          const BBox2f srange2(c,srange.upper);
248
          const BBox2f srange3(Vec2f(srange.lower.x,c.y),Vec2f(c.x,srange.upper.y));
249
          
250
          eval(patches[0],srange0,intersect(srange0,erange),depth+1);
251
          eval(patches[1],srange1,intersect(srange1,erange),depth+1);
252
          eval(patches[2],srange2,intersect(srange2,erange),depth+1);
253
          eval(patches[3],srange3,intersect(srange3,erange),depth+1);
254
        }
255
      }
256
    };
257
    
258
    template<typename Eval, typename Patch>
259
      bool stitch_col(const Patch& patch, int subPatch,
260
                      const bool right, const unsigned y0, const unsigned y1, const int fine_y, const int coarse_y, 
261
                      float* Px, float* Py, float* Pz, float* U, float* V, float* Nx, float* Ny, float* Nz, const unsigned dx0, const unsigned dwidth, const unsigned dheight)
262
    {
263
      assert(coarse_y <= fine_y);
264
      if (likely(fine_y == coarse_y))
265
        return false;
266
      
267
      const unsigned y0s = stitch(y0,fine_y,coarse_y);
268
      const unsigned y1s = stitch(y1,fine_y,coarse_y);
269
      const unsigned M = y1s-y0s+1 + VSIZEX;
270
      
271
      dynamic_large_stack_array(float,px,M,64*sizeof(float));
272
      dynamic_large_stack_array(float,py,M,64*sizeof(float));
273
      dynamic_large_stack_array(float,pz,M,64*sizeof(float));
274
      dynamic_large_stack_array(float,u,M,64*sizeof(float));
275
      dynamic_large_stack_array(float,v,M,64*sizeof(float));
276
      dynamic_large_stack_array(float,nx,M,64*sizeof(float));
277
      dynamic_large_stack_array(float,ny,M,64*sizeof(float));
278
      dynamic_large_stack_array(float,nz,M,64*sizeof(float));
279
      const bool has_Nxyz = Nx; assert(!Nx || (Ny && Nz));
280
      Eval(patch,subPatch, right,right, y0s,y1s, 2,coarse_y+1, px,py,pz,u,v, 
281
           has_Nxyz ? (float*)nx : nullptr,has_Nxyz ? (float*)ny : nullptr ,has_Nxyz ? (float*)nz : nullptr, 1,4097);
282
      
283
      for (unsigned y=y0; y<=y1; y++) 
284
      {
285
        const unsigned ys = stitch(y,fine_y,coarse_y)-y0s;
286
        Px[(y-y0)*dwidth+dx0] = px[ys];
287
        Py[(y-y0)*dwidth+dx0] = py[ys];
288
        Pz[(y-y0)*dwidth+dx0] = pz[ys];
289
        U [(y-y0)*dwidth+dx0] = u[ys];
290
        V [(y-y0)*dwidth+dx0] = v[ys];
291
        if (unlikely(has_Nxyz)) {
292
          Nx[(y-y0)*dwidth+dx0] = nx[ys];
293
          Ny[(y-y0)*dwidth+dx0] = ny[ys];
294
          Nz[(y-y0)*dwidth+dx0] = nz[ys];
295
        }
296
      }
297
      return true;
298
    }
299
    
300
    template<typename Eval, typename Patch>
301
      bool stitch_row(const Patch& patch, int subPatch, 
302
                      const bool bottom, const unsigned x0, const unsigned x1, const int fine_x, const int coarse_x, 
303
                      float* Px, float* Py, float* Pz, float* U, float* V, float* Nx, float* Ny, float* Nz, const unsigned dy0, const unsigned dwidth, const unsigned dheight)
304
    {
305
      assert(coarse_x <= fine_x);
306
      if (likely(fine_x == coarse_x))
307
	return false;
308
      
309
      const unsigned x0s = stitch(x0,fine_x,coarse_x);
310
      const unsigned x1s = stitch(x1,fine_x,coarse_x);
311
      const unsigned M = x1s-x0s+1 + VSIZEX;
312

313
      dynamic_large_stack_array(float,px,M,32*sizeof(float));
314
      dynamic_large_stack_array(float,py,M,32*sizeof(float));
315
      dynamic_large_stack_array(float,pz,M,32*sizeof(float));
316
      dynamic_large_stack_array(float,u,M,32*sizeof(float));
317
      dynamic_large_stack_array(float,v,M,32*sizeof(float));
318
      dynamic_large_stack_array(float,nx,M,32*sizeof(float));
319
      dynamic_large_stack_array(float,ny,M,32*sizeof(float));
320
      dynamic_large_stack_array(float,nz,M,32*sizeof(float));
321
      const bool has_Nxyz = Nx; assert(!Nx || (Ny && Nz));
322
      Eval(patch,subPatch, x0s,x1s, bottom,bottom, coarse_x+1,2, px,py,pz,u,v, 
323
           has_Nxyz ? (float*)nx :nullptr, has_Nxyz ? (float*)ny : nullptr , has_Nxyz ? (float*)nz : nullptr, 4097,1);
324
      
325
      for (unsigned x=x0; x<=x1; x++) 
326
      {
327
	const unsigned xs = stitch(x,fine_x,coarse_x)-x0s;
328
	Px[dy0*dwidth+x-x0] = px[xs];
329
        Py[dy0*dwidth+x-x0] = py[xs];
330
        Pz[dy0*dwidth+x-x0] = pz[xs];
331
        U [dy0*dwidth+x-x0] = u[xs];
332
        V [dy0*dwidth+x-x0] = v[xs];
333
        if (unlikely(has_Nxyz)) {
334
          Nx[dy0*dwidth+x-x0] = nx[xs];
335
          Ny[dy0*dwidth+x-x0] = ny[xs];
336
          Nz[dy0*dwidth+x-x0] = nz[xs];
337
        }
338
      }
339
      return true;
340
    }
341
    
342
    template<typename Eval, typename Patch>
343
    void feature_adaptive_eval_grid (const Patch& patch, unsigned subPatch, const float levels[4],
344
                                     const unsigned x0, const unsigned x1, const unsigned y0, const unsigned y1, const unsigned swidth, const unsigned sheight, 
345
                                     float* Px, float* Py, float* Pz, float* U, float* V, float* Nx, float* Ny, float* Nz, const unsigned dwidth, const unsigned dheight)
346
    {
347
      bool sl = false, sr = false, st = false, sb = false;
348
      if (levels) {
349
        sl = x0 == 0         && stitch_col<Eval,Patch>(patch,subPatch,0,y0,y1,sheight-1,int(levels[3]), Px,Py,Pz,U,V,Nx,Ny,Nz, 0    ,dwidth,dheight);
350
        sr = x1 == swidth-1  && stitch_col<Eval,Patch>(patch,subPatch,1,y0,y1,sheight-1,int(levels[1]), Px,Py,Pz,U,V,Nx,Ny,Nz, x1-x0,dwidth,dheight);
351
        st = y0 == 0         && stitch_row<Eval,Patch>(patch,subPatch,0,x0,x1,swidth-1,int(levels[0]), Px,Py,Pz,U,V,Nx,Ny,Nz, 0    ,dwidth,dheight);
352
        sb = y1 == sheight-1 && stitch_row<Eval,Patch>(patch,subPatch,1,x0,x1,swidth-1,int(levels[2]), Px,Py,Pz,U,V,Nx,Ny,Nz, y1-y0,dwidth,dheight);
353
      }
354
      const unsigned ofs = st*dwidth+sl;
355
      Eval(patch,subPatch,x0+sl,x1-sr,y0+st,y1-sb, swidth,sheight, Px+ofs,Py+ofs,Pz+ofs,U+ofs,V+ofs,Nx?Nx+ofs:nullptr,Ny?Ny+ofs:nullptr,Nz?Nz+ofs:nullptr, dwidth,dheight);
356
    }
357
  }
358
}
359

360

361
Product

Resources

Company
