void Geometry::enable ()
{
if (parent->isStatic()) {
process_error(RTC_INVALID_OPERATION,"static geometries cannot get enabled");
return;
}
if (isDisabled()) {
atomic_add(&parent->numIntersectionFilters4,(intersectionFilter4 != NULL) + (occlusionFilter4 != NULL));
atomic_add(&parent->numIntersectionFilters8,(intersectionFilter8 != NULL) + (occlusionFilter8 != NULL));
atomic_add(&parent->numIntersectionFilters16,(intersectionFilter16 != NULL) + (occlusionFilter16 != NULL));
}
switch (state) {
case ENABLING:
break;
case ENABLED:
break;
case MODIFIED:
break;
case DISABLING:
state = MODIFIED;
enabling();
break;
case DISABLED:
state = ENABLING;
enabling();
break;
case ERASING:
break;
}
}
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");
}
LineSegments::LineSegments (Scene* parent, RTCGeometryFlags flags, size_t numPrimitives, size_t numVertices, size_t numTimeSteps)
: Geometry(parent,LINE_SEGMENTS,numPrimitives,numTimeSteps,flags)
{
segments.init(parent->device,numPrimitives,sizeof(int));
for (size_t i=0; i<numTimeSteps; i++) {
vertices[i].init(parent->device,numVertices,sizeof(Vec3fa));
}
enabling();
}
TriangleMesh::TriangleMesh (Scene* parent, RTCGeometryFlags flags, size_t numTriangles, size_t numVertices, size_t numTimeSteps)
: Geometry(parent,TRIANGLE_MESH,numTriangles,numTimeSteps,flags)
{
triangles.init(parent->device,numTriangles,sizeof(Triangle));
for (size_t i=0; i<numTimeSteps; i++) {
vertices[i].init(parent->device,numVertices,sizeof(Vec3fa));
}
enabling();
}
BezierCurves::BezierCurves (Scene* parent, RTCGeometryFlags flags, size_t numPrimitives, size_t numVertices, size_t numTimeSteps)
: Geometry(parent,BEZIER_CURVES,numPrimitives,numTimeSteps,flags)
{
curves.init(parent->device,numPrimitives,sizeof(int));
for (size_t i=0; i<numTimeSteps; i++) {
vertices[i].init(parent->device,numVertices,sizeof(Vec3fa));
}
enabling();
}
QuadMesh::QuadMesh (Scene* parent, RTCGeometryFlags flags, size_t numQuads, size_t numVertices, size_t numTimeSteps)
: Geometry(parent,QUAD_MESH,numQuads,numTimeSteps,flags)
{
quads.init(parent->device,numQuads,sizeof(Quad));
for (size_t i=0; i<numTimeSteps; i++) {
vertices[i].init(parent->device,numVertices,sizeof(Vec3fa));
}
enabling();
}
BezierCurves::BezierCurves (Scene* parent, RTCGeometryFlags flags, size_t numCurves, size_t numVertices, size_t numTimeSteps)
: Geometry(parent,BEZIER_CURVES,numCurves,flags),
mask(-1), numTimeSteps(numTimeSteps), numCurves(numCurves), numVertices(numVertices)
{
curves.init(numCurves,sizeof(int));
for (size_t i=0; i<numTimeSteps; i++) {
vertices[i].init(numVertices,sizeof(Vertex));
}
enabling();
}
NativeCurves::NativeCurves (Scene* scene, SubType subtype, Basis basis, RTCGeometryFlags flags, size_t numPrimitives, size_t numVertices, size_t numTimeSteps)
: Geometry(scene,BEZIER_CURVES,numPrimitives,numTimeSteps,flags), subtype(subtype), basis(basis), tessellationRate(4)
{
curves.init(scene->device,numPrimitives,sizeof(int));
vertices.resize(numTimeSteps);
for (size_t i=0; i<numTimeSteps; i++) {
vertices[i].init(scene->device,numVertices,sizeof(Vec3fa));
}
enabling();
}
void FeatureEval::enable() {
if(is_enabled_){
disable();
return;
}
mw_->options_dock_->show();
mw_->tooloptions_->setCurrentWidget(settings_);
emit enabling();
connect(core_, SIGNAL(endEdit()), this, SLOT(disable()));
is_enabled_ = true;
}
QuadraticBezierCurvesScene::QuadraticBezierCurves::QuadraticBezierCurves (Scene* parent, RTCGeometryFlags flags, size_t numCurves, size_t numVertices, size_t numTimeSteps)
: Geometry(parent,QUADRATIC_BEZIER_CURVES,numCurves,flags),
mask(-1), built(false), numTimeSteps(numTimeSteps),
numCurves(numCurves), needCurves(false),
numVertices(numVertices), needVertices(false)
{
curves.init(numCurves,sizeof(int));
for (size_t i=0; i<numTimeSteps; i++) {
vertices[i].init(numVertices,sizeof(Vertex));
}
enabling();
}
void Morphology::enable() {
if(is_enabled_){
disable();
return;
}
mw_->options_dock_->show();
mw_->tooloptions_->setCurrentWidget(settings_);
emit enabling();
glwidget_->installEventFilter(this);
flatview_->installEventFilter(this);
connect(core_, SIGNAL(endEdit()), this, SLOT(disable()));
is_enabled_ = true;
}
void Morphology::initialize(Core *core){
core_= core;
cl_ = core_->cl_;
ll_ = core_->ll_;
glwidget_ = core_->mw_->glwidget_;
flatview_ = core_->mw_->flatview_;
mw_ = core_->mw_;
is_enabled_ = false;
connect(this, SIGNAL(enabling()), core_, SIGNAL(endEdit()));
enable_ = new QAction(QIcon(":/morphology.png"), "Enable Morphology", 0);
enable_->setCheckable(true);
connect(enable_, SIGNAL(triggered()), this, SLOT(enable()));
radius_ = 10;
mw_->toolbar_->addAction(enable_);
settings_ = new QWidget();
QVBoxLayout * layout = new QVBoxLayout(settings_);
settings_->setLayout(layout);
mw_->tooloptions_->addWidget(settings_);
QLabel * l = new QLabel(QString("Radius: %1 cm").arg(radius_), settings_);
QSlider * slider = new QSlider(settings_);
slider->setOrientation(Qt::Horizontal);
slider->setRange(1, 300);
slider->setSingleStep(1);
slider->setToolTip("Radius in cm");
slider->setValue(radius_);
slider->setTickPosition(QSlider::TicksBelow);
connect(slider, &QSlider::valueChanged, [this, l] (int val){
radius_ = val;
l->setText(QString("Radius: %1 cm").arg(radius_));
});
QPushButton * open = new QPushButton("Open");
connect(open, SIGNAL(clicked()), this, SLOT(open()));
layout->addWidget(l);
layout->addWidget(slider);
layout->addWidget(open);
layout->addStretch();
}
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");
}
AccelSet::AccelSet (Scene* parent, size_t numItems)
: Geometry(parent,Geometry::USER_GEOMETRY,numItems,1,RTC_GEOMETRY_STATIC), numItems(numItems)
{
intersectors.ptr = nullptr;
enabling();
}
void CameraSetter::initialize(Core *core){
core_= core;
cl_ = core_->cl_;
ll_ = core_->ll_;
glwidget_ = core_->mw_->glwidget_;
flatview_ = core_->mw_->flatview_;
mw_ = core_->mw_;
is_enabled_ = false;
connect(this, SIGNAL(enabling()), core_, SIGNAL(endEdit()));
enable_ = new QAction(QIcon(":/camerasetter.png"), "Enable CameraSetter", 0);
enable_->setCheckable(true);
connect(enable_, SIGNAL(triggered()), this, SLOT(enable()));
mw_->toolbar_->addAction(enable_);
settings_ = new QWidget();
QVBoxLayout * layout = new QVBoxLayout(settings_);
settings_->setLayout(layout);
mw_->tooloptions_->addWidget(settings_);
QTextEdit * camera_state_text = new QTextEdit();
auto cameraToText = [this, camera_state_text](){
auto rot = glwidget_->camera_.getRotation();
auto pos = glwidget_->camera_.getPosition();
QString str = QString("%1 %2 %3 \n %4 %5 %6 %7").arg(
QString::number(pos.x()),
QString::number(pos.y()),
QString::number(pos.z()),
QString::number(rot.x()),
QString::number(rot.y()),
QString::number(rot.z()),
QString::number(rot.w()));
camera_state_text->setText(str);
};
auto textToCamera = [this, camera_state_text](){
QString str = camera_state_text->toPlainText().trimmed();
QStringList sl = str.split(QRegExp("\\s+"), QString::SkipEmptyParts);
if(sl.size() != 7){
// qDebug() << "No good";
camera_state_text->setStyleSheet("QTextEdit { background: #FFCCCC;}");
return;
} else {
camera_state_text->setStyleSheet("QTextEdit { background: #FFFFFF;}");
}
QTextStream stream(&str);
double rx, ry, rz, rw;
double px, py, pz;
stream >> px >> py >> pz >> rx >> ry >> rz >> rw;
Eigen::Quaternion<float> rot(rw, rx, ry, rz);
Eigen::Vector3f pos(px, py, pz);
glwidget_->camera_.setRotation(rot);
glwidget_->camera_.setPosition(pos);
};
connect(&glwidget_->camera_, &Camera::modified, cameraToText);
connect(camera_state_text, &QTextEdit::textChanged, textToCamera);
seconds_ = 0;
running_ = false;
target_ = Eigen::Vector3f(0, 0, 0);
QLineEdit * elapsed_time_text = new QLineEdit();
distance_text_ = new QLineEdit();
QTextEdit * target_text_area = new QTextEdit();
target_text_area->setText("0 0 0");
QPushButton * start_button = new QPushButton("Start / Restart");
connect(target_text_area, &QTextEdit::textChanged, [this, target_text_area](){
QString str = target_text_area->toPlainText().trimmed();
QStringList sl = str.split(QRegExp("\\s+"), QString::SkipEmptyParts);
if(sl.size() != 3){
target_text_area->setStyleSheet("QTextEdit { background: #FFCCCC;}");
//qDebug() << "No good";
return;
} else {
target_text_area->setStyleSheet("QTextEdit { background: #FFFFFF;}");
}
QTextStream stream(&str);
double px, py, pz;
stream >> px >> py >> pz;
target_ = Eigen::Vector3f(px, py, pz);
});
GeometryInstance::GeometryInstance (Scene* scene, Geometry* geom)
: Geometry(scene,Type(geom->type | INSTANCE), 1, geom->numTimeSteps, geom->flags), local2world(one), world2local(one), geom(geom)
{
enabling();
}
GeometryGroup::GeometryGroup (Scene* scene, RTCGeometryFlags gflags, const std::vector<Geometry*>& geometries)
: Geometry(scene,GROUP, geometries.size(), 1, gflags), geometries(geometries)
{
enabling();
}
