void NativeCurves::setBuffer(RTCBufferType type, void* ptr, size_t offset, size_t stride, size_t size)
{
if (scene->isStatic() && scene->isBuild())
throw_RTCError(RTC_INVALID_OPERATION,"static geometries cannot get modified");
/* verify that all accesses are 4 bytes aligned */
if (((size_t(ptr) + offset) & 0x3) || (stride & 0x3))
throw_RTCError(RTC_INVALID_OPERATION,"data must be 4 bytes aligned");
unsigned bid = type & 0xFFFF;
if (type >= RTC_VERTEX_BUFFER0 && type < RTCBufferType(RTC_VERTEX_BUFFER0 + numTimeSteps))
{
size_t t = type - RTC_VERTEX_BUFFER0;
vertices[t].set(ptr,offset,stride,size);
vertices[t].checkPadding16();
}
else if (type >= RTC_USER_VERTEX_BUFFER0 && type < RTC_USER_VERTEX_BUFFER0+RTC_MAX_USER_VERTEX_BUFFERS)
{
if (bid >= userbuffers.size()) userbuffers.resize(bid+1);
userbuffers[bid] = APIBuffer<char>(scene->device,numVertices(),stride);
userbuffers[bid].set(ptr,offset,stride,size);
userbuffers[bid].checkPadding16();
}
else if (type == RTC_INDEX_BUFFER)
{
if (isEnabled() && size != (size_t)-1) disabling();
curves.set(ptr,offset,stride,size);
setNumPrimitives(size);
if (isEnabled() && size != (size_t)-1) enabling();
}
else
throw_RTCError(RTC_INVALID_ARGUMENT,"unknown buffer type");
}
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 NativeCurves::unmap(RTCBufferType type)
{
if (scene->isStatic() && scene->isBuild())
throw_RTCError(RTC_INVALID_OPERATION,"static geometries cannot get modified");
if (type == RTC_INDEX_BUFFER) {
curves.unmap(scene->numMappedBuffers);
}
else if (type >= RTC_VERTEX_BUFFER0 && type < RTCBufferType(RTC_VERTEX_BUFFER0 + numTimeSteps)) {
vertices[type - RTC_VERTEX_BUFFER0].unmap(scene->numMappedBuffers);
}
else {
throw_RTCError(RTC_INVALID_ARGUMENT,"unknown buffer type");
}
}
void* QuadMesh::map(RTCBufferType type)
{
if (scene->isStatic() && scene->isBuild())
throw_RTCError(RTC_INVALID_OPERATION,"static scenes cannot get modified");
if (type == RTC_INDEX_BUFFER) {
return quads.map(scene->numMappedBuffers);
}
else if (type >= RTC_VERTEX_BUFFER0 && type < RTCBufferType(RTC_VERTEX_BUFFER0 + numTimeSteps)) {
return vertices[type - RTC_VERTEX_BUFFER0].map(scene->numMappedBuffers);
}
else {
throw_RTCError(RTC_INVALID_ARGUMENT,"unknown buffer type");
return nullptr;
}
}
void TriangleMesh::unmap(RTCBufferType type)
{
if (parent->isStatic() && parent->isBuild())
throw_RTCError(RTC_INVALID_OPERATION,"static scenes cannot get modified");
if (type == RTC_INDEX_BUFFER) {
triangles.unmap(parent->numMappedBuffers);
}
else if (type >= RTC_VERTEX_BUFFER0 && type < RTCBufferType(RTC_VERTEX_BUFFER0 + numTimeSteps)) {
vertices[type - RTC_VERTEX_BUFFER0].unmap(parent->numMappedBuffers);
vertices0 = vertices[0];
}
else {
throw_RTCError(RTC_INVALID_ARGUMENT,"unknown buffer type");
}
}
void* LineSegments::map(RTCBufferType type)
{
if (parent->isStatic() && parent->isBuild()) {
throw_RTCError(RTC_INVALID_OPERATION,"static geometries cannot get modified");
return nullptr;
}
if (type == RTC_INDEX_BUFFER) {
return segments.map(parent->numMappedBuffers);
}
else if (type >= RTC_VERTEX_BUFFER0 && type < RTCBufferType(RTC_VERTEX_BUFFER0 + numTimeSteps)) {
return vertices[type - RTC_VERTEX_BUFFER0].map(parent->numMappedBuffers);
}
else {
throw_RTCError(RTC_INVALID_ARGUMENT,"unknown buffer type");
return nullptr;
}
}
void QuadMesh::setBuffer(RTCBufferType type, void* ptr, size_t offset, size_t stride, size_t size)
{
if (scene->isStatic() && scene->isBuild())
throw_RTCError(RTC_INVALID_OPERATION,"static scenes cannot get modified");
/* verify that all accesses are 4 bytes aligned */
if (((size_t(ptr) + offset) & 0x3) || (stride & 0x3))
throw_RTCError(RTC_INVALID_OPERATION,"data must be 4 bytes aligned");
unsigned bid = type & 0xFFFF;
if (type >= RTC_VERTEX_BUFFER0 && type < RTCBufferType(RTC_VERTEX_BUFFER0 + numTimeSteps))
{
size_t t = type - RTC_VERTEX_BUFFER0;
if (size == -1) size = vertices[t].size();
/* if buffer is larger than 16GB the premultiplied index optimization does not work */
if (stride*size > 16ll*1024ll*1024ll*1024ll)
throw_RTCError(RTC_INVALID_OPERATION,"vertex buffer can be at most 16GB large");
vertices[t].set(ptr,offset,stride,size);
vertices[t].checkPadding16();
vertices0 = vertices[0];
}
else if (type >= RTC_USER_VERTEX_BUFFER0 && type < RTC_USER_VERTEX_BUFFER0+RTC_MAX_USER_VERTEX_BUFFERS)
{
if (bid >= userbuffers.size()) userbuffers.resize(bid+1);
userbuffers[bid] = APIBuffer<char>(scene->device,numVertices(),stride);
userbuffers[bid].set(ptr,offset,stride,size);
userbuffers[bid].checkPadding16();
}
else if (type == RTC_INDEX_BUFFER)
{
if (size != (size_t)-1) disabling();
quads.set(ptr,offset,stride,size);
setNumPrimitives(size);
if (size != (size_t)-1) enabling();
}
else
throw_RTCError(RTC_INVALID_ARGUMENT,"unknown buffer type");
}
void TriangleMesh::setBuffer(RTCBufferType type, void* ptr, size_t offset, size_t stride)
{
if (parent->isStatic() && parent->isBuild())
throw_RTCError(RTC_INVALID_OPERATION,"static scenes cannot get modified");
/* verify that all accesses are 4 bytes aligned */
if (((size_t(ptr) + offset) & 0x3) || (stride & 0x3))
throw_RTCError(RTC_INVALID_OPERATION,"data must be 4 bytes aligned");
if (type >= RTC_VERTEX_BUFFER0 && type < RTCBufferType(RTC_VERTEX_BUFFER0 + numTimeSteps))
{
size_t t = type - RTC_VERTEX_BUFFER0;
vertices[t].set(ptr,offset,stride);
vertices[t].checkPadding16();
vertices0 = vertices[0];
}
else
{
switch (type) {
case RTC_INDEX_BUFFER :
triangles.set(ptr,offset,stride);
break;
case RTC_USER_VERTEX_BUFFER0:
if (userbuffers[0] == nullptr) userbuffers[0].reset(new APIBuffer<char>(parent->device,numVertices(),stride));
userbuffers[0]->set(ptr,offset,stride);
userbuffers[0]->checkPadding16();
break;
case RTC_USER_VERTEX_BUFFER1:
if (userbuffers[1] == nullptr) userbuffers[1].reset(new APIBuffer<char>(parent->device,numVertices(),stride));
userbuffers[1]->set(ptr,offset,stride);
userbuffers[1]->checkPadding16();
break;
default:
throw_RTCError(RTC_INVALID_ARGUMENT,"unknown buffer type");
}
}
}
__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));
}
}
