Namespace for OpenGL visualization. More...

Namespaces
	detail

	util

Data Structures
class	BoundingBox
	Visualizer for draing a bounding box from bounds. More...

class	Box
	Box with subdivisions for drawing. More...

class	CameraInterface
	A generic camera interface. More...

class	Circle
	Visualizer for drawing a circle with VBO. More...

struct	ContextBoundPtr
	A pointer template which is free'd together with its context Holds an internal object which is responsible for freeing the held object when OpenGL context is free'd. More...

class	Framebuffer32F
	Framebuffer with 32-bit float pixel depth per channel. More...

class	Grid
	A cartesian grid with lining adapted to distance. More...

class	Interface
	Basic visual interface. More...

struct	Light
	A light with position and phong shader attributes. More...

class	PerspectiveCamera
	A perspective camera. More...

class	Plane
	A plane with n x m grid points Vertex data is not stored on host, it is copied to GPU directly. Plane has dimensions [-0.5,-0.5] - [0.5,0.5]. More...

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

struct	Rectangle
	Visualizer helper class for drawing a rectangle in an OpenGL context. More...

class	Scene
	A class that holds settings and elements for session 3d visualization Belongs to a session. More...

class	Session
	Base class for drawing a session. More...

class	ShaderCompiler
	Adds #include functionality to shader source code Compiles source code file with included files or compiles a shader. More...

class	Sphere
	Draw Handler for visualizing a centered sphere. More...

class	Texture32F
	RGBA Texture with 32-bit float for each channel. More...

struct	Tracker

class	Tuning
	Tuning visualizer. More...

struct	UniformHandler
	Uniform handler for a shader program Cares about bind and releasing shaders and texture uniforms. Should only be used with the visual::useShader function. More...

struct	VBO
	A small Vertex Buffer Object class. More...

class	VertexVBO
	Utility class for storing and drawing VBO data. More...

class	WarpGrid
	Draw Handler for WarpGrid. More...

Typedefs
typedef std::function< void(QOpenGLFunctions &)>	ContextFunctor

Enumerations
enum	ProjectorViewMode { ProjectorViewMode::INSIDE, ProjectorViewMode::OUTSIDE, ProjectorViewMode::BOTH }

enum	EditMode { EditMode::CAMERA, EditMode::MOVE, EditMode::ROTATE }
	Enum class to determine which scene element is edited. More...

enum	MoveMode { MoveMode::MOVE_X, MoveMode::MOVE_Y, MoveMode::MOVE_Z, MoveMode::MOVE_XY }
	Which direction to move with mouse. More...

enum	RotateMode { RotateMode::PITCH, RotateMode::YAW, RotateMode::ROLL }
	Rotate pitch, yaw, roll. More...

enum	ProjectorSelectionMode { ProjectorSelectionMode::ALL, ProjectorSelectionMode::SELECTED, ProjectorSelectionMode::NONE }

Functions
bool	operator== (CameraInterface const &_lhs, CameraInterface const &_rhs)
	Test for equality. More...

void	contextSwitch (QOpenGLContext *_context, ContextFunctor f)

void	primaryContextSwitch (ContextFunctor)
	Switch to primary context to create OpenGL objects like textures etc. More...

void	withCurrentContext (ContextFunctor)
	Do OpenGL operations with current context, if it exists. More...

bool	operator== (Light const &_lhs, Light const &_rhs)
	Test for equality. ScreenSetup is ignored. More...

bool	operator== (PerspectiveCamera const &_lhs, PerspectiveCamera const &_rhs)
	Test for equality. ScreenSetup is ignored. More...

bool	operator== (Scene const &_lhs, Scene const &_rhs)

void	initShader (QOpenGLShaderProgram &_s, const char *_filename)
	Initialize shader: load from file and compile. More...

void	initShader (std::unique_ptr< QOpenGLShaderProgram > &_s, const char *_filename)
	Initialize shader: load from file and compile. More...

void	initShader (ContextBoundPtr< QOpenGLShaderProgram > &_s, const char *_filename)
	Initialize shader: load from file and compile. More...

void	useShader (QOpenGLShaderProgram &_s, std::function< void(UniformHandler &)> f)
	Use shader with and do uniform assignment and drawing inside functor. More...

bool	operator== (Tracker const &_lhs, Tracker const &_rhs)
	Test for equality. ScreenSetup is ignored. More...

Detailed Description

Namespace for OpenGL visualization.

Typedef Documentation

typedef std::function<void (QOpenGLFunctions&)> omni::visual::ContextFunctor

Enumeration Type Documentation

enum omni::visual::EditMode

strong

Enum class to determine which scene element is edited.

Enumerator
CAMERA
MOVE
ROTATE

                         {
       CAMERA,
       MOVE,
       ROTATE
     };

enum omni::visual::MoveMode

strong

Which direction to move with mouse.

Enumerator
MOVE_X
MOVE_Y
MOVE_Z
MOVE_XY

                         {
       MOVE_X,
       MOVE_Y,
       MOVE_Z,
       MOVE_XY
     };

enum omni::visual::ProjectorSelectionMode

strong

Enumerator
ALL
SELECTED
NONE

                                       {
       ALL, SELECTED, NONE
     };

enum omni::visual::ProjectorViewMode

strong

Enumerator
INSIDE
OUTSIDE
BOTH

enum omni::visual::RotateMode

strong

Rotate pitch, yaw, roll.

Enumerator
PITCH
YAW
ROLL

                           {
       PITCH,
       YAW,
       ROLL
     };

Function Documentation

