RealSpace::Canvas Class Reference

Inheritance diagram for RealSpace::Canvas:

Collaboration diagram for RealSpace::Canvas:

Public Member Functions
	Canvas ()
	~Canvas ()
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 ()
bool	isInitialized () const
void	mouseMoveEvent (QMouseEvent *)
void	mousePressEvent (QMouseEvent *)
void	mouseReleaseEvent (QMouseEvent *)
void	paintGL ()
void	releaseBuffer (Geometry const *)
void	releaseBuffers ()
void	resizeGL (int, int)
void	setCamera (bool full=true)
QVector3D	unproject (QPoint const &)
void	wheelEvent (QWheelEvent *)

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 RealSpace::Canvas:: { ... }	mouseButton
Program *	program
QRect	viewport

Friends
class	Object

Detailed Description

Definition at line 34 of file canvas.h.

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()

RealSpace::Canvas::Canvas

(

)

Definition at line 51 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 RealSpace::GeometryStore::deletingGeometry(), RealSpace::geometryStore(), and releaseBuffer().

Here is the call graph for this function:

~Canvas()

RealSpace::Canvas::~Canvas

(

)

Definition at line 65 of file canvas.cpp.

{
    cleanup();
}

References cleanup().

Here is the call graph for this function:

Member Function Documentation

cam()

Camera* RealSpace::Canvas::cam ( )

inline

Definition at line 59 of file canvas.h.

{ return camera; }

References camera.

Referenced by RealSpace::Widget3D::cam().

cleanup()

void RealSpace::Canvas::cleanup ( )

private

Definition at line 295 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 RealSpace::Canvas::defaultView

(

)

Definition at line 315 of file canvas.cpp.

