GUI::RealSpace::Canvas Class Reference

Description

Definition at line 34 of file canvas.h.

Inheritance diagram for GUI::RealSpace::Canvas:

Collaboration diagram for GUI::RealSpace::Canvas:

Public Member Functions
	Canvas ()
	~Canvas () override
Camera *	cam ()
void	defaultView ()
Model *	getModel ()
void	horizontalCameraTurn (float angle)
void	setBgColor (QColor const &)
void	setCamera (Camera *)
void	setModel (Model *)
void	setProgram (Program *)
void	sideView ()
void	topView ()
void	verticalCameraTurn (float angle)

Private Types
enum	{ btnNONE , btnTURN , btnZOOM }

Private Member Functions
void	cleanup ()
void	draw (QColor const &, QMatrix4x4 const &, Geometry const &)
void	initializeGL () override
bool	isInitialized () const
void	mouseMoveEvent (QMouseEvent *) override
void	mousePressEvent (QMouseEvent *) override
void	mouseReleaseEvent (QMouseEvent *) override
void	paintGL () override
void	releaseBuffer (Geometry const *)
void	releaseBuffers ()
void	resizeGL (int, int) override
void	setCamera (bool full=true)
QVector3D	unproject (QPoint const &)
void	wheelEvent (QWheelEvent *) override

Private Attributes
float	aspectRatio
QHash< Geometry const *, Buffer * >	buffers
Camera *	camera
float	colorBgB
float	colorBgG
float	colorBgR
int	currentZoomLevel
QPoint	e_last
bool	m_isInitializedGL
QMatrix4x4	matModel
QMatrix4x4	matProj
Model *	model
QMetaObject::Connection	modelUpdated
enum GUI::RealSpace::Canvas:: { ... }	mouseButton
Program *	program
QRect	viewport

Friends
class	Object

Member Enumeration Documentation

anonymous enum

anonymous enum

private

Enumerator
btnNONE
btnTURN
btnZOOM

Definition at line 76 of file canvas.h.

{ btnNONE, btnTURN, btnZOOM } mouseButton;

Constructor & Destructor Documentation

Canvas()

GUI::RealSpace::Canvas::Canvas

(

)

Definition at line 53 of file canvas.cpp.

    : aspectRatio(1)
    , colorBgR(1)
    , colorBgG(1)
    , colorBgB(1)
    , currentZoomLevel(0)
    , camera(nullptr)
    , program(nullptr)
    , model(nullptr)
    , m_isInitializedGL(false)
{
    connect(&geometryStore(), &GeometryStore::deletingGeometry, this, &Canvas::releaseBuffer);
}

References GUI::RealSpace::GeometryStore::deletingGeometry(), GUI::RealSpace::geometryStore(), and releaseBuffer().

Here is the call graph for this function:

~Canvas()

GUI::RealSpace::Canvas::~Canvas ( )

override

Definition at line 67 of file canvas.cpp.

{
    cleanup();
}

References cleanup().

Here is the call graph for this function:

Member Function Documentation

cam()

Camera* GUI::RealSpace::Canvas::cam ( )

inline

Definition at line 59 of file canvas.h.

{ return camera; }

References camera.

Referenced by GUI::RealSpace::Widget3D::cam(), and RealSpaceCanvas::updateScene().

cleanup()

void GUI::RealSpace::Canvas::cleanup ( )

private

Definition at line 297 of file canvas.cpp.

{
    makeCurrent();
 
    releaseBuffers();
 
    delete camera;
    camera = nullptr;
    delete program;
    program = nullptr;
 
    m_isInitializedGL = false;
    doneCurrent();
}

References camera, m_isInitializedGL, program, and releaseBuffers().

Referenced by ~Canvas(), and initializeGL().

Here is the call graph for this function:

defaultView()

void GUI::RealSpace::Canvas::defaultView

(

)

Definition at line 317 of file canvas.cpp.