void omni::visual::contextSwitch	(	QOpenGLContext *	_context,
		ContextFunctor	f
	)

                                                                    {
       auto *_current = QOpenGLContext::currentContext();
       if (!_current) return;
 
       if (_context != _current) {
         _context->makeCurrent(_current->surface());
       }
 
       withCurrentContext(f);
 
       if (_context != _current) {
         _current->makeCurrent(_current->surface());
       }
     }

void omni::visual::initShader	(	QOpenGLShaderProgram &	_s,
		const char *	_filename
	)

Initialize shader: load from file and compile.

                                                                      {
       QString _vertSrc =
         ShaderCompiler::compile(":/shaders/" + QString(_filename) + ".vert");
       QString _fragmentSrc =
         ShaderCompiler::compile(":/shaders/" + QString(_filename) + ".frag");
 
       _s.addShaderFromSourceCode(QOpenGLShader::Vertex,
                                  _vertSrc);
       _s.addShaderFromSourceCode(QOpenGLShader::Fragment,
                                  _fragmentSrc);
       _s.link();
     }

void omni::visual::initShader	(	std::unique_ptr< QOpenGLShaderProgram > &	_s,
		const char *	_filename
	)

Initialize shader: load from file and compile.

Dont do anything if shader is already allocated

                                            {
       /// Dont do anything if shader is already allocated
       if (!!_s) return;
 
       _s.reset(new QOpenGLShaderProgram());
       initShader(*_s, _filename);
     }

void omni::visual::initShader	(	ContextBoundPtr< QOpenGLShaderProgram > &	_s,
		const char *	_filename
	)

Initialize shader: load from file and compile.

Dont do anything if shader is already allocated

                                            {
       /// Dont do anything if shader is already allocated
       if (!!_s) return;
 
       if (_s.reset(new QOpenGLShaderProgram())) {
         initShader(*_s, _filename);
       }
     }

bool omni::visual::operator==	(	PerspectiveCamera const &	_lhs,
		PerspectiveCamera const &	_rhs
	)

Test for equality. ScreenSetup is ignored.

                                                                                   {
       return
         (static_cast<CameraInterface const&>(_lhs) == static_cast<CameraInterface const&>(_rhs)) &&
         OMNI_TEST_MEMBER_EQUAL(fov_);
     }

bool omni::visual::operator==	(	CameraInterface const &	_lhs,
		CameraInterface const &	_rhs
	)

Test for equality.

Test for equality. ScreenSetup is ignored.

                                                                               {
       return
         OMNI_TEST_MEMBER_EQUAL(up_) &&
         OMNI_TEST_MEMBER_EQUAL(near_) &&
         OMNI_TEST_MEMBER_EQUAL(far_);
     }

bool omni::visual::operator==	(	Tracker const &	_lhs,
		Tracker const &	_rhs
	)

Test for equality. ScreenSetup is ignored.

     {
       return
         OMNI_TEST_MEMBER_EQUAL(center_) &&
         OMNI_TEST_MEMBER_EQUAL(direction_);
     }

bool omni::visual::operator==	(	Light const &	_lhs,
		Light const &	_rhs
	)

Test for equality. ScreenSetup is ignored.

                                                           {
       return
         OMNI_TEST_MEMBER_EQUAL(ambient_) &&
         OMNI_TEST_MEMBER_EQUAL(diffuse_) &&
         OMNI_TEST_MEMBER_EQUAL(specular_) &&
         OMNI_TEST_MEMBER_EQUAL(intensity_);
     }

bool omni::visual::operator==	(	Scene const &	_lhs,
		Scene const &	_rhs
	)

                                                           {
       return
         OMNI_TEST_MEMBER_EQUAL(size_) &&
         OMNI_TEST_MEMBER_EQUAL(displayInput_) &&
         OMNI_TEST_MEMBER_EQUAL(displayGrid_) &&
         OMNI_TEST_MEMBER_EQUAL(displayProjectors_) &&
         OMNI_TEST_MEMBER_EQUAL(displayProjectedAreas_) &&
         OMNI_TEST_MEMBER_EQUAL(editMode_) &&
         OMNI_TEST_MEMBER_EQUAL(rotateMode_) &&
         OMNI_TEST_MEMBER_EQUAL(moveMode_) &&
         OMNI_TEST_MEMBER_EQUAL(lights_) &&
         OMNI_TEST_MEMBER_EQUAL(cameras_);
     }

void omni::visual::primaryContextSwitch ( ContextFunctor f )

Switch to primary context to create OpenGL objects like textures etc.

                                                 {
       if (!QOpenGLContext::globalShareContext()) return;
       contextSwitch(QOpenGLContext::globalShareContext(), f);
     }

void omni::visual::useShader	(	QOpenGLShaderProgram &	_s,
		std::function< void(UniformHandler &)>	f
	)

Use shader with and do uniform assignment and drawing inside functor.

                                                         {
       withCurrentContext([&](QOpenGLFunctions& _gl) {
         _s.bind();
         {
           UniformHandler _handler(_gl, _s);
           f(_handler);
 
           // Destructor of handler is called here implicitly
           // by RAII to unbind all textures
         }
         _s.release();
       });
     }

void omni::visual::withCurrentContext ( ContextFunctor f )

Do OpenGL operations with current context, if it exists.

     {
       auto _currentContext = QOpenGLContext::currentContext();
       if (!_currentContext) return;
 
       if (!_currentContext->isValid()) {
         return;
       }
       QOpenGLFunctions glFuncs(_currentContext);
       f(glFuncs);
     }

Namespaces

Data Structures

Typedefs

Enumerations

Functions

Detailed Description

Typedef Documentation

Enumeration Type Documentation

Function Documentation