omni::visual::Session Class Reference

Base class for drawing a session. More...

#include <Session.h>

Collaboration diagram for omni::visual::Session:

Public Member Functions
	Session (omni::Session const &)
	Construct with reference to session. More...
omni::Session const &	session () const
	Return const ref to session. More...
void	drawCanvas (mapping::OutputMode=mapping::OutputMode::MAPPED_INPUT, bool _grayscale=false) const
	Draw canvas with given output mode and optional grayscale toggle. More...
void	drawCanvasWireframe () const
void	drawCanvasFor3DView ()
	Draw canvas for scene view. More...
void	drawCanvasWithFrustumIntersections (ProjectorSelectionMode) const
	Canvas with frustum intersection of all projectors. More...
void	drawFrustumIntersection (proj::Projector const &, QColor const &) const
	Draw frustum canvas intersection. More...
void	update ()
	Update projectors and canvas. More...
void	drawProjectors (ProjectorSelectionMode=ProjectorSelectionMode::ALL) const
	Draw projectors. If _selectedOnly true, only currently selected projector is drawn. More...
void	drawProjectorHalos (ProjectorSelectionMode=ProjectorSelectionMode::ALL) const
	Draw projector halos. If _selectedOnly true, only currently selected projector is drawn. More...
bool	needsUpdate () const
	Returns true if an update is required. More...

Private Member Functions
void	drawCanvasWithMatrix () const
	Draw canvas transform with matrix. More...
template<typename F >
void	projectorDrawFunction (ProjectorSelectionMode, F f) const

Private Attributes
omni::Session const &	session_
std::list< visual::Projector >	projectors_
bool	needsUpdate_ = true

Static Private Attributes
static ContextBoundPtr < QOpenGLShaderProgram >	frustumShader_

Detailed Description

Base class for drawing a session.

Constructor & Destructor Documentation

omni::visual::Session::Session

(

omni::Session const &

_session

)

Construct with reference to session.

                                                :
      session_(_session)
    {}

Member Function Documentation

void omni::visual::Session::drawCanvas	(	mapping::OutputMode	_mode = mapping::OutputMode::MAPPED_INPUT,
		bool	_grayscale = false
	)		const

Draw canvas with given output mode and optional grayscale toggle.

    {
      auto _canvas = session_.canvas();

      if (!_canvas) return;

      withCurrentContext([&](QOpenGLFunctions& _)
      {
        auto *_input = session_.inputs().current();
        auto *_mapping = const_cast<mapping::Interface *>(session_.mapping());

        if (_input && session_.mapping() &&
            (_mode != mapping::OutputMode::LIGHTING_ONLY))
        {
          _.glDisable(GL_LIGHTING);
          _.glActiveTexture(GL_TEXTURE0);
          _.glBindTexture(GL_TEXTURE_RECTANGLE, _input->textureId());
          _mapping->bind(session_.inputs().current(), _mode, _grayscale);
          drawCanvasWithMatrix();
          _.glBindTexture(GL_TEXTURE_RECTANGLE, 0);
          _mapping->release();
        }
        else
        {
          // Render canvas with lighting when there is no input
          glColor4f(1.0, 1.0, 1.0, 1.0);
          drawCanvasWithMatrix();
        }
      });
    }

void omni::visual::Session::drawCanvasFor3DView

(

)

Draw canvas for scene view.

There is also no input to be displayed when input has no texture

                                      {
      auto _canvas = session_.canvas();

      if (!_canvas) return;

      withCurrentContext([&](QOpenGLFunctions& _)
      {
        auto *_input = session_.inputs().current();
        auto *_mapping = const_cast<mapping::Interface *>(session_.mapping());

        bool _displayInput = session_.scene().displayInput() &&
                             _mapping && _input;

        if (_input) {
          /// There is also no input to be displayed when input has no texture
          _displayInput &= _input->textureId() != 0;
        }

        if (_displayInput)
        {
          _.glDisable(GL_LIGHTING);
          _.glEnable(GL_DEPTH_TEST);
          _.glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
          _.glActiveTexture(GL_TEXTURE0);
          _.glBindTexture(GL_TEXTURE_RECTANGLE, _input->textureId());
          glPushMatrix();
          {
            glLoadIdentity();
            glMultMatrixf(_canvas->matrix().constData());

            _mapping->bind(session_.inputs().current(),
                           session_.scene().insideOutside());
            {
              _canvas->draw();
            }
            _mapping->release();

            _.glDisable(GL_DEPTH_TEST);
            _.glBlendFunc(GL_SRC_ALPHA, GL_ONE);
            _mapping->bind(session_.inputs().current(),
                           1.0 - session_.scene().insideOutside());
            {
              _canvas->draw();
            }
            _mapping->release();
            _.glBindTexture(GL_TEXTURE_RECTANGLE, 0);
            glPopMatrix();
          }
          _.glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
          _.glEnable(GL_DEPTH_TEST);
        }
        else
        {
          _.glEnable(GL_LIGHTING);

          // Render canvas with lighting when there is no input
          glColor4f(1.0, 1.0, 1.0, 1.0);
          glPushMatrix();
          {
            glLoadIdentity();
            glMultMatrixf(_canvas->matrix().constData());
            _canvas->draw();
          }
          glPopMatrix();
        }
        drawCanvasWireframe();
      });
    }

void omni::visual::Session::drawCanvasWireframe

(

)

