libs/qglview/glwidget.cpp

#include "glwidget.h"
#include "renderer_simple.h"
#include "renderer_deferred_shading.h"
#include <QVBoxLayout>


GLWidget::GLWidget(QWidget *parent) : QWidget(parent) {
	view_ = new QGLView();
	view_->setFlag(Qt::FramelessWindowHint);
	container = QWidget::createWindowContainer(view_, this);
	lay = new QVBoxLayout(this);
	lay->addWidget(container);
	lay->setContentsMargins(0, 0, 0, 0);
	lay->setSpacing(0);
	setMouseTracking(true);
	setWindowIcon(QIcon("://icons/qglview.png"));
	connect(view_, &QGLView::doubleClick, this, &GLWidget::viewDoubleClicked);
}


QColor GLWidget::backColor() const {
	return view_->backColor();
}


qreal GLWidget::lineWidth() const {
	return view_->lineWidth();
}


qreal GLWidget::FOV() const {
	return view_->FOV();
}


qreal GLWidget::depthStart() const {
	return view_->depthStart();
}


qreal GLWidget::depthEnd() const {
	return view_->depthEnd();
}


QColor GLWidget::ambientColor() const {
	return view_->ambientColor();
}


bool GLWidget::isLightEnabled() const {
	return view_->isLightEnabled();
}


bool GLWidget::isGrabMouseEnabled() const {
	return view_->isGrabMouseEnabled();
}


bool GLWidget::isMouseRotateEnabled() const {
	return view_->isMouseRotateEnabled();
}


bool GLWidget::isMouseSelectionEnabled() const {
	return view_->isMouseSelectionEnabled();
}


bool GLWidget::isCameraOrbit() const
{
	return view_->isCameraOrbit();
}


bool GLWidget::isHoverHaloEnabled() const {
	return view_->isHoverHaloEnabled();
}


QColor GLWidget::hoverHaloColor() const {
	return view_->hoverHaloColor();
}


qreal GLWidget::hoverHaloFillAlpha() const {
	return view_->hoverHaloFillAlpha();
}


bool GLWidget::isSelectionHaloEnabled() const {
	return view_->isSelectionHaloEnabled();
}


QColor GLWidget::selectionHaloColor() const {
	return view_->selectionHaloColor();
}


qreal GLWidget::selectionHaloFillAlpha() const {
	return view_->selectionHaloFillAlpha();
}


void GLWidget::addObject(GLObjectBase * o) {
    view_->addObject(o);
}


QByteArray GLWidget::saveCamera() {
    ChunkStream cs;
    const Camera * c = view()->camera();
    cs.add(1, c->posX());
    cs.add(2, c->posY());
    cs.add(3, c->posZ());
    cs.add(4, c->aim().x());
    cs.add(5, c->aim().y());
    cs.add(6, c->aim().z());
    cs.add(7, c->angleZ());
    cs.add(8, c->angleXY());
    cs.add(9, c->angleRoll());
    cs.add(10, c->FOV());
    return cs.data();
}


void GLWidget::restoreCamera(const QByteArray &ba) {
    if (ba.isEmpty()) return;
    ChunkStream cs(ba);
    QVector3D pos, aim, ang;
    while (!cs.atEnd()) {
        switch (cs.read()) {
        case 1: pos.setX(cs.getData<float>()); break;
        case 2: pos.setY(cs.getData<float>()); break;
        case 3: pos.setZ(cs.getData<float>()); break;
        case 4: aim.setX(cs.getData<float>()); break;
        case 5: aim.setY(cs.getData<float>()); break;
        case 6: aim.setZ(cs.getData<float>()); break;
        case 7: ang.setZ(cs.getData<float>()); break;
        case 8: ang.setY(cs.getData<float>()); break;
        case 9: ang.setX(cs.getData<float>()); break;
        case 10: setFOV(cs.getData<float>()); break;
        default: break;
        }
    }
    view()->camera()->setPos(pos);
    view()->camera()->setAim(aim);
    view()->camera()->setAngles(ang);
}


void GLWidget::stop() {
	view_->stop();
}


void GLWidget::start(float freq, GLRendererBase * r) {
	if (r == nullptr) r = new RendererSimple(view_);
	GLRendererBase * pr = nullptr;
	view_->setRenderer(r, &pr);
	if (pr != nullptr && pr != r) delete pr;
	view_->start(freq);
}


void GLWidget::setBackColor(const QColor & c) {
	view_->setBackColor(c);
}


void GLWidget::setLineWidth(const qreal & arg) {
	view_->setLineWidth(arg);
}


void GLWidget::setFOV(const qreal & arg) {
	view_->setFOV(arg);
}


void GLWidget::setDepthStart(const qreal & arg) {
	view_->setDepthStart(arg);
}


void GLWidget::setDepthEnd(const qreal & arg) {
	view_->setDepthEnd(arg);
}


void GLWidget::setAmbientColor(const QColor & arg) {
	view_->setAmbientColor(arg);
}


void GLWidget::setLightEnabled(const bool & arg) {
	view_->setLightEnabled(arg);
}


void GLWidget::setGrabMouseEnabled(const bool & arg) {
	view_->setGrabMouseEnabled(arg);
}


void GLWidget::setMouseRotateEnabled(const bool & arg) {
	view_->setMouseRotateEnabled(arg);
}


void GLWidget::setMouseSelectionEnabled(const bool & arg) {
	view_->setMouseSelectionEnabled(arg);
}


void GLWidget::setCameraOrbit(const bool & arg) {
	view_->setCameraOrbit(arg);
}


void GLWidget::setHoverHaloEnabled(const bool & arg) {
	view_->setHoverHaloEnabled(arg);
}


void GLWidget::setHoverHaloColor(const QColor & arg) {
	view_->setHoverHaloColor(arg);
}


void GLWidget::setHoverHaloFillAlpha(const qreal & arg) {
	view_->setHoverHaloFillAlpha(arg);
}


void GLWidget::setSelectionHaloEnabled(const bool & arg) {
	view_->setSelectionHaloEnabled(arg);
}


void GLWidget::setSelectionHaloColor(const QColor & arg) {
	view_->setSelectionHaloColor(arg);
}


void GLWidget::setSelectionHaloFillAlpha(const qreal & arg) {
	view_->setSelectionHaloFillAlpha(arg);
}


void GLWidget::viewDoubleClicked() {
//	qDebug() << "click widget!!";
	if (view_->windowState() == Qt::WindowFullScreen) {
//		view_->hide();
		container = QWidget::createWindowContainer(view_, this);
		lay->addWidget(container);
		container->show();
//		show();
	} else {
//		hide();
		view_->setParent(nullptr);
		view_->showFullScreen();
		lay->removeWidget(container);
	}
//	qDebug() << "click widge done!";
}