void LineSegments::interpolate(unsigned primID, float u, float v, RTCBufferType buffer, float* P, float* dPdu, float* dPdv, float* ddPdudu, float* ddPdvdv, float* ddPdudv, size_t numFloats)
{
/* test if interpolation is enabled */
#if defined(DEBUG)
if ((parent->aflags & RTC_INTERPOLATE) == 0)
throw_RTCError(RTC_INVALID_OPERATION,"rtcInterpolate can only get called when RTC_INTERPOLATE is enabled for the scene");
#endif
/* calculate base pointer and stride */
assert((buffer >= RTC_VERTEX_BUFFER0 && buffer < RTCBufferType(RTC_VERTEX_BUFFER0 + numTimeSteps)) ||
(buffer >= RTC_USER_VERTEX_BUFFER0 && buffer <= RTC_USER_VERTEX_BUFFER1));
const char* src = nullptr;
size_t stride = 0;
if (buffer >= RTC_USER_VERTEX_BUFFER0) {
src = userbuffers[buffer&0xFFFF]->getPtr();
stride = userbuffers[buffer&0xFFFF]->getStride();
} else {
src = vertices[buffer&0xFFFF].getPtr();
stride = vertices[buffer&0xFFFF].getStride();
}
for (size_t i=0; i<numFloats; i+=VSIZEX)
{
const size_t ofs = i*sizeof(float);
const size_t segment = segments[primID];
const vboolx valid = vintx((int)i)+vintx(step) < vintx(numFloats);
const vfloatx p0 = vfloatx::loadu(valid,(float*)&src[(segment+0)*stride+ofs]);
const vfloatx p1 = vfloatx::loadu(valid,(float*)&src[(segment+1)*stride+ofs]);
if (P ) vfloatx::storeu(valid,P+i,(1.0f-u)*p0 + u*p1);
if (dPdu ) vfloatx::storeu(valid,dPdu+i,p1-p0);
if (ddPdudu) vfloatx::storeu(valid,dPdu+i,vfloatx(zero));
}
}
void QuadMesh::interpolate(unsigned primID, float u, float v, RTCBufferType buffer, float* P, float* dPdu, float* dPdv, float* ddPdudu, float* ddPdvdv, float* ddPdudv, size_t numFloats)
{
/* test if interpolation is enabled */
#if defined(DEBUG)
if ((scene->aflags & RTC_INTERPOLATE) == 0)
throw_RTCError(RTC_INVALID_OPERATION,"rtcInterpolate can only get called when RTC_INTERPOLATE is enabled for the scene");
#endif
/* calculate base pointer and stride */
assert((buffer >= RTC_VERTEX_BUFFER0 && buffer < RTCBufferType(RTC_VERTEX_BUFFER0 + numTimeSteps)) ||
(buffer >= RTC_USER_VERTEX_BUFFER0 && buffer <= RTC_USER_VERTEX_BUFFER1));
const char* src = nullptr;
size_t stride = 0;
if (buffer >= RTC_USER_VERTEX_BUFFER0) {
src = userbuffers[buffer&0xFFFF].getPtr();
stride = userbuffers[buffer&0xFFFF].getStride();
} else {
src = vertices[buffer&0xFFFF].getPtr();
stride = vertices[buffer&0xFFFF].getStride();
}
for (size_t i=0; i<numFloats; i+=VSIZEX)
{
const vboolx valid = vintx((int)i)+vintx(step) < vintx(int(numFloats));
const size_t ofs = i*sizeof(float);
const Quad& tri = quad(primID);
const vfloatx p0 = vfloatx::loadu(valid,(float*)&src[tri.v[0]*stride+ofs]);
const vfloatx p1 = vfloatx::loadu(valid,(float*)&src[tri.v[1]*stride+ofs]);
const vfloatx p2 = vfloatx::loadu(valid,(float*)&src[tri.v[2]*stride+ofs]);
const vfloatx p3 = vfloatx::loadu(valid,(float*)&src[tri.v[3]*stride+ofs]);
const vboolx left = u+v <= 1.0f;
const vfloatx Q0 = select(left,p0,p2);
const vfloatx Q1 = select(left,p1,p3);
const vfloatx Q2 = select(left,p3,p1);
const vfloatx U = select(left,u,vfloatx(1.0f)-u);
const vfloatx V = select(left,v,vfloatx(1.0f)-v);
const vfloatx W = 1.0f-U-V;
if (P) {
vfloatx::storeu(valid,P+i,madd(W,Q0,madd(U,Q1,V*Q2)));
}
if (dPdu) {
assert(dPdu); vfloatx::storeu(valid,dPdu+i,select(left,Q1-Q0,Q0-Q1));
assert(dPdv); vfloatx::storeu(valid,dPdv+i,select(left,Q2-Q0,Q0-Q2));
}
if (ddPdudu) {
assert(ddPdudu); vfloatx::storeu(valid,ddPdudu+i,vfloatx(zero));
assert(ddPdvdv); vfloatx::storeu(valid,ddPdvdv+i,vfloatx(zero));
assert(ddPdudv); vfloatx::storeu(valid,ddPdudv+i,vfloatx(zero));
}
}
}
void TriangleMesh::interpolate(unsigned primID, float u, float v, RTCBufferType buffer, float* P, float* dPdu, float* dPdv, float* ddPdudu, float* ddPdvdv, float* ddPdudv, size_t numFloats)
{
/* test if interpolation is enabled */
#if defined(DEBUG)
if ((parent->aflags & RTC_INTERPOLATE) == 0)
throw_RTCError(RTC_INVALID_OPERATION,"rtcInterpolate can only get called when RTC_INTERPOLATE is enabled for the scene");
#endif
/* calculate base pointer and stride */
assert((buffer >= RTC_VERTEX_BUFFER0 && buffer <= RTC_VERTEX_BUFFER1) ||
(buffer >= RTC_USER_VERTEX_BUFFER0 && buffer <= RTC_USER_VERTEX_BUFFER1));
const char* src = nullptr;
size_t stride = 0;
if (buffer >= RTC_USER_VERTEX_BUFFER0) {
src = userbuffers[buffer&0xFFFF]->getPtr();
stride = userbuffers[buffer&0xFFFF]->getStride();
} else {
src = vertices[buffer&0xFFFF].getPtr();
stride = vertices[buffer&0xFFFF].getStride();
}
for (size_t i=0; i<numFloats; i+=VSIZEX)
{
size_t ofs = i*sizeof(float);
const float w = 1.0f-u-v;
const Triangle& tri = triangle(primID);
const vboolx valid = vintx(i)+vintx(step) < vintx(numFloats);
const vfloatx p0 = vfloatx::loadu(valid,(float*)&src[tri.v[0]*stride+ofs]);
const vfloatx p1 = vfloatx::loadu(valid,(float*)&src[tri.v[1]*stride+ofs]);
const vfloatx p2 = vfloatx::loadu(valid,(float*)&src[tri.v[2]*stride+ofs]);
if (P) {
vfloatx::storeu(valid,P+i,w*p0 + u*p1 + v*p2);
}
if (dPdu) {
assert(dPdu); vfloatx::storeu(valid,dPdu+i,p1-p0);
assert(dPdv); vfloatx::storeu(valid,dPdv+i,p2-p0);
}
if (ddPdudu) {
assert(ddPdudu); vfloatx::storeu(valid,ddPdudu+i,vfloatx(zero));
assert(ddPdvdv); vfloatx::storeu(valid,ddPdvdv+i,vfloatx(zero));
assert(ddPdudv); vfloatx::storeu(valid,ddPdudv+i,vfloatx(zero));
}
}
}
__forceinline void NativeCurvesISA::interpolate_helper(unsigned primID, float u, float v, RTCBufferType buffer,
float* P, float* dPdu, float* dPdv, float* ddPdudu, float* ddPdvdv, float* ddPdudv, size_t numFloats)
{
/* test if interpolation is enabled */
#if defined(DEBUG)
if ((scene->aflags & RTC_INTERPOLATE) == 0)
throw_RTCError(RTC_INVALID_OPERATION,"rtcInterpolate can only get called when RTC_INTERPOLATE is enabled for the scene");
#endif
/* calculate base pointer and stride */
assert((buffer >= RTC_VERTEX_BUFFER0 && buffer < RTCBufferType(RTC_VERTEX_BUFFER0 + numTimeSteps)) ||
(buffer >= RTC_USER_VERTEX_BUFFER0 && buffer <= RTC_USER_VERTEX_BUFFER1));
const char* src = nullptr;
size_t stride = 0;
if (buffer >= RTC_USER_VERTEX_BUFFER0) {
src = userbuffers[buffer&0xFFFF].getPtr();
stride = userbuffers[buffer&0xFFFF].getStride();
} else {
src = vertices[buffer&0xFFFF].getPtr();
stride = vertices[buffer&0xFFFF].getStride();
}
for (size_t i=0; i<numFloats; i+=VSIZEX)
{
size_t ofs = i*sizeof(float);
const size_t curve = curves[primID];
const vboolx valid = vintx((int)i)+vintx(step) < vintx((int)numFloats);
const vfloatx p0 = vfloatx::loadu(valid,(float*)&src[(curve+0)*stride+ofs]);
const vfloatx p1 = vfloatx::loadu(valid,(float*)&src[(curve+1)*stride+ofs]);
const vfloatx p2 = vfloatx::loadu(valid,(float*)&src[(curve+2)*stride+ofs]);
const vfloatx p3 = vfloatx::loadu(valid,(float*)&src[(curve+3)*stride+ofs]);
const Curve bezier(p0,p1,p2,p3);
if (P ) vfloatx::storeu(valid,P+i, bezier.eval(u));
if (dPdu ) vfloatx::storeu(valid,dPdu+i, bezier.eval_du(u));
if (ddPdudu) vfloatx::storeu(valid,ddPdudu+i,bezier.eval_dudu(u));
}
}
{
const vintx vi = vintx(int(j)) + vintx(step);
const vboolx valid = vi < vintx(int(numOctantRays));
const vintx offset = *(vintx*)&rayIDs[j] * int(stride);
rayN.setHitByOffset(valid, offset, rays[j/VSIZEX], intersect);
}
raysInOctant[curOctant] = 0;
}
}
else
{
/* fallback to packets */
for (size_t i = 0; i < N; i += VSIZEX)
{
const vintx vi = vintx(int(i)) + vintx(step);
vboolx valid = vi < vintx(int(N));
const vintx offset = vi * int(stride);
RayK<VSIZEX> ray = rayN.getRayByOffset(valid, offset);
valid &= ray.tnear <= ray.tfar;
if (intersect)
scene->intersectors.intersect(valid, ray, context);
else
scene->intersectors.occluded(valid, ray, context);
rayN.setHitByOffset(valid, offset, ray, intersect);
}
}
}
