version 1.3.0

new QGLViewSettings structure for all view parameters
API for load/save it, automatic sync with ViewEditor
some clean

CMakeLists.txt

@@ -26,8 +26,8 @@ else()
 	include(SHSTKQtMacros)
 	
 	set(QGLEngine_MAJOR    1)
-	set(QGLEngine_MINOR    2)
+	set(QGLEngine_MINOR    3)
-	set(QGLEngine_REVISION 1)
+	set(QGLEngine_REVISION 0)
 	set(QGLEngine_SUFFIX   "rc")
 	set(QGLEngine_COMPANY  SHS)
 	set(QGLEngine_DOMAIN   org.SHS)

src/core/CMakeLists.txt

@@ -22,8 +22,9 @@ set_deploy_property(${PROJECT_NAME} ${QGLEngine_LIB_TYPE}
 	COMPANY  "${QGLEngine_COMPANY}"
 	INFO "QGLEngine core library")
 make_rc(${PROJECT_NAME} _RC)
-pip_code_model(CCM "render/renderer.h" OPTIONS "-DQGLENGINE_CORE_EXPORT" "-Es")
+pip_code_model(CCM0 "render/renderer.h" OPTIONS "-DQGLENGINE_CORE_EXPORT" "-Es" NAME "ccm_renderer")
-qad_add_library(${PROJECT_NAME} ${QGLEngine_LIB_TYPE} out_CPP ${_RC} ${CCM})
+pip_code_model(CCM1 "view/qglview_settings.h" OPTIONS "-DQGLENGINE_CORE_EXPORT" "-Ss" NAME "ccm_qglview")
+qad_add_library(${PROJECT_NAME} ${QGLEngine_LIB_TYPE} out_CPP ${_RC} ${CCM0} ${CCM1})
 qad_generate_export_header(${PROJECT_NAME})
 list(APPEND out_HDR "${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}_export.h")
 qad_target_include_directories(${PROJECT_NAME} PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}" ${_includes})

src/core/render/renderer.cpp

@@ -19,7 +19,7 @@
 #define GL_GLEXT_PROTOTYPES
 #include "renderer.h"
 
-#include "ccm_qglengine_core.h"
+#include "ccm_renderer.h"
 #include "glmesh.h"
 #include "glshaders.h"
 #include "gltexture_manager.h"
