281 lines
8.9 KiB
C++
281 lines
8.9 KiB
C++
// Copyright 2009-2021 Intel Corporation
|
|
// SPDX-License-Identifier: Apache-2.0
|
|
|
|
#include "scene_line_segments.h"
|
|
#include "scene.h"
|
|
|
|
namespace embree
|
|
{
|
|
#if defined(EMBREE_LOWEST_ISA)
|
|
|
|
LineSegments::LineSegments (Device* device, Geometry::GType gtype)
|
|
: Geometry(device,gtype,0,1), tessellationRate(4)
|
|
{
|
|
vertices.resize(numTimeSteps);
|
|
}
|
|
|
|
void LineSegments::setMask (unsigned mask)
|
|
{
|
|
this->mask = mask;
|
|
Geometry::update();
|
|
}
|
|
|
|
void LineSegments::setNumTimeSteps (unsigned int numTimeSteps)
|
|
{
|
|
vertices.resize(numTimeSteps);
|
|
if (getCurveType() == GTY_SUBTYPE_ORIENTED_CURVE)
|
|
normals.resize(numTimeSteps);
|
|
Geometry::setNumTimeSteps(numTimeSteps);
|
|
}
|
|
|
|
void LineSegments::setVertexAttributeCount (unsigned int N)
|
|
{
|
|
vertexAttribs.resize(N);
|
|
Geometry::update();
|
|
}
|
|
|
|
void LineSegments::setBuffer(RTCBufferType type, unsigned int slot, RTCFormat format, const Ref<Buffer>& buffer, size_t offset, size_t stride, unsigned int num)
|
|
{
|
|
/* verify that all accesses are 4 bytes aligned */
|
|
if ((type != RTC_BUFFER_TYPE_FLAGS) && (((size_t(buffer->getPtr()) + offset) & 0x3) || (stride & 0x3)))
|
|
throw_RTCError(RTC_ERROR_INVALID_OPERATION, "data must be 4 bytes aligned");
|
|
|
|
if (type == RTC_BUFFER_TYPE_VERTEX)
|
|
{
|
|
if (format != RTC_FORMAT_FLOAT4)
|
|
throw_RTCError(RTC_ERROR_INVALID_OPERATION, "invalid vertex buffer format");
|
|
|
|
if (slot >= vertices.size())
|
|
throw_RTCError(RTC_ERROR_INVALID_ARGUMENT, "invalid vertex buffer slot");
|
|
|
|
vertices[slot].set(buffer, offset, stride, num, format);
|
|
vertices[slot].checkPadding16();
|
|
}
|
|
else if (type == RTC_BUFFER_TYPE_NORMAL)
|
|
{
|
|
if (getCurveType() != GTY_SUBTYPE_ORIENTED_CURVE)
|
|
throw_RTCError(RTC_ERROR_INVALID_ARGUMENT, "unknown buffer type");
|
|
|
|
if (format != RTC_FORMAT_FLOAT3)
|
|
throw_RTCError(RTC_ERROR_INVALID_OPERATION, "invalid normal buffer format");
|
|
|
|
if (slot >= normals.size())
|
|
throw_RTCError(RTC_ERROR_INVALID_OPERATION, "invalid normal buffer slot");
|
|
|
|
normals[slot].set(buffer, offset, stride, num, format);
|
|
normals[slot].checkPadding16();
|
|
}
|
|
else if (type == RTC_BUFFER_TYPE_VERTEX_ATTRIBUTE)
|
|
{
|
|
if (format < RTC_FORMAT_FLOAT || format > RTC_FORMAT_FLOAT16)
|
|
throw_RTCError(RTC_ERROR_INVALID_OPERATION, "invalid vertex attribute buffer format");
|
|
|
|
if (slot >= vertexAttribs.size())
|
|
throw_RTCError(RTC_ERROR_INVALID_OPERATION, "invalid vertex attribute buffer slot");
|
|
|
|
vertexAttribs[slot].set(buffer, offset, stride, num, format);
|
|
vertexAttribs[slot].checkPadding16();
|
|
}
|
|
else if (type == RTC_BUFFER_TYPE_INDEX)
|
|
{
|
|
if (slot != 0)
|
|
throw_RTCError(RTC_ERROR_INVALID_ARGUMENT, "invalid buffer slot");
|
|
if (format != RTC_FORMAT_UINT)
|
|
throw_RTCError(RTC_ERROR_INVALID_OPERATION, "invalid index buffer format");
|
|
|
|
segments.set(buffer, offset, stride, num, format);
|
|
setNumPrimitives(num);
|
|
}
|
|
else if (type == RTC_BUFFER_TYPE_FLAGS)
|
|
{
|
|
if (slot != 0)
|
|
throw_RTCError(RTC_ERROR_INVALID_ARGUMENT, "invalid buffer slot");
|
|
if (format != RTC_FORMAT_UCHAR)
|
|
throw_RTCError(RTC_ERROR_INVALID_OPERATION, "invalid flag buffer format");
|
|
|
|
flags.set(buffer, offset, stride, num, format);
|
|
flags.userData = 1; // to encode that app manages this buffer
|
|
}
|
|
else
|
|
throw_RTCError(RTC_ERROR_INVALID_ARGUMENT, "unknown buffer type");
|
|
}
|
|
|
|
void* LineSegments::getBuffer(RTCBufferType type, unsigned int slot)
|
|
{
|
|
if (type == RTC_BUFFER_TYPE_INDEX)
|
|
{
|
|
if (slot != 0)
|
|
throw_RTCError(RTC_ERROR_INVALID_ARGUMENT, "invalid buffer slot");
|
|
return segments.getPtr();
|
|
}
|
|
else if (type == RTC_BUFFER_TYPE_VERTEX)
|
|
{
|
|
if (slot >= vertices.size())
|
|
throw_RTCError(RTC_ERROR_INVALID_ARGUMENT, "invalid buffer slot");
|
|
return vertices[slot].getPtr();
|
|
}
|
|
else if (type == RTC_BUFFER_TYPE_NORMAL)
|
|
{
|
|
if (slot >= normals.size())
|
|
throw_RTCError(RTC_ERROR_INVALID_ARGUMENT, "invalid buffer slot");
|
|
return normals[slot].getPtr();
|
|
}
|
|
else if (type == RTC_BUFFER_TYPE_VERTEX_ATTRIBUTE)
|
|
{
|
|
if (slot >= vertexAttribs.size())
|
|
throw_RTCError(RTC_ERROR_INVALID_ARGUMENT, "invalid buffer slot");
|
|
return vertexAttribs[slot].getPtr();
|
|
}
|
|
else if (type == RTC_BUFFER_TYPE_FLAGS)
|
|
{
|
|
if (slot != 0)
|
|
throw_RTCError(RTC_ERROR_INVALID_ARGUMENT, "invalid buffer slot");
|
|
return flags.getPtr();
|
|
}
|
|
else
|
|
{
|
|
throw_RTCError(RTC_ERROR_INVALID_ARGUMENT, "unknown buffer type");
|
|
return nullptr;
|
|
}
|
|
}
|
|
|
|
void LineSegments::updateBuffer(RTCBufferType type, unsigned int slot)
|
|
{
|
|
if (type == RTC_BUFFER_TYPE_INDEX)
|
|
{
|
|
if (slot != 0)
|
|
throw_RTCError(RTC_ERROR_INVALID_ARGUMENT, "invalid buffer slot");
|
|
segments.setModified();
|
|
}
|
|
else if (type == RTC_BUFFER_TYPE_VERTEX)
|
|
{
|
|
if (slot >= vertices.size())
|
|
throw_RTCError(RTC_ERROR_INVALID_ARGUMENT, "invalid buffer slot");
|
|
vertices[slot].setModified();
|
|
}
|
|
else if (type == RTC_BUFFER_TYPE_NORMAL)
|
|
{
|
|
if (slot >= normals.size())
|
|
throw_RTCError(RTC_ERROR_INVALID_ARGUMENT, "invalid buffer slot");
|
|
normals[slot].setModified();
|
|
}
|
|
else if (type == RTC_BUFFER_TYPE_VERTEX_ATTRIBUTE)
|
|
{
|
|
if (slot >= vertexAttribs.size())
|
|
throw_RTCError(RTC_ERROR_INVALID_ARGUMENT, "invalid buffer slot");
|
|
vertexAttribs[slot].setModified();
|
|
}
|
|
else if (type == RTC_BUFFER_TYPE_FLAGS)
|
|
{
|
|
if (slot != 0)
|
|
throw_RTCError(RTC_ERROR_INVALID_ARGUMENT, "invalid buffer slot");
|
|
flags.setModified();
|
|
}
|
|
else
|
|
{
|
|
throw_RTCError(RTC_ERROR_INVALID_ARGUMENT, "unknown buffer type");
|
|
}
|
|
|
|
Geometry::update();
|
|
}
|
|
|
|
void LineSegments::setTessellationRate(float N) {
|
|
tessellationRate = clamp((int)N,1,16);
|
|
}
|
|
|
|
void LineSegments::setMaxRadiusScale(float s) {
|
|
maxRadiusScale = s;
|
|
}
|
|
|
|
void LineSegments::commit()
|
|
{
|
|
/* verify that stride of all time steps are identical */
|
|
for (unsigned int t=0; t<numTimeSteps; t++)
|
|
if (vertices[t].getStride() != vertices[0].getStride())
|
|
throw_RTCError(RTC_ERROR_INVALID_OPERATION,"stride of vertex buffers have to be identical for each time step");
|
|
|
|
for (const auto& buffer : normals)
|
|
if (buffer.getStride() != normals[0].getStride())
|
|
throw_RTCError(RTC_ERROR_INVALID_OPERATION,"stride of normal buffers have to be identical for each time step");
|
|
|
|
vertices0 = vertices[0];
|
|
if (getCurveType() == GTY_SUBTYPE_ORIENTED_CURVE)
|
|
normals0 = normals[0];
|
|
|
|
/* if no flags buffer is specified we manage and calculate the flags buffer */
|
|
if (!flags.buffer) flags.userData = 0; // to encode that we manage this buffer
|
|
bool recompute_flags_buffer = segments.isLocalModified();
|
|
|
|
/* resize flags buffer if number of primitives changed */
|
|
if (!flags.userData && (!flags.buffer || flags.size() != numPrimitives))
|
|
{
|
|
Ref<Buffer> buffer = new Buffer(device, numPrimitives*sizeof(char));
|
|
flags.set(buffer, 0, sizeof(char), numPrimitives, RTC_FORMAT_UCHAR);
|
|
recompute_flags_buffer = true;
|
|
}
|
|
|
|
/* recalculate the flags buffer if index buffer got modified */
|
|
if (!flags.userData && recompute_flags_buffer)
|
|
{
|
|
bool hasLeft = false;
|
|
for (size_t i=0; i<numPrimitives; i++) {
|
|
bool hasRight = (i==numPrimitives-1) ? false : segment(i+1) == segment(i)+1;
|
|
flags[i] = hasLeft * RTC_CURVE_FLAG_NEIGHBOR_LEFT;
|
|
flags[i] |= hasRight * RTC_CURVE_FLAG_NEIGHBOR_RIGHT;
|
|
hasLeft = hasRight;
|
|
}
|
|
}
|
|
segments.clearLocalModified();
|
|
|
|
Geometry::commit();
|
|
}
|
|
|
|
void LineSegments::addElementsToCount (GeometryCounts & counts) const
|
|
{
|
|
if (numTimeSteps == 1) counts.numLineSegments += numPrimitives;
|
|
else counts.numMBLineSegments += numPrimitives;
|
|
}
|
|
|
|
bool LineSegments::verify ()
|
|
{
|
|
/*! verify consistent size of vertex arrays */
|
|
if (vertices.size() == 0)
|
|
return false;
|
|
|
|
for (const auto& buffer : vertices)
|
|
if (buffer.size() != numVertices())
|
|
return false;
|
|
|
|
for (const auto& buffer : normals)
|
|
if (vertices[0].size() != buffer.size())
|
|
return false;
|
|
|
|
/*! verify segment indices */
|
|
for (unsigned int i=0; i<size(); i++) {
|
|
if (segments[i]+1 >= numVertices()) return false;
|
|
}
|
|
|
|
/*! verify vertices */
|
|
for (const auto& buffer : vertices) {
|
|
for (size_t i=0; i<buffer.size(); i++) {
|
|
if (!isvalid(buffer[i].x)) return false;
|
|
if (!isvalid(buffer[i].y)) return false;
|
|
if (!isvalid(buffer[i].z)) return false;
|
|
if (!isvalid(buffer[i].w)) return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
void LineSegments::interpolate(const RTCInterpolateArguments* const args) {
|
|
interpolate_impl<4>(args);
|
|
}
|
|
#endif
|
|
|
|
namespace isa
|
|
{
|
|
LineSegments* createLineSegments(Device* device, Geometry::GType gtype) {
|
|
return new LineSegmentsISA(device,gtype);
|
|
}
|
|
}
|
|
}
|