{
    // Default view
    if (isInitialized()) {
        GUI::RealSpace::Camera::Position defPos(
            GUI::RealSpace::Vector3D(0, cameraDefaultPosY, cameraDefaultPosZ), // eye
            GUI::RealSpace::Vector3D(0, 0, 0),                                 // center
            GUI::RealSpace::Vector3D::_z);                                     // up
 
        // Default position of camera for 3D axes and object are the same
        camera->lookAt3DAxes(defPos);
        camera->lookAt(defPos);
        camera->endTransform(true);
 
        currentZoomLevel = 0; // reset zoom level to default value
        update();
    }
}

References GUI::RealSpace::Vector3D::_z, camera, currentZoomLevel, GUI::RealSpace::Camera::endTransform(), isInitialized(), GUI::RealSpace::Camera::lookAt(), and GUI::RealSpace::Camera::lookAt3DAxes().

Referenced by GUI::RealSpace::Widget3D::defaultView(), RealSpaceCanvas::defaultView(), and RealSpaceCanvas::showEvent().

Here is the call graph for this function:

draw()

void GUI::RealSpace::Canvas::draw ( QColor const &  color, QMatrix4x4 const &  mat, Geometry const &  geo  )

private

Definition at line 282 of file canvas.cpp.

{
    auto it = buffers.find(&geo);
    Buffer* buf;
    if (buffers.end() == it)
        buffers.insert(&geo, buf = new Buffer(geo)); // created on demand
    else
        buf = *it;
 
    ASSERT(program);
    program->set(color);
    program->set(mat);
    buf->draw();
}

References buffers, GUI::RealSpace::Buffer::draw(), program, and GUI::RealSpace::Program::set().

Referenced by GUI::RealSpace::Object::draw().

Here is the call graph for this function:

getModel()

Model * GUI::RealSpace::Canvas::getModel

(

)

Definition at line 112 of file canvas.cpp.

{
    return model;
}

References model.

Referenced by GUI::RealSpace::Widget3D::model().

horizontalCameraTurn()

void GUI::RealSpace::Canvas::horizontalCameraTurn

(

float

angle

)

Definition at line 391 of file canvas.cpp.

{
    if (isInitialized()) {
        float theta = angle * static_cast<float>(M_PI / 180.0); // in radians
 
        // Horizontal camera turn for 3D axes
        Camera::Position initial_pos3DAxes = camera->getPos3DAxes();
 
        GUI::RealSpace::Vector3D v_eye3DAxes = initial_pos3DAxes.eye; // camera's position vector
        GUI::RealSpace::Vector3D v_ctr3DAxes = initial_pos3DAxes.ctr;
        GUI::RealSpace::Vector3D v_up3DAxes = initial_pos3DAxes.up;
 
        GUI::RealSpace::Vector3D v_axis3DAxes = v_up3DAxes.normalized(); // normalized rotation axis
 
        // Rotating camera's position (eye) about up vector
        GUI::RealSpace::Vector3D v_rot_eye3DAxes =
            v_up3DAxes * (1 - std::cos(theta)) * dot(v_axis3DAxes, v_eye3DAxes)
            + v_eye3DAxes * std::cos(theta) + cross(v_axis3DAxes, v_eye3DAxes) * std::sin(theta);
 
        Camera::Position rotated_pos3DAxes(v_rot_eye3DAxes, v_ctr3DAxes, v_up3DAxes);
 
        camera->lookAt3DAxes(rotated_pos3DAxes);
 
        // Horizontal camera turn for 3D object
        Camera::Position initial_pos = camera->getPos();
 
        GUI::RealSpace::Vector3D v_eye = initial_pos.eye; // camera's position vector
        GUI::RealSpace::Vector3D v_ctr = initial_pos.ctr;
        GUI::RealSpace::Vector3D v_up = initial_pos.up;
 
        GUI::RealSpace::Vector3D v_axis = v_up.normalized(); // normalized rotation axis
 
        // Rotating camera's position (eye) about up vector
        GUI::RealSpace::Vector3D v_rot_eye = v_up * (1 - std::cos(theta)) * dot(v_axis, v_eye)
                                             + v_eye * std::cos(theta)
                                             + cross(v_axis, v_eye) * std::sin(theta);
 
        Camera::Position rotated_pos(v_rot_eye, v_ctr, v_up);
 
        camera->lookAt(rotated_pos);
 
        camera->endTransform(true);
    }
}