const

                                            {
      auto _canvas = session_.canvas();
      float _wf = session_.scene().wireframe();
      if (!_canvas || _wf <= 0.0) return;

      glPushMatrix();
      {
        glEnable(GL_BLEND);
        glEnable(GL_LINE_SMOOTH);
        glPolygonMode(GL_FRONT,GL_LINE);
        glPolygonMode(GL_BACK,GL_LINE);
        glLineWidth(std::max(0.5,_wf*5.0));
        glColor4f(1.0,1.0,1.0,_wf);

        glLoadIdentity();
        glMultMatrixf(_canvas->matrix().constData());
        _canvas->drawWithViewMode();

        glPolygonMode(GL_FRONT,GL_FILL);
        glPolygonMode(GL_BACK,GL_FILL);
        glLineWidth(1.0);
      }
      glPopMatrix();
    }

void omni::visual::Session::drawCanvasWithFrustumIntersections

(

ProjectorSelectionMode

_selectionMode

)

const

Canvas with frustum intersection of all projectors.

    {
      projectorDrawFunction(_selectionMode, [&](Projector const&, int i) {
        auto _tuning = session_.tunings()[i];
        drawFrustumIntersection(_tuning->projector(),
                                _tuning->color());
      });
    }

void omni::visual::Session::drawCanvasWithMatrix ( ) const

private

Draw canvas transform with matrix.

                                             {
      auto _canvas = session_.canvas();

      if (!_canvas) return;

      glPushMatrix();
      {
        glLoadIdentity();
        glMultMatrixf(_canvas->matrix().constData());
        _canvas->drawWithViewMode();
      }
      glPopMatrix();
    }

void omni::visual::Session::drawFrustumIntersection	(	proj::Projector const &	_proj,
		QColor const &	_color
	)		const

Draw frustum canvas intersection.

Construct frustum

    {
      auto _canvas = session_.canvas();

      if (!frustumShader_ || !_canvas) return;

      frustumShader_->bind();
      /// Construct frustum
      QVector3D     _eye    = _proj.pos();

      // Setup frustum uniforms for intersection test
      frustumShader_->setUniformValue("color", _color.redF(),
                                      _color.greenF(), _color.blueF());
      frustumShader_->setUniformValue("eye",          _eye);
      frustumShader_->setUniformValue("frame_width",
                                      GLfloat(0.02));
      frustumShader_->setUniformValue("proj_matrix",   _proj.projectionMatrix());
      frustumShader_->setUniformValue("opacity", GLfloat(0.8));
      frustumShader_->setUniformValue("view_mode",int(_canvas->viewMode()));

      glDisable(GL_DEPTH_TEST);
      drawCanvasWithMatrix();
      glEnable(GL_DEPTH_TEST);

      frustumShader_->release();
    }

void omni::visual::Session::drawProjectorHalos

(

ProjectorSelectionMode

_selectionMode = ProjectorSelectionMode::ALL

)

const

Draw projector halos. If _selectedOnly true, only currently selected projector is drawn.

    {
      if (needsUpdate()) return;

      projectorDrawFunction(_selectionMode, [&](Projector const& _proj, int i) {
        if (session_.tunings()[i]->outputEnabled()) {
          _proj.drawHalo();
        }
      });
    }

void omni::visual::Session::drawProjectors

(

ProjectorSelectionMode

_selectedMode = ProjectorSelectionMode::ALL

)

const

Draw projectors. If _selectedOnly true, only currently selected projector is drawn.

    {
      if (needsUpdate()) return;

      withCurrentContext([&](QOpenGLFunctions& _) {
        _.glDisable(GL_DEPTH_TEST);

        projectorDrawFunction(_selectedMode, [&](Projector const& _proj, int) {
          _proj.draw();
        });

        if (session_.canvas())
        {
          projectorDrawFunction(_selectedMode, [&](Projector const& _proj, int) {
            _proj.drawPositioning(
              session_.canvas()->center());
            });
          }

          _.glEnable(GL_DEPTH_TEST);

      });
    }

bool omni::visual::Session::needsUpdate

(

)

const

Returns true if an update is required.

    {
      return session_.tunings().size() != projectors_.size() || needsUpdate_;
    }

template<typename F >

void omni::visual::Session::projectorDrawFunction ( ProjectorSelectionMode  _selectionMode, F  f  ) const

private

                                                   {
      int i = 0;

      for (auto& _proj : projectors_) {
        switch (_selectionMode) {
        default:
        case ProjectorSelectionMode::ALL:
          f(_proj, i);
          break;

        case ProjectorSelectionMode::SELECTED:

          if (i == session_.tunings().currentIndex()) {
            f(_proj, i);
          }

        case ProjectorSelectionMode::NONE:
          break;
        }
        ++i;
      }
    }

omni::Session const & omni::visual::Session::session

(

)

const

Return const ref to session.

    {
      return session_;
    }

void omni::visual::Session::update

(

)

Update projectors and canvas.

    {
      if (!QOpenGLContext::currentContext()) return;

      // Update projector visualizers
      projectors_.clear();

      for (int i = 0; i < session_.tunings().size(); ++i)
      {
        projectors_.emplace_back(session_.tunings()[i]->projector());
        projectors_.back().setColor(session_.tunings()[i]->color());
        projectors_.back().setSelected(
          i == session_.tunings().currentIndex());
        projectors_.back().setSize(session_.scene().size() / 10.0);
        projectors_.back().update();
      }

      // Setup frustum/canvas intersection shader
      if (!frustumShader_)
      {
        initShader(frustumShader_,"frustum");
      }
      needsUpdate_ = false;
    }

Field Documentation

ContextBoundPtr< QOpenGLShaderProgram > omni::visual::Session::frustumShader_

staticprivate

bool omni::visual::Session::needsUpdate_ = true

private

std::list<visual::Projector> omni::visual::Session::projectors_

private

omni::Session const& omni::visual::Session::session_

private

---

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

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