246 lines
9.6 KiB
C++
246 lines
9.6 KiB
C++
// Copyright 2009-2020 Intel Corporation
|
|
// SPDX-License-Identifier: Apache-2.0
|
|
|
|
#pragma once
|
|
|
|
#include "patch.h"
|
|
#include "feature_adaptive_eval_grid.h"
|
|
|
|
namespace embree
|
|
{
|
|
namespace isa
|
|
{
|
|
struct PatchEvalGrid
|
|
{
|
|
typedef Patch3fa Patch;
|
|
typedef Patch::Ref Ref;
|
|
typedef GeneralCatmullClarkPatch3fa GeneralCatmullClarkPatch;
|
|
typedef CatmullClarkPatch3fa CatmullClarkPatch;
|
|
typedef BSplinePatch3fa BSplinePatch;
|
|
typedef BezierPatch3fa BezierPatch;
|
|
typedef GregoryPatch3fa GregoryPatch;
|
|
typedef BilinearPatch3fa BilinearPatch;
|
|
|
|
private:
|
|
const unsigned x0,x1;
|
|
const unsigned y0,y1;
|
|
const unsigned swidth,sheight;
|
|
const float rcp_swidth, rcp_sheight;
|
|
float* const Px;
|
|
float* const Py;
|
|
float* const Pz;
|
|
float* const U;
|
|
float* const V;
|
|
float* const Nx;
|
|
float* const Ny;
|
|
float* const Nz;
|
|
const unsigned dwidth,dheight;
|
|
unsigned count;
|
|
|
|
public:
|
|
|
|
PatchEvalGrid (Ref patch, unsigned subPatch,
|
|
const unsigned x0, const unsigned x1, const unsigned y0, const unsigned y1, const unsigned swidth, const unsigned sheight,
|
|
float* Px, float* Py, float* Pz, float* U, float* V,
|
|
float* Nx, float* Ny, float* Nz,
|
|
const unsigned dwidth, const unsigned dheight)
|
|
: 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)),
|
|
Px(Px), Py(Py), Pz(Pz), U(U), V(V), Nx(Nx), Ny(Ny), Nz(Nz), dwidth(dwidth), dheight(dheight), count(0)
|
|
{
|
|
assert(swidth < (2<<20) && sheight < (2<<20));
|
|
const BBox2f srange(Vec2f(0.0f,0.0f),Vec2f(float(swidth-1),float(sheight-1)));
|
|
const BBox2f erange(Vec2f(float(x0),float(y0)),Vec2f((float)x1,(float)y1));
|
|
bool done MAYBE_UNUSED = eval(patch,subPatch,srange,erange);
|
|
assert(done);
|
|
assert(count == (x1-x0+1)*(y1-y0+1));
|
|
}
|
|
|
|
template<typename Patch>
|
|
__forceinline void evalLocalGrid(const Patch* patch, const BBox2f& srange, const int lx0, const int lx1, const int ly0, const int ly1)
|
|
{
|
|
const float scale_x = rcp(srange.upper.x-srange.lower.x);
|
|
const float scale_y = rcp(srange.upper.y-srange.lower.y);
|
|
count += (lx1-lx0)*(ly1-ly0);
|
|
|
|
#if 0
|
|
for (unsigned iy=ly0; iy<ly1; iy++) {
|
|
for (unsigned ix=lx0; ix<lx1; ix++) {
|
|
const float lu = select(ix == swidth -1, float(1.0f), (float(ix)-srange.lower.x)*scale_x);
|
|
const float lv = select(iy == sheight-1, float(1.0f), (float(iy)-srange.lower.y)*scale_y);
|
|
const Vec3fa p = patch->patch.eval(lu,lv);
|
|
const float u = float(ix)*rcp_swidth;
|
|
const float v = float(iy)*rcp_sheight;
|
|
const int ofs = (iy-y0)*dwidth+(ix-x0);
|
|
Px[ofs] = p.x;
|
|
Py[ofs] = p.y;
|
|
Pz[ofs] = p.z;
|
|
U[ofs] = u;
|
|
V[ofs] = v;
|
|
}
|
|
}
|
|
#else
|
|
foreach2(lx0,lx1,ly0,ly1,[&](const vboolx& valid, const vintx& ix, const vintx& iy) {
|
|
const vfloatx lu = select(ix == swidth -1, vfloatx(1.0f), (vfloatx(ix)-srange.lower.x)*scale_x);
|
|
const vfloatx lv = select(iy == sheight-1, vfloatx(1.0f), (vfloatx(iy)-srange.lower.y)*scale_y);
|
|
const Vec3vfx p = patch->patch.eval(lu,lv);
|
|
Vec3vfx n = zero;
|
|
if (unlikely(Nx != nullptr)) n = normalize_safe(patch->patch.normal(lu,lv));
|
|
const vfloatx u = vfloatx(ix)*rcp_swidth;
|
|
const vfloatx v = vfloatx(iy)*rcp_sheight;
|
|
const vintx ofs = (iy-y0)*dwidth+(ix-x0);
|
|
if (likely(all(valid)) && all(iy==iy[0])) {
|
|
const unsigned ofs2 = ofs[0];
|
|
vfloatx::storeu(Px+ofs2,p.x);
|
|
vfloatx::storeu(Py+ofs2,p.y);
|
|
vfloatx::storeu(Pz+ofs2,p.z);
|
|
vfloatx::storeu(U+ofs2,u);
|
|
vfloatx::storeu(V+ofs2,v);
|
|
if (unlikely(Nx != nullptr)) {
|
|
vfloatx::storeu(Nx+ofs2,n.x);
|
|
vfloatx::storeu(Ny+ofs2,n.y);
|
|
vfloatx::storeu(Nz+ofs2,n.z);
|
|
}
|
|
} else {
|
|
foreach_unique_index(valid,iy,[&](const vboolx& valid, const int iy0, const int j) {
|
|
const unsigned ofs2 = ofs[j]-j;
|
|
vfloatx::storeu(valid,Px+ofs2,p.x);
|
|
vfloatx::storeu(valid,Py+ofs2,p.y);
|
|
vfloatx::storeu(valid,Pz+ofs2,p.z);
|
|
vfloatx::storeu(valid,U+ofs2,u);
|
|
vfloatx::storeu(valid,V+ofs2,v);
|
|
if (unlikely(Nx != nullptr)) {
|
|
vfloatx::storeu(valid,Nx+ofs2,n.x);
|
|
vfloatx::storeu(valid,Ny+ofs2,n.y);
|
|
vfloatx::storeu(valid,Nz+ofs2,n.z);
|
|
}
|
|
});
|
|
}
|
|
});
|
|
#endif
|
|
}
|
|
|
|
bool eval(Ref This, const BBox2f& srange, const BBox2f& erange, const unsigned depth)
|
|
{
|
|
if (erange.empty())
|
|
return true;
|
|
|
|
const int lx0 = (int) ceilf(erange.lower.x);
|
|
const int lx1 = (int) ceilf(erange.upper.x) + (erange.upper.x == x1 && (srange.lower.x < erange.upper.x || erange.upper.x == 0));
|
|
const int ly0 = (int) ceilf(erange.lower.y);
|
|
const int ly1 = (int) ceilf(erange.upper.y) + (erange.upper.y == y1 && (srange.lower.y < erange.upper.y || erange.upper.y == 0));
|
|
if (lx0 >= lx1 || ly0 >= ly1)
|
|
return true;
|
|
|
|
if (!This)
|
|
return false;
|
|
|
|
switch (This.type())
|
|
{
|
|
case Patch::BILINEAR_PATCH: {
|
|
evalLocalGrid((Patch::BilinearPatch*)This.object(),srange,lx0,lx1,ly0,ly1);
|
|
return true;
|
|
}
|
|
case Patch::BSPLINE_PATCH: {
|
|
evalLocalGrid((Patch::BSplinePatch*)This.object(),srange,lx0,lx1,ly0,ly1);
|
|
return true;
|
|
}
|
|
case Patch::BEZIER_PATCH: {
|
|
evalLocalGrid((Patch::BezierPatch*)This.object(),srange,lx0,lx1,ly0,ly1);
|
|
return true;
|
|
}
|
|
case Patch::GREGORY_PATCH: {
|
|
evalLocalGrid((Patch::GregoryPatch*)This.object(),srange,lx0,lx1,ly0,ly1);
|
|
return true;
|
|
}
|
|
case Patch::SUBDIVIDED_QUAD_PATCH:
|
|
{
|
|
const Vec2f c = srange.center();
|
|
const BBox2f srange0(srange.lower,c);
|
|
const BBox2f srange1(Vec2f(c.x,srange.lower.y),Vec2f(srange.upper.x,c.y));
|
|
const BBox2f srange2(c,srange.upper);
|
|
const BBox2f srange3(Vec2f(srange.lower.x,c.y),Vec2f(c.x,srange.upper.y));
|
|
|
|
Patch::SubdividedQuadPatch* patch = (Patch::SubdividedQuadPatch*)This.object();
|
|
eval(patch->child[0],srange0,intersect(srange0,erange),depth+1);
|
|
eval(patch->child[1],srange1,intersect(srange1,erange),depth+1);
|
|
eval(patch->child[2],srange2,intersect(srange2,erange),depth+1);
|
|
eval(patch->child[3],srange3,intersect(srange3,erange),depth+1);
|
|
return true;
|
|
}
|
|
case Patch::EVAL_PATCH: {
|
|
CatmullClarkPatch patch; patch.deserialize(This.object());
|
|
FeatureAdaptiveEvalGrid(patch,srange,erange,depth,x0,x1,y0,y1,swidth,sheight,Px,Py,Pz,U,V,Nx,Ny,Nz,dwidth,dheight);
|
|
count += (lx1-lx0)*(ly1-ly0);
|
|
return true;
|
|
}
|
|
default:
|
|
assert(false);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
bool eval(Ref This, unsigned subPatch, const BBox2f& srange, const BBox2f& erange)
|
|
{
|
|
if (!This)
|
|
return false;
|
|
|
|
switch (This.type())
|
|
{
|
|
case Patch::SUBDIVIDED_GENERAL_PATCH: {
|
|
Patch::SubdividedGeneralPatch* patch = (Patch::SubdividedGeneralPatch*)This.object();
|
|
assert(subPatch < patch->N);
|
|
return eval(patch->child[subPatch],srange,erange,1);
|
|
}
|
|
default:
|
|
assert(subPatch == 0);
|
|
return eval(This,srange,erange,0);
|
|
}
|
|
}
|
|
};
|
|
|
|
__forceinline unsigned patch_eval_subdivision_count (const HalfEdge* h)
|
|
{
|
|
const unsigned N = h->numEdges();
|
|
if (N == 4) return 1;
|
|
else return N;
|
|
}
|
|
|
|
template<typename Tessellator>
|
|
inline void patch_eval_subdivision (const HalfEdge* h, Tessellator tessellator)
|
|
{
|
|
const unsigned N = h->numEdges();
|
|
int neighborSubdiv[GeneralCatmullClarkPatch3fa::SIZE]; // FIXME: use array_t
|
|
float levels[GeneralCatmullClarkPatch3fa::SIZE];
|
|
for (unsigned i=0; i<N; i++) {
|
|
assert(i<GeneralCatmullClarkPatch3fa::SIZE);
|
|
neighborSubdiv[i] = h->hasOpposite() ? h->opposite()->numEdges() != 4 : 0;
|
|
levels[i] = h->edge_level;
|
|
h = h->next();
|
|
}
|
|
if (N == 4)
|
|
{
|
|
const Vec2f uv[4] = { Vec2f(0.0f,0.0f), Vec2f(1.0f,0.0f), Vec2f(1.0f,1.0f), Vec2f(0.0f,1.0f) };
|
|
tessellator(uv,neighborSubdiv,levels,0);
|
|
}
|
|
else
|
|
{
|
|
for (unsigned i=0; i<N; i++)
|
|
{
|
|
assert(i<MAX_PATCH_VALENCE);
|
|
static_assert(MAX_PATCH_VALENCE <= 16, "MAX_PATCH_VALENCE > 16");
|
|
const int h = (i >> 2) & 3, l = i & 3;
|
|
const Vec2f subPatchID((float)l,(float)h);
|
|
const Vec2f uv[4] = { 2.0f*subPatchID + (0.5f+Vec2f(0.0f,0.0f)),
|
|
2.0f*subPatchID + (0.5f+Vec2f(1.0f,0.0f)),
|
|
2.0f*subPatchID + (0.5f+Vec2f(1.0f,1.0f)),
|
|
2.0f*subPatchID + (0.5f+Vec2f(0.0f,1.0f)) };
|
|
const int neighborSubdiv1[4] = { 0,0,0,0 };
|
|
const float levels1[4] = { 0.5f*levels[(i+0)%N], 0.5f*levels[(i+0)%N], 0.5f*levels[(i+N-1)%N], 0.5f*levels[(i+N-1)%N] };
|
|
tessellator(uv,neighborSubdiv1,levels1,i);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|