References camera, GUI::RealSpace::cross(), GUI::RealSpace::Camera::Position::ctr, GUI::RealSpace::dot(), GUI::RealSpace::Camera::endTransform(), GUI::RealSpace::Camera::Position::eye, GUI::RealSpace::Camera::getPos(), GUI::RealSpace::Camera::getPos3DAxes(), isInitialized(), GUI::RealSpace::Camera::lookAt(), GUI::RealSpace::Camera::lookAt3DAxes(), GUI::RealSpace::Vector3D::normalized(), and GUI::RealSpace::Camera::Position::up.

Referenced by mouseMoveEvent().

Here is the call graph for this function:

initializeGL()

void GUI::RealSpace::Canvas::initializeGL ( )

overrideprivate

Definition at line 128 of file canvas.cpp.

{
    setCamera((camera = new Camera));
    setProgram((program = new Program));
 
    connect(context(), &QOpenGLContext::aboutToBeDestroyed, this, &Canvas::cleanup);
 
    initializeOpenGLFunctions();
    glEnable(GL_DEPTH_TEST);
    glEnable(GL_CULL_FACE);
    m_isInitializedGL = true;
}

References camera, cleanup(), m_isInitializedGL, program, setCamera(), and setProgram().

Here is the call graph for this function:

isInitialized()

bool GUI::RealSpace::Canvas::isInitialized ( ) const

private

Definition at line 312 of file canvas.cpp.

{
    return m_isInitializedGL && model != nullptr;
}

References m_isInitializedGL, and model.

Referenced by defaultView(), horizontalCameraTurn(), sideView(), topView(), and verticalCameraTurn().

mouseMoveEvent()

void GUI::RealSpace::Canvas::mouseMoveEvent ( QMouseEvent *  e )

overrideprivate

Definition at line 214 of file canvas.cpp.

{
    if (camera) {
        float delta_x = e->pos().x() - e_last.x();
        float delta_y = e->pos().y() - e_last.y();
 
        switch (mouseButton) {
        case btnTURN: {
            if (delta_x != 0)
                horizontalCameraTurn(-delta_x * rot_speed_h); // -ve for consistency with Blender
 
            if (delta_y != 0)
                verticalCameraTurn(-delta_y * rot_speed_v); // -ve for consistency with Blender
 
            e_last = e->pos();
            break;
        }
        case btnZOOM: {
            float d = (e->y() - e_last.y()) / float(viewport.height());
            camera->zoomBy(1 + d);
            break;
        }
        default:
            break;
        }
 
        update();
    }
}

References btnTURN, btnZOOM, camera, e_last, horizontalCameraTurn(), mouseButton, verticalCameraTurn(), viewport, and GUI::RealSpace::Camera::zoomBy().

Here is the call graph for this function:

mousePressEvent()

void GUI::RealSpace::Canvas::mousePressEvent ( QMouseEvent *  e )

overrideprivate

Definition at line 193 of file canvas.cpp.

{
    switch (e->button()) {
    case Qt::LeftButton:
        mouseButton = btnTURN;
        break;
    case Qt::RightButton:
        mouseButton = btnZOOM;
        break;
    default:
        mouseButton = btnNONE;
        break;
    }
 
    if (camera) {
        matModel = camera->matModel;
        matProj = camera->matProj;
        e_last = e->pos();
    }
}

References btnNONE, btnTURN, btnZOOM, camera, e_last, GUI::RealSpace::Camera::matModel, matModel, GUI::RealSpace::Camera::matProj, matProj, and mouseButton.

mouseReleaseEvent()

void GUI::RealSpace::Canvas::mouseReleaseEvent ( QMouseEvent *  )

overrideprivate

Definition at line 244 of file canvas.cpp.

{
    if (camera) {
        camera->endTransform(true);
        update();
    }
}

References camera, and GUI::RealSpace::Camera::endTransform().

Here is the call graph for this function:

