omni::visual::Projector Class Reference

Visualizer for drawing a projector with halo. More...

#include <Projector.h>

Inheritance diagram for omni::visual::Projector:

Collaboration diagram for omni::visual::Projector:

Public Member Functions
	Projector (const proj::Projector &)
	~Projector ()
void	update ()
	Update geometry. More...
qreal	size () const
	Return size of drawn projector. More...
void	setSize (qreal)
	Set size. More...
bool	isSelected () const
	Halo is bright if projector is selected. More...
void	setSelected (bool)
	Set boolean if projector is selected. More...
QColor	color () const
	Return drawn color. More...
void	setColor (QColor)
	Set color if drawn projector. More...
void	draw () const
	Draw projector line. More...
void	drawHalo () const
	Draw projector value. More...
void	drawPositioning (QVector3D const &_center) const
	Draw positioning of projector with center point. More...
Public Member Functions inherited from omni::visual::Interface
virtual	~Interface ()

Private Attributes
proj::Projector const &	proj_
bool	selected_ = false
float	size_ = 2.0
QColor	color_
QVector3D	eye_
QVector3D	topLeft_
QVector3D	topRight_
QVector3D	bottomLeft_
QVector3D	bottomRight_

Static Private Attributes
static ContextBoundPtr < QOpenGLShaderProgram >	haloShader_

Additional Inherited Members
Static Protected Member Functions inherited from omni::visual::Interface
static void	vertex3 (QVector3D const &)
	glVertex3f from QVector3D More...
static void	visualLine (QVector3D const &_from, QVector3D const &_to)
	Draws a line. More...
static void	color (QColor _color, float _alpha=1.0)
	glColor4f from QColor More...

Detailed Description

Visualizer for drawing a projector with halo.

Constructor & Destructor Documentation

omni::visual::Projector::Projector

(

const proj::Projector &

_proj

)

                                                       :
            proj_(_proj)
        {
            update();
        }

omni::visual::Projector::~Projector ( )

inline

{}

Member Function Documentation

QColor omni::visual::Projector::color

(

)

const

Return drawn color.

        {
            return color_;
        }

void omni::visual::Projector::draw ( ) const

virtual

Draw projector line.

Implements omni::visual::Interface.

        {
            Interface::color(color_);

            withCurrentContext([this](QOpenGLFunctions& _)
            {
                _.glLineWidth(selected_ ? 2.0 : 1.0);

                glPushMatrix();
                {
                    glLoadIdentity();
                    _.glDisable(GL_COLOR_MATERIAL);
                    _.glDisable(GL_LIGHTING);

                    // Apply matrix to OpenGL
                    glMultMatrixf(proj_.matrix().constData());
                    this->visualLine(eye_, topLeft_);
                    this->visualLine(eye_, topRight_);
                    this->visualLine(eye_, bottomLeft_);
                    this->visualLine(eye_, bottomRight_);
                    this->visualLine(topLeft_, topRight_);
                    this->visualLine(topLeft_, bottomLeft_);
                    this->visualLine(topRight_, bottomRight_);
                    this->visualLine(bottomLeft_, bottomRight_);
                }
                glPopMatrix();
            });
        }

void omni::visual::Projector::drawHalo

(

)

const

Draw projector value.

        {
          if (!haloShader_) return;
            glPushMatrix();
            {
                glLoadIdentity();

                // Apply matrix to OpenGL
                glMultMatrixf(proj_.matrix().data());
                haloShader_->bind();
                haloShader_->setUniformValue("color",
                                             color_.redF(),
                                             color_.greenF(),
                                             color_.blueF(),
                                             selected_ ? 0.25 : 0.05);

                glDisable(GL_DEPTH_TEST);
                glBegin(GL_TRIANGLE_FAN);
                Interface::color(color_, selected_ ? 0.45 : 0.15);

                glTexCoord2f(0.0, 0.0);

                this->vertex3(eye_);
                Interface::color(color_, 0.0);
                float _scale = size_ * 2.0;

                if (selected_) _scale *= 2.0;

                glTexCoord2f(0.0, 1.0);
                this->vertex3(topLeft_ * _scale);
                this->vertex3(topRight_ * _scale);
                this->vertex3(bottomRight_ * _scale);
                this->vertex3(bottomLeft_ * _scale);
                this->vertex3(topLeft_ * _scale);
                glEnd();
                glEnable(GL_DEPTH_TEST);

                haloShader_->release();
            }
            glPopMatrix();
        }

void omni::visual::Projector::drawPositioning

(

QVector3D const &

_center

)

const

Draw positioning of projector with center point.

        {
            Interface::color(color_);

            withCurrentContext([this](QOpenGLFunctions& _)
            {
                _.glLineWidth(selected_ ? 4.0 : 1.5);
            });

            auto _p       = proj_.pos();
            auto _setupId =
                proj_.setup() ? proj_.setup()->getTypeId().str() :
                "PeripheralSetup";

            if (_setupId == "PeripheralSetup")
            {
                // Draw line from center to projector ground position
                this->visualLine(_center, QVector3D(_p.x(), _p.y(), _center.z()));
                this->visualLine(
                    QVector3D(_p.x(), _p.y(), _center.z()), _p);
            } else
            {
                // Draw manhattan line from center to projector ground position
                this->visualLine(_center,
                                 QVector3D(_p.x(), _center.y(), _center.z()));
                this->visualLine(
                                 QVector3D(_p.x(), _center.y(), _center.z()),
                                 QVector3D(_p.x(), _p.y(),      _center.z()));
                this->visualLine(
                                 QVector3D(_p.x(), _p.y(),      _center.z()), _p);
            }
        }

bool omni::visual::Projector::isSelected

(

)

const

Halo is bright if projector is selected.

        {
            return selected_;
        }

void omni::visual::Projector::setColor

(

QColor

_color

)

Set color if drawn projector.

        {
            color_ = _color;
        }

void omni::visual::Projector::setSelected

(

bool

_selected

)

Set boolean if projector is selected.

        {
            selected_ = _selected;
        }

void omni::visual::Projector::setSize

(

qreal

_size

)

Set size.

        {
            size_ = _size;
            update();
        }

qreal omni::visual::Projector::size

(

)

const

Return size of drawn projector.

        {
            return size_;
        }

void omni::visual::Projector::update ( )

virtual

Update geometry.

Reimplemented from omni::visual::Interface.

        {
          withCurrentContext([&](QOpenGLFunctions& _) {
            initShader(haloShader_,"halo");
          });

            proj::Frustum _frustum(proj_);
            eye_         = QVector3D(0, 0, 0);
            topLeft_     = _frustum.topLeft() *size_;
            topRight_    = _frustum.topRight() *size_;
            bottomLeft_  = _frustum.bottomLeft() *size_;
            bottomRight_ = _frustum.bottomRight() * size_;
        }

Field Documentation

QVector3D omni::visual::Projector::bottomLeft_

private

QVector3D omni::visual::Projector::bottomRight_

private

QColor omni::visual::Projector::color_

private

QVector3D omni::visual::Projector::eye_

private

ContextBoundPtr< QOpenGLShaderProgram > omni::visual::Projector::haloShader_

staticprivate

proj::Projector const& omni::visual::Projector::proj_

private

bool omni::visual::Projector::selected_ = false

private

float omni::visual::Projector::size_ = 2.0

private

QVector3D omni::visual::Projector::topLeft_

private

QVector3D omni::visual::Projector::topRight_

private

---

The documentation for this class was generated from the following files:

• include/omni/visual/Projector.h
• src/lib/visual/Projector.cpp