@@ -394,9 +394,9 @@ void Renderer::renderLight(int first_wr_buff, bool clear_only) {
 			prog->setUniformValue("shadows_enabled", view->shadows());
 			if (view->shadows()) {
 				prog->setUniformValue("shadow_size", view->shadow_map_size);
-				prog->setUniformValue("soft_shadows_enabled", view->soft_shadows);
+				prog->setUniformValue("soft_shadows_enabled", view->settings.soft_shadows);
-				prog->setUniformValue("soft_shadows_samples", view->soft_shadows_samples);
+				prog->setUniformValue("soft_shadows_samples", view->settings.soft_shadows_samples);
-				prog->setUniformValue("soft_shadows_quality", view->soft_shadows_quality);
+				prog->setUniformValue("soft_shadows_quality", view->settings.soft_shadows_quality);
 				GLenum filter = view->softShadows() ? GL_NEAREST : GL_LINEAR;
 				shadow_maps_cone.bind(view, tarShadowsCone);
 				view->glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_MIN_FILTER, filter);
@@ -661,10 +661,11 @@ void Renderer::renderScene() {
 
 	/// tonemapping
 	phase.begin("tonemap");
+	tone_proc.enabled = view->settings.autoExposure;
 	tone_proc.process();
 	auto free = getFreePlanes(0);
 	if (bindShader(srTonemapPass, &prog)) {
-		prog->setUniformValue("gamma", gamma_);
+		prog->setUniformValue("gamma", view->settings.gamma);
 		prog->setUniformValue("frame_max", tone_proc.frameMax());
 		// qDebug() << tone_proc.frameMax();
 		fbo_out.bindColorTexture(prev_write_plane, 0);
@@ -676,7 +677,7 @@ void Renderer::renderScene() {
 
 	/// FXAA
 	phase.begin("fxaa");
-	if (view->FXAA_) {
+	if (view->settings.FXAA) {
 		prog = shader_fxaa;
 		if (bindShader(prog)) {
 			auto free = getFreePlanes(0);

src/core/render/renderer.h

@@ -133,7 +133,6 @@ protected:
 	QVector<int> getFreePlanes(int count);
 
 private:
-	float gamma_ = 1.f;
 	int camera_light_mode, cur_write_plane = 0, prev_write_plane = 0;
 	int grab_mipmap = 0, grab_mipmap_f = 0;
 	bool edit_mode, need_init_shaders, need_render_sum, __reinit_debug;

src/core/view/glwidget.cpp

@@ -62,11 +62,6 @@ qreal GLWidget::depthStart() const {
 }
 
 
-bool GLWidget::isLightEnabled() const {
-	return view_->isLightEnabled();
-}
-
-
 bool GLWidget::isGrabMouseEnabled() const {
 	return view_->isGrabMouseEnabled();
 }
@@ -157,11 +152,6 @@ void GLWidget::setDepthStart(const qreal & arg) {
 }
 
 
-void GLWidget::setLightEnabled(const bool & arg) {
-	view_->setLightEnabled(arg);
-}
-
-
 void GLWidget::setGrabMouseEnabled(const bool & arg) {
 	view_->setGrabMouseEnabled(arg);
 }

src/core/view/glwidget.h

@@ -56,7 +56,6 @@ public:
 	qreal FOV() const;
 	qreal depthStart() const;
 	QColor ambientColor() const;
-	bool isLightEnabled() const;
 	bool isGrabMouseEnabled() const;
 	bool isMouseRotateEnabled() const;
 	bool isMouseSelectionEnabled() const;
@@ -78,7 +77,6 @@ public slots:
 	void setLineWidth(const qreal & arg);
 	void setFOV(const qreal & arg);
 	void setDepthStart(const qreal & arg);
-	void setLightEnabled(const bool & arg);
 	void setGrabMouseEnabled(const bool & arg);
 	void setMouseRotateEnabled(const bool & arg);
 	void setMouseSelectionEnabled(const bool & arg);

src/core/view/qglview.cpp

@@ -18,6 +18,7 @@
 
 #include "qglview.h"
 
+#include "ccm_qglview.h"
 #include "glmesh.h"
 #include "gltexture_manager.h"
 
@@ -25,6 +26,8 @@
 #include <QKeyEvent>
 #include <QOpenGLTexture>
 #include <chunkstream.h>
+#include <pichunkstream.h>
+#include <piqt.h>
 #include <qad_types.h>
 
 using namespace QGLEngineShaders;
@@ -32,28 +35,7 @@ using namespace QGLEngineShaders;
 
 QGLView::QGLView(): OpenGLWindow(), renderer_(this), mouse(this) {
 	setIcon(QIcon(":/icons/qglview.png"));
-	is_init              = false;
+	shadow_map_size = QSize(512, 512);
-	timer                = 0;
-	hoverHaloColor_      = QColor(195, 140, 255);
-	selectionHaloColor_  = QColor(175, 255, 140);
-	lineWidth_           = 1.;
-	max_anisotropic      = 1;
-	max_texture_chanels  = 8;
-	lightEnabled_        = true;
-	shaders_supported    = false;
-	FXAA_                = false;
-	fps_cnt              = 0;
-	soft_shadows_quality = 1.;
-	soft_shadows_samples = 32;
-	soft_shadows         = false;
-	shadows_             = false;
-	fps_tm = fps_  = 0.;
-	fogColor_      = Qt::darkGray;
-	fogDensity_    = 0.;
-	fogDecay_      = 10.;
-	hoverHaloFill_ = selectionHaloFill_ = 0.15f;
-	render_mode                         = rmFill;
-	shadow_map_size                     = QSize(512, 512);
 	// setFeature(qglFXAA, false);
 	// setFeature(qglAnisotropicLevel, 8);
 	// setFeature(qglEyeAccomodationEnabled, false);
@@ -78,9 +60,7 @@ QGLView::QGLView(): OpenGLWindow(), renderer_(this), mouse(this) {
 	// setFeature(qglDepthOfFieldAutoFocusSpeed, 0.1);
 	// setFeature(qglDepthOfFieldFocus, 1.);
 	// setFeature(qglDepthOfFieldDiaphragm, 8.);
-	hoverHalo_ = selectionHalo_ = true;
+	scene_          = new Scene();
-	fogEnabled_ = shaders_bind = false;
-	scene_                     = new Scene();
 	connect(scene_, SIGNAL(selectionChanged()), this, SIGNAL(selectionChanged()));
 	connect(scene_, SIGNAL(__destroyed()), this, SLOT(__destroyed()));
 	connect(scene_, SIGNAL(__objectDeleted(ObjectBase *)), this, SLOT(__objectDeleted(ObjectBase *)));
@@ -163,8 +143,8 @@ void QGLView::render() {
 	if (!framebuffer_size.isEmpty()) render_size = framebuffer_size;
 	resizeGL(render_size.width(), render_size.height());
 	emit glBeginPaint();
-	glPointSize(lineWidth_);
+	glPointSize(settings.lineWidth);
-	glLineWidth(lineWidth_);
+	glLineWidth(settings.lineWidth);
 	QSizeF fbo_sz                       = renderer_.fbo_ds.size();
 	renderer_.rend_selection.size_coeff = {double(fbo_sz.width()) / pixelWidth(), double(fbo_sz.height()) / pixelHeight()};
 	renderer_.mouse_pos                 = mapFromGlobal(QCursor::pos()) * devicePixelRatio();
@@ -204,7 +184,6 @@ void QGLView::initialize() {
 
 void QGLView::checkCaps() {
 	glGetIntegerv(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, &max_anisotropic);
-	shaders_supported = QOpenGLShaderProgram::hasOpenGLShaderPrograms();
 }
 
 
@@ -285,39 +264,25 @@ void QGLView::restoreCamera(const QByteArray & ba) {
 }
 
 
-void QGLView::setGrabImageMipmap(int level) {
-	renderer_.grab_mipmap = level;
-}
-
-
-void QGLView::setGrabImageFMipmap(int level) {
-	renderer_.grab_mipmap_f = level;
-}
-
-
-void QGLView::setShadowMapSize(QSize sz) {
-	shadow_map_size = sz;
-}
-
-
 void QGLView::setTextureMapSize(QSize sz) {
 	renderer_.maps_size = sz;
 	renderer_.markReloadMaterials();
 }
 
 
-QSize QGLView::shadowMapSize() const {
-	return shadow_map_size;
-}
-
-
-QSize QGLView::textureMapSize() const {
-	return renderer_.maps_size;
-}
-
-
 QSize QGLView::actualFramebufferSize() const {
 	QSize render_size = pixelSize();
 	if (!framebuffer_size.isEmpty()) render_size = framebuffer_size;
 	return render_size;
 }
+
+
+QByteArray QGLView::saveSetting() const {
+	return piqSerialize(settings);
+}
+
+
+void QGLView::loadSetting(QByteArray data) {
+	settings = piqDeserialize<QGLViewSettings>(data);
+	emit settingsLoaded();
+}

src/core/view/qglview.h

@@ -26,6 +26,7 @@
 #include "mouse_controller.h"
 #include "openglwindow.h"
 #include "qglengine_core_export.h"
+#include "qglview_settings.h"
 #include "renderer.h"
 
 #include <QElapsedTimer>
@@ -43,7 +44,6 @@ class QGLENGINE_CORE_EXPORT QGLView
 	Q_PROPERTY(float gamma READ gamma WRITE setGamma)
 	Q_PROPERTY(bool autoExposure READ autoExposure WRITE setAutoExposure)
 	Q_PROPERTY(QColor fogColor READ fogColor WRITE setFogColor)
-	Q_PROPERTY(bool fogEnabled READ isFogEnabled WRITE setFogEnabled)
 	Q_PROPERTY(float fogDensity READ fogDensity WRITE setFogDensity)
 	Q_PROPERTY(float fogDecay READ fogDecay WRITE setFogDecay)
 	Q_PROPERTY(int renderMode READ renderMode WRITE setRenderMode)
@@ -86,35 +86,33 @@ public:
 	void stop();
 	void start(float freq = 0.);
 
-	float lineWidth() const { return lineWidth_; }
+	float lineWidth() const { return settings.lineWidth; }
 	float FOV() const { return camera()->FOV(); }
 	float depthStart() const { return camera()->depthStart(); }
 	float currentFPS() const { return fps_; }
-	float gamma() const { return renderer_.gamma_; }
+	float gamma() const { return settings.gamma; }
-	bool autoExposure() const { return renderer_.tone_proc.enabled; }
+	bool autoExposure() const { return settings.autoExposure; }
 	int maxAnisotropicLevel() const { return max_anisotropic; }
 	QString environmentMapFile() const { return renderer_.tex_env.fileHDR(); }
-	bool FXAA() const { return FXAA_; }
+	bool FXAA() const { return settings.FXAA; }
-	void setFXAA(bool on) { FXAA_ = on; }
+	void setFXAA(bool on) { settings.FXAA = on; }
 
-	QColor fogColor() const { return fogColor_; }
+	QColor fogColor() const { return settings.fogColor; }
-	float fogDensity() const { return fogDensity_; }
+	float fogDensity() const { return settings.fogDensity; }
-	float fogDecay() const { return fogDecay_; }
+	float fogDecay() const { return settings.fogDecay; }
-	bool isFogEnabled() const { return fogEnabled_; }
-	bool isLightEnabled() const { return lightEnabled_; }
 	bool isGrabMouseEnabled() const { return mouse.isGrabMouseEnabled(); }
 	bool isMouseRotateEnabled() const { return mouse.isMouseRotateEnabled(); }
 	bool isMouseSelectionEnabled() const { return mouse.isMouseSelectionEnabled(); }
 	bool isCameraOrbit() const { return mouse.isCameraOrbit(); }
-	bool isHoverHaloEnabled() const { return hoverHalo_; }
+	bool isHoverHaloEnabled() const { return settings.hoverHalo; }
-	QColor hoverHaloColor() const { return hoverHaloColor_; }
+	QColor hoverHaloColor() const { return settings.hoverHaloColor; }
-	float hoverHaloFillAlpha() const { return hoverHaloFill_; }
+	float hoverHaloFillAlpha() const { return settings.hoverHaloFill; }
-	bool isSelectionHaloEnabled() const { return selectionHalo_; }
+	bool isSelectionHaloEnabled() const { return settings.selectionHalo; }
-	QColor selectionHaloColor() const { return selectionHaloColor_; }
+	QColor selectionHaloColor() const { return settings.selectionHaloColor; }
-	float selectionHaloFillAlpha() const { return selectionHaloFill_; }
+	float selectionHaloFillAlpha() const { return settings.selectionHaloFill; }
 
-	int renderMode() const { return (int)render_mode; }
+	int renderMode() const { return settings.render_mode; }
-	void setRenderMode(int mode) { render_mode = (RenderMode)mode; }
+	void setRenderMode(int mode) { settings.render_mode = mode; }
 
 	bool isServiceMode() const { return renderer_.edit_mode; }
 	void setServiceMode(bool yes) { renderer_.edit_mode = yes; }
@@ -164,27 +162,30 @@ public:
 	void setGrabFormats(QFlags<Renderer::GrabFormat> f) { grab_formats = f; }
 	QImage getImage() const { return renderer_.getImage(); }
 	QVector<QVector4D> getImageF() const { return renderer_.getImageF(); }
-	void setGrabImageMipmap(int level);
+	void setGrabImageMipmap(int level) { renderer_.grab_mipmap = level; }
-	void setGrabImageFMipmap(int level);
+	void setGrabImageFMipmap(int level) { renderer_.grab_mipmap_f = level; }
 
-	void setShadowMapSize(QSize sz);
+	void setShadowMapSize(QSize sz) { shadow_map_size = sz; }
 	void setTextureMapSize(QSize sz);
-	QSize shadowMapSize() const;
+	QSize shadowMapSize() const { return shadow_map_size; }
-	QSize textureMapSize() const;
+	QSize textureMapSize() const { return renderer_.maps_size; }
 
 	void setFramebufferSize(QSize sz) { framebuffer_size = sz; }
 	void resetFramebufferSize() { framebuffer_size = QSize(); }
 	QSize framebufferSize() const { return framebuffer_size; }
 	QSize actualFramebufferSize() const;
 
-	int softShadowsSamples() const { return soft_shadows_samples; }
+	int softShadowsSamples() const { return settings.soft_shadows_samples; }
-	void setSoftShadowsSamples(int s) { soft_shadows_samples = s; }
+	void setSoftShadowsSamples(int s) { settings.soft_shadows_samples = s; }
-	float softShadowsQuality() const { return soft_shadows_quality; }
+	float softShadowsQuality() const { return settings.soft_shadows_quality; }
-	void setSoftShadowsQuality(float s) { soft_shadows_quality = s; }
+	void setSoftShadowsQuality(float s) { settings.soft_shadows_quality = s; }
-	bool softShadows() const { return soft_shadows; }
+	bool softShadows() const { return settings.soft_shadows; }
-	void setSoftShadows(bool on) { soft_shadows = on; }
+	void setSoftShadows(bool on) { settings.soft_shadows = on; }
-	bool shadows() const { return shadows_; }
+	bool shadows() const { return settings.shadows; }
-	void setShadows(bool on) { shadows_ = on; }
+	void setShadows(bool on) { settings.shadows = on; }
+
+	QByteArray saveSetting() const;
+	void loadSetting(QByteArray data);
 
 	GLfloat aspect, iaspect;
 	Renderer renderer_;
@@ -218,51 +219,45 @@ private:
 	MouseController mouse;
 	QMenu context_menu;
 	QSet<int> keys_;
-	QColor fogColor_, hoverHaloColor_, selectionHaloColor_;
 	QElapsedTimer time;
-	GLint max_anisotropic, max_texture_chanels;
+	GLint max_anisotropic = 1, max_texture_chanels = 8;
-	RenderMode render_mode;
 	QFlags<Renderer::GrabFormat> grab_formats;
 	QSize prev_size, shadow_map_size, framebuffer_size;
-	float lineWidth_, soft_shadows_quality;
+	QGLViewSettings settings;
-	float fps_, fps_tm, fogDensity_, fogDecay_;
+	float fps_ = 0.f, fps_tm = 0.f;
-	float hoverHaloFill_, selectionHaloFill_, m_motionBlurFactor;
+	float m_motionBlurFactor = 1.f;
-	int timer, fps_cnt, sh_id_loc, soft_shadows_samples;
+	int timer = 0, fps_cnt = 0, sh_id_loc = 0;
-	bool fogEnabled_, lightEnabled_, FXAA_;
+	bool shaders_bind = false;
-	bool shaders_supported, shaders_bind;
+	bool is_init      = false;
-	bool hoverHalo_, selectionHalo_;
-	bool is_init, shadows_, soft_shadows;
 
 private slots:
 	void __destroyed();
 	void __objectDeleted(ObjectBase * o);
 
 public slots:
-	void setLineWidth(const float & arg) { lineWidth_ = arg; }
+	void setLineWidth(const float & arg) { settings.lineWidth = arg; }
 	void setFOV(const float & arg) { camera()->setFOV(arg); }
 	void setDepthStart(const float & arg) { camera()->setDepthStart(arg); }
-	void setGamma(const float & arg) { renderer_.gamma_ = arg; }
+	void setGamma(const float & arg) { settings.gamma = arg; }
-	void setAutoExposure(bool arg) { renderer_.tone_proc.enabled = arg; }
+	void setAutoExposure(bool arg) { settings.autoExposure = arg; }
 	void setEnvironmentMapFile(QString file) {
 		renderer_.tex_env.setFileHDR(file);
 		renderer_.recreateMaterialThumbnails(true);
 	}
-	void setFogColor(const QColor & arg) { fogColor_ = arg; }
+	void setFogColor(const QColor & arg) { settings.fogColor = arg; }
-	void setFogDensity(const float & arg) { fogDensity_ = arg; }
+	void setFogDensity(const float & arg) { settings.fogDensity = arg; }
-	void setFogDecay(const float & arg) { fogDecay_ = arg; }
+	void setFogDecay(const float & arg) { settings.fogDecay = arg; }
-	void setFogEnabled(const bool & arg) { fogEnabled_ = arg; }
-	void setLightEnabled(const bool & arg) { lightEnabled_ = arg; }
 	void setGrabMouseEnabled(const bool & arg) { mouse.setGrabMouseEnabled(arg); }
 	void setMouseRotateEnabled(const bool & arg) { mouse.setMouseRotateEnabled(arg); }
 	void setMouseSelectionEnabled(const bool & arg) { mouse.setMouseSelectionEnabled(arg); }
 	void setCustomMouseMove(const bool & arg) { mouse.setCustomMouseMove(arg); }
 	void setCameraOrbit(const bool & arg) { mouse.setCameraOrbit(arg); }
-	void setHoverHaloEnabled(const bool & arg) { hoverHalo_ = arg; }
+	void setHoverHaloEnabled(const bool & arg) { settings.hoverHalo = arg; }
-	void setHoverHaloColor(const QColor & arg) { hoverHaloColor_ = arg; }
+	void setHoverHaloColor(const QColor & arg) { settings.hoverHaloColor = arg; }
-	void setHoverHaloFillAlpha(const float & arg) { hoverHaloFill_ = arg; }
+	void setHoverHaloFillAlpha(const float & arg) { settings.hoverHaloFill = arg; }
-	void setSelectionHaloEnabled(const bool & arg) { selectionHalo_ = arg; }
+	void setSelectionHaloEnabled(const bool & arg) { settings.selectionHalo = arg; }
-	void setSelectionHaloColor(const QColor & arg) { selectionHaloColor_ = arg; }
+	void setSelectionHaloColor(const QColor & arg) { settings.selectionHaloColor = arg; }
-	void setSelectionHaloFillAlpha(const float & arg) { selectionHaloFill_ = arg; }
+	void setSelectionHaloFillAlpha(const float & arg) { settings.selectionHaloFill = arg; }
 
 	void reloadShaders() { renderer_.reloadShaders(); }
 
@@ -287,6 +282,7 @@ signals:
 	void materialsChanged();
 	void materialThumbnailCreated(Material *);
 	void doubleClick();
+	void settingsLoaded();
 };
 
 #endif // QGLVIEW_H

src/core/view/qglview_settings.h

@@ -0,0 +1,58 @@
+/*
+    QGLView
+    Ivan Pelipenko peri4ko@yandex.ru
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU Lesser General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef qglview_settings_h
+#define qglview_settings_h
+
+#include "qglengine_core_export.h"
+
+#include <QColor>
+#include <QOpenGLFunctions>
+#include <pibase_macros.h>
+
+#define ID(v) PIMETA(id=v)
+
+struct QGLENGINE_CORE_EXPORT QGLViewSettings {
+	ID(1) bool FXAA                   = false;
+	ID(2) int render_mode             = GL_FILL;
+	ID(3) float lineWidth             = 1;
+
+	ID(4) bool hoverHalo              = true;
+	ID(5) float hoverHaloFill         = 0.15f;
+	ID(6) QColor hoverHaloColor       = QColor(195, 140, 255);
+
+	ID(7) bool selectionHalo          = true;
+	ID(8) float selectionHaloFill     = 0.15f;
+	ID(9) QColor selectionHaloColor   = QColor(175, 255, 140);
+
+	ID(10) float fogDensity           = 0.;
+	ID(11) float fogDecay             = 10.;
+	ID(12) QColor fogColor            = Qt::darkGray;
+
+	ID(13) bool shadows               = false;
+	ID(14) bool soft_shadows          = false;
+	ID(15) int soft_shadows_samples   = 32;
+	ID(16) float soft_shadows_quality = 1.;
+
+	ID(17) float gamma                = 1.f;
+	ID(18) bool autoExposure          = false;
+};
+
+#undef ID
+
+#endif

src/widgets/view_editor.cpp

@@ -43,10 +43,29 @@ ViewEditor::ViewEditor(QWidget * parent): QWidget(parent) {
 
 
 void ViewEditor::assignQGLView(QGLView * v) {
+	if (view) {
+		disconnect(view, nullptr, this, nullptr);
+		disconnect(view->scene(), nullptr, this, nullptr);
+	}
 	view = v;
 	if (!view) return;
-	active = false;
+	connect(view, &QGLView::settingsLoaded, this, &ViewEditor::setup);
 	connect(view->scene(), &Scene::presetChanged, this, [this](int p) { ui->labelPreset->setNum(p); });
+	setup();
+}
+
+
+void ViewEditor::changeEvent(QEvent * e) {
+	QWidget::changeEvent(e);
+	switch (e->type()) {
+	case QEvent::LanguageChange: ui->retranslateUi(this); break;
+	default: break;
+	}
+}
+
+
+void ViewEditor::setup() {
+	active = false;
 	ui->labelPreset->setNum(view->scene()->preset());
 	ui->spinFOV->setValue(view->FOV());
 	ui->spinDepthStart->setValue(view->depthStart());
@@ -56,6 +75,8 @@ void ViewEditor::assignQGLView(QGLView * v) {
 	ui->spinSelectionHaloFill->setValue(view->selectionHaloFillAlpha());
 	ui->colorHoverHalo->setColor(view->hoverHaloColor());
 	ui->colorSelectionHalo->setColor(view->selectionHaloColor());
+	ui->spinViewGamma->setValue(view->gamma());
+	ui->checkAutoExposure->setChecked(view->autoExposure());
 	ui->checkFXAA->setChecked(view->FXAA());
 	ui->checkCameraOrbit->setChecked(view->isCameraOrbit());
 	ui->checkCameraLight->setCheckState((Qt::CheckState)view->cameraLightMode());
@@ -85,15 +106,6 @@ void ViewEditor::assignQGLView(QGLView * v) {
 }
 
 
-void ViewEditor::changeEvent(QEvent * e) {
-	QWidget::changeEvent(e);
-	switch (e->type()) {
-	case QEvent::LanguageChange: ui->retranslateUi(this); break;
-	default: break;
-	}
-}
-
-
 void ViewEditor::on_spinFOV_valueChanged(double val) {
 	if (!view || !active) return;
 	view->setFOV(val);

src/widgets/view_editor.h

@@ -43,6 +43,7 @@ protected:
 	bool active    = true;
 
 private slots:
+	void setup();
 	void on_spinFOV_valueChanged(double val);
 	void on_spinDepthStart_valueChanged(double val);
 	void on_spinViewGamma_valueChanged(double val);