paintGL()

void GUI::RealSpace::Canvas::paintGL ( )

overrideprivate

Definition at line 149 of file canvas.cpp.

{
    glClearColor(colorBgR, colorBgG, colorBgB, 1);
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 
    if (camera && program && model) {
        program->init();
        program->bind();
        program->set(*camera);
        program->setAxis(false);
 
        // opaque objects
        model->draw(*this);
 
        // transparent objects
        glEnable(GL_BLEND);
        glDepthMask(false);
        glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
        model->drawBlend(*this);
        glDisable(GL_BLEND);
        glDepthMask(true);
 
        if (!model->modelIsEmpty()) {
            // Draw 3D coordinate axes in lower left corner
            glViewport(0, 0, viewport.width() / 9, viewport.height() / 5);
            QMatrix4x4 matObject3DAxes;
            matObject3DAxes.setToIdentity(); // 3D axes transformation matrix is Identity
            program->set(matObject3DAxes);
            program->setMatModel(camera->matModel3DAxes);
            program->setAxis(true);
            std::unique_ptr<Buffer3DAxes> buf3DAxes(new Buffer3DAxes());
            buf3DAxes->draw3DAxes();
        }
 
        program->release();
    }
}

References camera, colorBgB, colorBgG, colorBgR, GUI::RealSpace::Model::draw(), GUI::RealSpace::Model::drawBlend(), GUI::RealSpace::Program::init(), GUI::RealSpace::Camera::matModel3DAxes, model, GUI::RealSpace::Model::modelIsEmpty(), program, GUI::RealSpace::Program::set(), GUI::RealSpace::Program::setAxis(), GUI::RealSpace::Program::setMatModel(), and viewport.

Here is the call graph for this function:

releaseBuffer()

void GUI::RealSpace::Canvas::releaseBuffer ( Geometry const *  g )

private

Definition at line 270 of file canvas.cpp.

{
    delete buffers.take(g);
}

References buffers.

Referenced by Canvas().

releaseBuffers()

void GUI::RealSpace::Canvas::releaseBuffers ( )

private

Definition at line 275 of file canvas.cpp.

{
    for (auto* b : buffers.values())
        delete b;
    buffers.clear();
}

References buffers.

Referenced by cleanup(), and setModel().

resizeGL()

void GUI::RealSpace::Canvas::resizeGL ( int  w, int  h  )

overrideprivate

Definition at line 141 of file canvas.cpp.

{
    int w1 = qMax(1, w), h1 = qMax(1, h);
    viewport.setRect(0, 0, w1, h1);
    aspectRatio = float(w1) / float(h1);
    setCamera(false);
}

References aspectRatio, setCamera(), and viewport.

Here is the call graph for this function:

setBgColor()

void GUI::RealSpace::Canvas::setBgColor

(

QColor const &

c

)

Definition at line 72 of file canvas.cpp.

{
    colorBgR = float(c.redF());
    colorBgG = float(c.greenF());
    colorBgB = float(c.blueF());
    update();
}

References colorBgB, colorBgG, and colorBgR.

Referenced by GUI::RealSpace::Widget3D::setBackground().

setCamera() [1/2]

void GUI::RealSpace::Canvas::setCamera ( bool  full = true )

private

Definition at line 117 of file canvas.cpp.

{
    if (camera) {
        camera->setAspectRatio(aspectRatio);
        if (full && model)
            camera->lookAt(model->defCamPos);
    }
 
    update();
}

References aspectRatio, camera, GUI::RealSpace::Model::defCamPos, GUI::RealSpace::Camera::lookAt(), model, and GUI::RealSpace::Camera::setAspectRatio().

Here is the call graph for this function:

setCamera() [2/2]

void GUI::RealSpace::Canvas::setCamera

(

Camera *

c

)

Definition at line 80 of file canvas.cpp.

{
    camera = c;
    setCamera();
}

References camera.

Referenced by initializeGL(), resizeGL(), and setModel().

setModel()

void GUI::RealSpace::Canvas::setModel

(

Model *

m

)

Definition at line 94 of file canvas.cpp.