{
    // Default view
    if (isInitialized()) {
        RealSpace::Camera::Position defPos(
            RealSpace::Vector3D(0, cameraDefaultPosY, cameraDefaultPosZ), // eye
            RealSpace::Vector3D(0, 0, 0),                                 // center
            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 RealSpace::Vector3D::_z, camera, currentZoomLevel, RealSpace::Camera::endTransform(), isInitialized(), RealSpace::Camera::lookAt(), and RealSpace::Camera::lookAt3DAxes().

Referenced by RealSpace::Widget3D::defaultView().

Here is the call graph for this function:

draw()

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

private

Definition at line 280 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 ASSERT, buffers, RealSpace::Buffer::draw(), program, and RealSpace::Program::set().

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

Here is the call graph for this function:

getModel()

Model * RealSpace::Canvas::getModel

(

)

Definition at line 110 of file canvas.cpp.

{
    return model;
}

References model.

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

horizontalCameraTurn()

void RealSpace::Canvas::horizontalCameraTurn

(

float

angle

)

Definition at line 387 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();
 
        RealSpace::Vector3D v_eye3DAxes = initial_pos3DAxes.eye; // camera's position vector
        RealSpace::Vector3D v_ctr3DAxes = initial_pos3DAxes.ctr;
        RealSpace::Vector3D v_up3DAxes = initial_pos3DAxes.up;
 
        RealSpace::Vector3D v_axis3DAxes = v_up3DAxes.normalized(); // normalized rotation axis
 
        // Rotating camera's position (eye) about up vector
        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();
 
        RealSpace::Vector3D v_eye = initial_pos.eye; // camera's position vector
        RealSpace::Vector3D v_ctr = initial_pos.ctr;
        RealSpace::Vector3D v_up = initial_pos.up;
 
        RealSpace::Vector3D v_axis = v_up.normalized(); // normalized rotation axis
 
        // Rotating camera's position (eye) about up vector
        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, RealSpace::cross(), RealSpace::Camera::Position::ctr, RealSpace::dot(), RealSpace::Camera::endTransform(), RealSpace::Camera::Position::eye, RealSpace::Camera::getPos(), RealSpace::Camera::getPos3DAxes(), isInitialized(), RealSpace::Camera::lookAt(), RealSpace::Camera::lookAt3DAxes(), M_PI, RealSpace::Vector3D::normalized(), and RealSpace::Camera::Position::up.

Referenced by mouseMoveEvent().

Here is the call graph for this function:

initializeGL()

void RealSpace::Canvas::initializeGL ( )

private

Definition at line 126 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 RealSpace::Canvas::isInitialized ( ) const

private

Definition at line 310 of file canvas.cpp.

{
    return m_isInitializedGL && model != nullptr;
}

References m_isInitializedGL, and model.

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

mouseMoveEvent()

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

private

Definition at line 212 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 RealSpace::Camera::zoomBy().

Here is the call graph for this function:

mousePressEvent()

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

private

Definition at line 191 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, RealSpace::Camera::matModel, matModel, RealSpace::Camera::matProj, matProj, and mouseButton.

mouseReleaseEvent()

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

private

Definition at line 242 of file canvas.cpp.

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

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

Here is the call graph for this function:

paintGL()

void RealSpace::Canvas::paintGL ( )

private

Definition at line 147 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, RealSpace::Model::draw(), RealSpace::Model::drawBlend(), RealSpace::Program::init(), RealSpace::Camera::matModel3DAxes, model, RealSpace::Model::modelIsEmpty(), program, RealSpace::Program::set(), RealSpace::Program::setAxis(), RealSpace::Program::setMatModel(), and viewport.

Here is the call graph for this function:

releaseBuffer()

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

private

Definition at line 268 of file canvas.cpp.

{
    delete buffers.take(g);
}

References buffers.

Referenced by Canvas().

releaseBuffers()

void RealSpace::Canvas::releaseBuffers ( )

private

Definition at line 273 of file canvas.cpp.

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

References buffers.

Referenced by cleanup(), and setModel().

resizeGL()

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

private

Definition at line 139 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 RealSpace::Canvas::setBgColor

(

QColor const &

c

)

Definition at line 70 of file canvas.cpp.

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

References colorBgB, colorBgG, and colorBgR.

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

setCamera() [1/2]

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

private

Definition at line 115 of file canvas.cpp.

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

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

Here is the call graph for this function:

setCamera() [2/2]

void RealSpace::Canvas::setCamera

(

Camera *

c

)

Definition at line 78 of file canvas.cpp.

{
    camera = c;
    setCamera();
}

References camera.

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

setModel()

void RealSpace::Canvas::setModel

(

Model *

m

)

Definition at line 92 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, &RealSpace::Camera::updated, model, &Model::cameraUpdated);
    camera->set();
}

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

Referenced by RealSpace::Widget3D::setModel().

Here is the call graph for this function:

setProgram()

void RealSpace::Canvas::setProgram

(

Program *

p

)

Definition at line 84 of file canvas.cpp.

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

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

Referenced by initializeGL().

Here is the call graph for this function:

sideView()

void RealSpace::Canvas::sideView

(

)

Definition at line 334 of file canvas.cpp.

{
    // Side view at current zoom level
    if (isInitialized()) {
        RealSpace::Vector3D eye(0, cameraDefaultPosY, 0);
 
        // Side view 3D axes is zoom scale independent
        camera->lookAt3DAxes(RealSpace::Camera::Position(eye,                          // eye
                                                         RealSpace::Vector3D(0, 0, 0), // center
                                                         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(RealSpace::Camera::Position(eye,                          // eye
                                                   RealSpace::Vector3D(0, 0, 0), // center
                                                   RealSpace::Vector3D::_z));    // up
 
        camera->endTransform(true);
        update();
    }
}

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

Referenced by RealSpace::Widget3D::sideView().

Here is the call graph for this function:

topView()

void RealSpace::Canvas::topView

(

)

Definition at line 360 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
        RealSpace::Vector3D eye(0, -0.5, -cameraDefaultPosY);
 
        // Top view 3D axes is zoom scale independent
        camera->lookAt3DAxes(RealSpace::Camera::Position(eye,                          // eye
                                                         RealSpace::Vector3D(0, 0, 0), // center
                                                         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(RealSpace::Camera::Position(eye,                          // eye
                                                   RealSpace::Vector3D(0, 0, 0), // center
                                                   RealSpace::Vector3D::_z));    // up
 
        camera->endTransform(true);
        update();
    }
}

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

Referenced by RealSpace::Widget3D::topView().

Here is the call graph for this function:

unproject()

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

private

Definition at line 185 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 RealSpace::Canvas::verticalCameraTurn

(

float

angle

)

Definition at line 433 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();
 
        RealSpace::Vector3D v_eye3DAxes = initial_pos3DAxes.eye; // camera's position vector
        RealSpace::Vector3D v_ctr3DAxes = initial_pos3DAxes.ctr;
        RealSpace::Vector3D v_up3DAxes = initial_pos3DAxes.up;
 
        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
        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();
 
        RealSpace::Vector3D v_eye = initial_pos.eye; // camera's position vector
        RealSpace::Vector3D v_ctr = initial_pos.ctr;
        RealSpace::Vector3D v_up = initial_pos.up;
 
        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
        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, RealSpace::cross(), RealSpace::Camera::Position::ctr, RealSpace::dot(), RealSpace::Camera::endTransform(), RealSpace::Camera::Position::eye, RealSpace::Camera::getPos(), RealSpace::Camera::getPos3DAxes(), isInitialized(), RealSpace::Camera::lookAt(), RealSpace::Camera::lookAt3DAxes(), M_PI, RealSpace::Vector3D::normalized(), and RealSpace::Camera::Position::up.

Referenced by mouseMoveEvent().

Here is the call graph for this function:

wheelEvent()

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

private

Definition at line 250 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, RealSpace::Camera::endTransform(), and 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 RealSpace::Canvas::aspectRatio

private

Definition at line 63 of file canvas.h.

Referenced by resizeGL(), and setCamera().

buffers

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

private

Definition at line 88 of file canvas.h.

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

camera

Camera* 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 RealSpace::Canvas::colorBgB

private

Definition at line 63 of file canvas.h.

Referenced by paintGL(), and setBgColor().

colorBgG

float RealSpace::Canvas::colorBgG

private

Definition at line 63 of file canvas.h.

Referenced by paintGL(), and setBgColor().

colorBgR

float RealSpace::Canvas::colorBgR

private

Definition at line 63 of file canvas.h.

Referenced by paintGL(), and setBgColor().

currentZoomLevel

int RealSpace::Canvas::currentZoomLevel

private

Definition at line 64 of file canvas.h.

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

e_last

QPoint RealSpace::Canvas::e_last

private

Definition at line 72 of file canvas.h.

Referenced by mouseMoveEvent(), and mousePressEvent().

m_isInitializedGL

bool RealSpace::Canvas::m_isInitializedGL

private

Definition at line 97 of file canvas.h.

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

matModel

QMatrix4x4 RealSpace::Canvas::matModel

private

Definition at line 73 of file canvas.h.

Referenced by mousePressEvent(), and unproject().

matProj

QMatrix4x4 RealSpace::Canvas::matProj

private

Definition at line 73 of file canvas.h.

Referenced by mousePressEvent(), and unproject().

model

Model* RealSpace::Canvas::model

private

Definition at line 84 of file canvas.h.

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

modelUpdated

QMetaObject::Connection RealSpace::Canvas::modelUpdated

private

Definition at line 86 of file canvas.h.

Referenced by setModel().

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

Referenced by mouseMoveEvent(), and mousePressEvent().

program

Program* RealSpace::Canvas::program

private

Definition at line 83 of file canvas.h.

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

viewport

QRect 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/www/ba/GUI/ba3d/view/canvas.h
• /home/www/ba/GUI/ba3d/view/canvas.cpp