{
    releaseBuffers();
 
    disconnect(modelUpdated);
    model = m;
    modelUpdated = connect(model, &Model::updated, [this](bool withEye) {
        if (withEye)
            setCamera();
        else
            update();
    });
 
    setCamera();
    // connect(camera, &GUI::RealSpace::Camera::updated, model, &Model::cameraUpdated);
    camera->set();
}

References camera, model, modelUpdated, releaseBuffers(), GUI::RealSpace::Camera::set(), setCamera(), and GUI::RealSpace::Model::updated().

Referenced by RealSpaceCanvas::resetScene(), GUI::RealSpace::Widget3D::setModel(), and RealSpaceCanvas::updateScene().

Here is the call graph for this function:

setProgram()

void GUI::RealSpace::Canvas::setProgram

(

Program *

p

)

Definition at line 86 of file canvas.cpp.

{
    program = p;
    if (program)
        program->needsInit();
    update();
}

References GUI::RealSpace::Program::needsInit(), and program.

Referenced by initializeGL().

Here is the call graph for this function:

sideView()

void GUI::RealSpace::Canvas::sideView

(

)

Definition at line 336 of file canvas.cpp.

{
    // Side view at current zoom level
    if (isInitialized()) {
        GUI::RealSpace::Vector3D eye(0, cameraDefaultPosY, 0);
 
        // Side view 3D axes is zoom scale independent
        camera->lookAt3DAxes(
            GUI::RealSpace::Camera::Position(eye,                               // eye
                                             GUI::RealSpace::Vector3D(0, 0, 0), // center
                                             GUI::RealSpace::Vector3D::_z));    // up
 
        // Side view 3D object is zoom scale dependent
        if (currentZoomLevel >= 0)
            eye.y *= std::pow(ZoomInScale(), std::abs(currentZoomLevel));
        else
            eye.y *= std::pow(ZoomOutScale(), std::abs(currentZoomLevel));
 
        camera->lookAt(GUI::RealSpace::Camera::Position(eye,                               // eye
                                                        GUI::RealSpace::Vector3D(0, 0, 0), // center
                                                        GUI::RealSpace::Vector3D::_z));    // up
 
        camera->endTransform(true);
        update();
    }
}

References GUI::RealSpace::Vector3D::_z, camera, currentZoomLevel, GUI::RealSpace::Camera::endTransform(), isInitialized(), GUI::RealSpace::Camera::lookAt(), GUI::RealSpace::Camera::lookAt3DAxes(), and GUI::RealSpace::Vector3D::y.

Referenced by GUI::RealSpace::Widget3D::sideView(), and RealSpaceCanvas::sideView().

Here is the call graph for this function:

topView()

void GUI::RealSpace::Canvas::topView

(

)

Definition at line 363 of file canvas.cpp.

{
    // Top view at current zoom level
    if (isInitialized()) {
        // Setting a tiny offset in y value of eye such that eye and up vectors are not parallel
        GUI::RealSpace::Vector3D eye(0, -0.5, -cameraDefaultPosY);
 
        // Top view 3D axes is zoom scale independent
        camera->lookAt3DAxes(
            GUI::RealSpace::Camera::Position(eye,                               // eye
                                             GUI::RealSpace::Vector3D(0, 0, 0), // center
                                             GUI::RealSpace::Vector3D::_z));    // up
 
        // Top view 3D object is zoom scale dependent
        if (currentZoomLevel >= 0)
            eye.z *= std::pow(ZoomInScale(), std::abs(currentZoomLevel));
        else
            eye.z *= std::pow(ZoomOutScale(), std::abs(currentZoomLevel));
 
        camera->lookAt(GUI::RealSpace::Camera::Position(eye,                               // eye
                                                        GUI::RealSpace::Vector3D(0, 0, 0), // center
                                                        GUI::RealSpace::Vector3D::_z));    // up
 
        camera->endTransform(true);
        update();
    }
}

References GUI::RealSpace::Vector3D::_z, camera, currentZoomLevel, GUI::RealSpace::Camera::endTransform(), isInitialized(), GUI::RealSpace::Camera::lookAt(), GUI::RealSpace::Camera::lookAt3DAxes(), and GUI::RealSpace::Vector3D::z.

Referenced by GUI::RealSpace::Widget3D::topView(), and RealSpaceCanvas::topView().

Here is the call graph for this function:

unproject()

QVector3D GUI::RealSpace::Canvas::unproject ( QPoint const &  p )

private

Definition at line 187 of file canvas.cpp.

{
    float x = p.x(), y = viewport.height() - p.y();
    return QVector3D(x, y, 1).unproject(matModel, matProj, viewport);
}

References matModel, matProj, and viewport.

verticalCameraTurn()

void GUI::RealSpace::Canvas::verticalCameraTurn

(

float

angle

)

Definition at line 436 of file canvas.cpp.

{
    if (isInitialized()) {
        float theta = angle * static_cast<float>(M_PI / 180.0); // in radians
 
        // Vertical camera turn for 3D axes
        Camera::Position initial_pos3DAxes = camera->getPos3DAxes();
 
        GUI::RealSpace::Vector3D v_eye3DAxes = initial_pos3DAxes.eye; // camera's position vector
        GUI::RealSpace::Vector3D v_ctr3DAxes = initial_pos3DAxes.ctr;
        GUI::RealSpace::Vector3D v_up3DAxes = initial_pos3DAxes.up;
 
        GUI::RealSpace::Vector3D v_axis3DAxes =
            cross(v_up3DAxes, v_eye3DAxes).normalized(); // normalized rotation axis
 
        // Rotating camera's position (eye) about an axis perpendicular to up and eye vectors
        GUI::RealSpace::Vector3D v_rot_eye3DAxes =
            v_up3DAxes * (1 - std::cos(theta)) * dot(v_axis3DAxes, v_eye3DAxes)
            + v_eye3DAxes * std::cos(theta) + cross(v_axis3DAxes, v_eye3DAxes) * std::sin(theta);
 
        Camera::Position rotated_pos3DAxes(v_rot_eye3DAxes, v_ctr3DAxes, v_up3DAxes);
 
        camera->lookAt3DAxes(rotated_pos3DAxes);
 
        // Vertical camera turn for 3D object
        Camera::Position initial_pos = camera->getPos();
 
        GUI::RealSpace::Vector3D v_eye = initial_pos.eye; // camera's position vector
        GUI::RealSpace::Vector3D v_ctr = initial_pos.ctr;
        GUI::RealSpace::Vector3D v_up = initial_pos.up;
 
        GUI::RealSpace::Vector3D v_axis =
            cross(v_up, v_eye).normalized(); // normalized rotation axis
 
        // Rotating camera's position (eye) about an axis perpendicular to up and eye vectors
        GUI::RealSpace::Vector3D v_rot_eye = v_up * (1 - std::cos(theta)) * dot(v_axis, v_eye)
                                             + v_eye * std::cos(theta)
                                             + cross(v_axis, v_eye) * std::sin(theta);
 
        Camera::Position rotated_pos(v_rot_eye, v_ctr, v_up);
 
        camera->lookAt(rotated_pos);
 
        camera->endTransform(true);
    }
}

References camera, GUI::RealSpace::cross(), GUI::RealSpace::Camera::Position::ctr, GUI::RealSpace::dot(), GUI::RealSpace::Camera::endTransform(), GUI::RealSpace::Camera::Position::eye, GUI::RealSpace::Camera::getPos(), GUI::RealSpace::Camera::getPos3DAxes(), isInitialized(), GUI::RealSpace::Camera::lookAt(), GUI::RealSpace::Camera::lookAt3DAxes(), GUI::RealSpace::Vector3D::normalized(), and GUI::RealSpace::Camera::Position::up.

Referenced by mouseMoveEvent().

Here is the call graph for this function:

wheelEvent()

void GUI::RealSpace::Canvas::wheelEvent ( QWheelEvent *  e )

overrideprivate

Definition at line 252 of file canvas.cpp.

{
    if (camera) {
        if (e->angleDelta().y() < 0) {
            // Zoom in
            camera->zoomBy(ZoomInScale());
            currentZoomLevel += 1;
        } else {
            // Zoom out
            camera->zoomBy(ZoomOutScale());
            currentZoomLevel -= 1;
        }
        camera->endTransform(true);
        update();
    }
    e->accept(); // disabling the event from propagating further to the parent widgets
}

References camera, currentZoomLevel, GUI::RealSpace::Camera::endTransform(), and GUI::RealSpace::Camera::zoomBy().

Here is the call graph for this function:

Friends And Related Function Documentation

Object

friend class Object

friend

Definition at line 36 of file canvas.h.

Member Data Documentation

aspectRatio

float GUI::RealSpace::Canvas::aspectRatio

private

Definition at line 63 of file canvas.h.

Referenced by resizeGL(), and setCamera().

buffers

QHash<Geometry const*, Buffer*> GUI::RealSpace::Canvas::buffers

private

Definition at line 88 of file canvas.h.

Referenced by draw(), releaseBuffer(), and releaseBuffers().

camera

Camera* GUI::RealSpace::Canvas::camera

private

Definition at line 82 of file canvas.h.

Referenced by cam(), cleanup(), defaultView(), horizontalCameraTurn(), initializeGL(), mouseMoveEvent(), mousePressEvent(), mouseReleaseEvent(), paintGL(), setCamera(), setModel(), sideView(), topView(), verticalCameraTurn(), and wheelEvent().

colorBgB

float GUI::RealSpace::Canvas::colorBgB

private

Definition at line 63 of file canvas.h.

Referenced by paintGL(), and setBgColor().

colorBgG

float GUI::RealSpace::Canvas::colorBgG

private

Definition at line 63 of file canvas.h.

Referenced by paintGL(), and setBgColor().

colorBgR

float GUI::RealSpace::Canvas::colorBgR

private

Definition at line 63 of file canvas.h.

Referenced by paintGL(), and setBgColor().

currentZoomLevel

int GUI::RealSpace::Canvas::currentZoomLevel

private

Definition at line 64 of file canvas.h.

Referenced by defaultView(), sideView(), topView(), and wheelEvent().

e_last

QPoint GUI::RealSpace::Canvas::e_last

private

Definition at line 72 of file canvas.h.

Referenced by mouseMoveEvent(), and mousePressEvent().

m_isInitializedGL

bool GUI::RealSpace::Canvas::m_isInitializedGL

private

Definition at line 97 of file canvas.h.

Referenced by cleanup(), initializeGL(), and isInitialized().

matModel

QMatrix4x4 GUI::RealSpace::Canvas::matModel

private

Definition at line 73 of file canvas.h.

Referenced by mousePressEvent(), and unproject().

matProj

QMatrix4x4 GUI::RealSpace::Canvas::matProj

private

Definition at line 73 of file canvas.h.

Referenced by mousePressEvent(), and unproject().

model

Model* GUI::RealSpace::Canvas::model

private

Definition at line 84 of file canvas.h.

Referenced by getModel(), isInitialized(), paintGL(), setCamera(), and setModel().

modelUpdated

QMetaObject::Connection GUI::RealSpace::Canvas::modelUpdated

private

Definition at line 86 of file canvas.h.

Referenced by setModel().

enum { ... } GUI::RealSpace::Canvas::mouseButton

Referenced by mouseMoveEvent(), and mousePressEvent().

program

Program* GUI::RealSpace::Canvas::program

private

Definition at line 83 of file canvas.h.

Referenced by cleanup(), draw(), initializeGL(), paintGL(), and setProgram().

viewport

QRect GUI::RealSpace::Canvas::viewport

private

Definition at line 62 of file canvas.h.

Referenced by mouseMoveEvent(), paintGL(), resizeGL(), and unproject().

---

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

• /home/build/builds/o5h8MZZm/0/mlz/bornagain/GUI/ba3d/view/canvas.h
• /home/build/builds/o5h8MZZm/0/mlz/bornagain/GUI/ba3d/view/canvas.cpp