.clang-format

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

.clang-format

@@ -135,7 +135,7 @@ JavaScriptWrapImports: true
 KeepEmptyLinesAtTheStartOfBlocks: false
 LambdaBodyIndentation: Signature
 MacroBlockBegin: "PRIVATE_DEFINITION_START|STATIC_INITIALIZER_BEGIN"
-MacroBlockEnd: "PRIVATE_DEFINITION_END|STATIC_INITIALIZER_END"
+MacroBlockEnd: "PRIVATE_DEFINITION_END|PRIVATE_DEFINITION_END_NO_INITIALIZE|STATIC_INITIALIZER_END"
 MaxEmptyLinesToKeep: 2
 NamespaceIndentation: None
 ObjCBinPackProtocolList: Auto
@@ -219,5 +219,6 @@ WhitespaceSensitiveMacros:
   - BOOST_PP_STRINGIZE
   - NS_SWIFT_NAME
   - CF_SWIFT_NAME
+  - PIMETA
 ...
 

CMakeLists.txt

@@ -1,4 +1,4 @@
-cmake_minimum_required(VERSION 3.0)
+cmake_minimum_required(VERSION 3.13)
 cmake_policy(SET CMP0072 NEW) #  FindOpenGL prefers GLVND by default
 if (POLICY CMP0057)
 	cmake_policy(SET CMP0057 NEW)
@@ -26,7 +26,7 @@ else()
 	include(SHSTKQtMacros)
 	
 	set(QGLEngine_MAJOR    1)
-	set(QGLEngine_MINOR    0)
+	set(QGLEngine_MINOR    4)
 	set(QGLEngine_REVISION 0)
 	set(QGLEngine_SUFFIX   "rc")
 	set(QGLEngine_COMPANY  SHS)

shaders/ds_light.glsl

@@ -16,20 +16,21 @@ void main(void) {
 
 in vec3 view_dir, world_dir;
 
-uniform vec2 dt, shadow_size;
+uniform vec2 dt;
 uniform float z_near;
 uniform sampler2D tex_coeff_brdf, tex_noise;
 uniform sampler2D tex_0, tex_1, tex_2, tex_3, tex_4, tex_5, tex_sh;
 //uniform sampler2DShadow tex_shadow[16];
+uniform vec2 shadow_size;
 uniform sampler2DArrayShadow tex_shadows_cone;
 uniform sampler2DArray tex_depths_cone;
 uniform samplerCubeArrayShadow tex_shadows_omni;
 uniform samplerCubeArray tex_depths_omni;
-uniform samplerCube tex_env;
+uniform bool soft_shadows_enabled = false, shadows_enabled = false;
-uniform int lights_start, lights_count, soft_shadows_samples = 16, noise_size = 64;
-uniform bool soft_shadows_enabled = false;
 uniform float soft_shadows_quality = 1.;
-
+uniform int soft_shadows_samples = 16, noise_size = 64;
+uniform samplerCube tex_env;
+uniform int lights_start, lights_count;
 uniform vec4 fog_color = vec4(0.5, 0.5, 0.5, 1.);
 uniform float fog_decay = 10., fog_density = 0.;
 uniform mat3 view_mat;
@@ -43,7 +44,7 @@ ivec2 tc;
 vec4 pos, lpos, shp;
 vec3 li, si, ldir, halfV, bn, bn2, lwdir;
 vec3 normal, geom_normal, vds, vds2;
-float rough_diff, rough_spec, dist, NdotL, NdotH, spot, ldist, diff, spec, sdist, shadow, shadow_dz;
+float rough_diff, rough_spec, dist, NdotL, NdotH, spot, ldist, diff, spec, sdist;
 uint flags;
 
 
@@ -173,7 +174,7 @@ void calcLight(in int index, in vec3 n, in vec3 v) {
 	spot *= light_map_pix.a;
 #endif
 
-	if (int(round(qgl_light_parameter[index].flags)) == 1 && bitfieldExtract(flags, 3, 1) == 1 && (spot > 1E-4)) {
+	if (shadows_enabled && (int(round(qgl_light_parameter[index].flags)) == 1) && (bitfieldExtract(flags, 3, 1) == 1) && (spot > 1E-4)) {
 #ifndef SPOT
 		vec3 odir = -(view_mat * ldir);
 #endif
@@ -300,7 +301,9 @@ void main(void) {
 	vec3 diffuse       = v0.rgb;
 		 normal        = v1.xyz;
 	geom_normal        = v5.xyz;
+#ifndef SPOT
 	vec3 emission      = v3.rgb;
+#endif
 	float alpha        = v0.a;
 	float metalness    = v2.r;
 	float roughness    = v2.g;
@@ -335,7 +338,10 @@ void main(void) {
 	vec3 env_dir = view_mat * reflect(-v, normal);
 	vec3 env_col = textureLod(tex_env, env_dir, sqrt(roughness) * max_lod).rgb * spec_col;
 	
-	vec3 res_col = max(vec3(0.), li * diffuse + si * spec_col + emission);
+	vec3 res_col = max(vec3(0.), li * diffuse + si * spec_col);
+#ifndef SPOT
+	res_col += emission;
+#endif
 	res_col = mix(res_col, env_col, env_spec * reflectivity);
 	
 	if (bitfieldExtract(flags, 1, 1) == 1) {

shaders/rescale.glsl

@@ -0,0 +1,15 @@
+// vert //
+
+void main(void) {
+	qgl_FragTexture = qgl_Texture;
+	gl_Position = qgl_ftransform();
+}
+
+
+// frag //
+
+uniform sampler2D tex_0;
+
+void main(void) {
+	qgl_FragColor = texture(tex_0, qgl_FragTexture.xy);
+}

shaders/selection_apply.glsl

@@ -11,9 +11,10 @@ void main(void) {
 uniform sampler2D fb_out, fb_hover, fb_select;
 
 void main(void) {
-	ivec2 tc = ivec2(gl_FragCoord.xy);
+	//ivec2 tc = ivec2(gl_FragCoord.xy);
+	//vec4 src = texelFetch(fb_out   , tc, 0);
 	vec2 stc = qgl_FragTexture.xy;
-	vec4 src = texelFetch(fb_out   , tc, 0);
+	vec4 src = texture(fb_out   , stc);
 	vec4 hov = texture(fb_hover , stc);
 	vec4 sel = texture(fb_select, stc);
 	src.rgb = clamp(src.rgb, vec3(0), vec3(1));

src/core/CMakeLists.txt

@@ -1,4 +1,4 @@
-cmake_minimum_required(VERSION 3.0)
+cmake_minimum_required(VERSION 3.13)
 project(qglengine_core)
 if (POLICY CMP0017)
 	cmake_policy(SET CMP0017 NEW)
@@ -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/core/glframebuffer.cpp

@@ -141,7 +141,7 @@ void Framebuffer::queryPoints(int index, QRect rect_, GLenum pixel_format) {
 	f->glBindFramebuffer(GL_READ_FRAMEBUFFER, fbo);
 	f->glReadBuffer(GL_COLOR_ATTACHMENT0 + index);
 	pbo.bind(f);
-	f->glReadPixels(rect_.x(), height() - rect_.bottom(), rect_.width(), rect_.height(), GL_RGBA, pixel_format, 0);
+	f->glReadPixels(rect_.x(), height() - rect_.bottom() - 1, rect_.width(), rect_.height(), GL_RGBA, pixel_format, 0);
 	pbo_queried = rect_.width() * rect_.height();
 	pbo.release(f);
 }
@@ -152,6 +152,11 @@ void Framebuffer::queryImage(int index) {
 }
 
 
+void Framebuffer::queryImageF(int index) {
+	queryPoints(index, rect(), GL_FLOAT);
+}
+
+
 uint Framebuffer::getPoint() const {
 	if (!pbo.isInit() || (pbo_queried == 0)) return 0;
 	uint ret = 0;
@@ -222,7 +227,16 @@ void Framebuffer::blit(int index_from, GLuint fb_to, int index_to, QRect from, Q
 	f->glBindFramebuffer(GL_READ_FRAMEBUFFER, fbo);
 	f->glReadBuffer(GL_COLOR_ATTACHMENT0 + index_from);
 	f->glDrawBuffers(1, &e);
-	f->glBlitFramebuffer(from.x(), from.y(), from.right(), from.bottom(), to.x(), to.y(), to.right(), to.bottom(), mask, filter);
+	f->glBlitFramebuffer(from.x(),
+						 from.y(),
+						 from.right() + 1,
+						 from.bottom() + 1,
+						 to.x(),
+						 to.y(),
+						 to.right() + 1,
+						 to.bottom() + 1,
+						 mask,
+						 filter);
 }
 
 

src/core/core/glframebuffer.h

@@ -48,6 +48,7 @@ public:
 	void queryPoint(int index, QPoint p);
 	void queryPoints(int index, QRect rect, GLenum pixel_format = GL_UNSIGNED_BYTE);
 	void queryImage(int index);
+	void queryImageF(int index);
 	uint getPoint() const;
 	QVector<uint> getPointsByte() const;
 	QVector<QVector4D> getPointsFloat() const;

src/core/core/glframebuffer_mipmap.cpp

@@ -37,6 +37,12 @@ void FramebufferMipmap::setIndexFrom(int index) {
 }
 
 
+void FramebufferMipmap::enablePixelBuffer() {
+	for (int i = 0; i < fbo.size(); ++i)
+		fbo[i]->enablePixelBuffer();
+}
+
+
 void FramebufferMipmap::resize() {
 	QSize sz = src_fb.size();
 	for (int i = 0; i < fbo.size(); ++i) {

src/core/core/glframebuffer_mipmap.h

@@ -37,6 +37,7 @@ public:
 	QRect rect(int level) const { return fbo[level]->rect(); }
 	void setIndexFrom(int index);
 
+	void enablePixelBuffer();
 	void resize();
 	void create();
 	void reinit();

src/core/core/glmesh.cpp

@@ -172,12 +172,24 @@ bool Mesh::rebuffer(QOpenGLExtraFunctions * f) {
 	buffer_geom.load(f, data_.constData(), gsize);
 
 	buffer_ind.bind(f);
-	if (geom_type == GL_TRIANGLES) {
+	switch (geom_type) {
+	case GL_TRIANGLES:
 		buffer_ind.resize(f, tsize);
 		buffer_ind.load(f, triangles_.constData(), tsize);
-	} else {
+		break;
+	case GL_LINES:
 		buffer_ind.resize(f, lsize);
 		buffer_ind.load(f, lines_.constData(), lsize);
+		break;
+	case GL_POINTS: {
+		QVector<GLint> points;
+		points.resize(vertices_.size());
+		for (int i = 0; i < vertices_.size(); ++i)
+			points[i] = i;
+		int psize = points.size() * sizeof(GLint);
+		buffer_ind.resize(f, psize);
+		buffer_ind.load(f, points.constData(), psize);
+	} break;
 	}
 
 	return !isEmpty();
@@ -192,10 +204,12 @@ void Mesh::draw(QOpenGLExtraFunctions * f, int count, int type) {
 
 	VertexObject * vao = vaoByType(type);
 	vao->bindBuffers(f, buffer_geom, buffer_ind);
-	if (geom_type == GL_TRIANGLES)
+	switch (geom_type) {
-		vao->draw(f, geom_type, triangles_.size() * 3, count);
+	case GL_TRIANGLES: vao->draw(f, geom_type, triangles_.size() * 3, count); break;
-	else
+	case GL_LINES: vao->draw(f, geom_type, lines_.size() * 2, count); break;
-		vao->draw(f, geom_type, lines_.size() * 2, count);
+	case GL_POINTS: vao->draw(f, geom_type, vertices_.size(), count); break;
+	default: break;
+	}
 }
 
 

src/core/core/gltransform.cpp

@@ -161,6 +161,14 @@ inline void decomposeQMatrix4x4(const QMatrix4x4 & m, QVector3D & position, QVec
 Transform::Transform(): m_scale(1.0f, 1.0f, 1.0f), m_translation(), m_eulerRotationAngles(), m_matrixDirty(false) {}
 
 
+Transform::Transform(const Transform & t) {
+	m_scale               = t.m_scale;
+	m_translation         = t.m_translation;
+	m_eulerRotationAngles = t.m_eulerRotationAngles;
+	m_matrixDirty         = true;
+}
+
+
 Transform & Transform::operator=(const Transform & t) {
 	m_scale               = t.m_scale;
 	m_translation         = t.m_translation;

src/core/core/gltransform.h

@@ -32,6 +32,7 @@ class QGLENGINE_CORE_EXPORT Transform {
 
 public:
 	Transform();
+	Transform(const Transform & t);
 	Transform & operator=(const Transform & t);
 
 	float scale() const;

src/core/core/gltypes.h

@@ -196,6 +196,9 @@ inline QColor operator/(const QColor & c, float v) {
 }
 
 
+inline QVector4D color2vector(const QColor & c) {
+	return QVector4D(c.redF(), c.greenF(), c.blueF(), c.alphaF());
+}
 inline void qglColor(const QColor & c) {
 	glColor4f(c.redF(), c.greenF(), c.blueF(), c.alphaF());
 }

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"
@@ -31,6 +31,8 @@
 #include <piqt.h>
 #include <qad_types.h>
 
+#define SHADERS_DIR ":/qglengine"
+
 
 using namespace QGLEngineShaders;
 
@@ -45,7 +47,9 @@ Renderer::Renderer(QGLView * view_)
 	, rend_service(this)
 	, rend_selection(this)
 	, tone_proc(this)
-	, tex_env(view_, 512) {
+	, tex_env(view_, 512)
+	, img_mips(fbo_out, obrLighting, 4)
+	, img_f_mips(fbo_out, obrLighting, 4) {
 	mat_norm_to_tex_coord.scale(0.5, 0.5);
 	mat_norm_to_tex_coord.translate(1, 1);
 	mat_proj_90 = glMatrixPerspective(90., 1., 0.1);
@@ -96,11 +100,13 @@ Renderer::Renderer(QGLView * view_)
 	shader_files[srShadowConePass]          = "shadow.glsl";
 	shader_files[srShadowOmniPass]          = "shadow.glsl";
 
+	shader_files[srRescale]                 = "rescale.glsl";
+
 	shader_defines[srGeometrySolidPass] << "SOLID";
 	shader_defines[srLightSpotPass] << "SPOT";
 	shader_defines[srShadowOmniPass] << "OMNI";
 
-	PICodeInfo::EnumInfo * obre = PICodeInfo::enumsInfo->value("Renderer::DeferredBufferRole");
+	PICodeInfo::EnumInfo * obre = PICODEINFO::enums().value("Renderer::DeferredBufferRole");
 	if (obre) {
 		for (auto e: obre->members) {
 			obr_defines += "#define " + PI2QString(e.name) + " " + QString::number(e.value) + "\n";
@@ -133,8 +139,12 @@ void Renderer::init(int width, int height) {
 	shadow_maps_omni.reinit();
 	depth_maps_cone.reinit();
 	depth_maps_omni.reinit();
+	img_mips.reinit();
+	img_f_mips.reinit();
+	img_mips.enablePixelBuffer();
+	img_f_mips.enablePixelBuffer();
 	resize(width, height);
-	rend_mat.init(width, height);
+	rend_mat.init(256, 256);
 	rend_service.init(width, height);
 	rend_selection.init(width, height);
 	tone_proc.init();
@@ -143,17 +153,19 @@ void Renderer::init(int width, int height) {
 	initCoeffTextures();
 	markReloadTextures();
 	tex_env.init();
-	if (is_grabbing) fbo_out.enablePixelBuffer();
+	fbo_out.enablePixelBuffer();
 	need_init_shaders = true;
 }
 
 
 void Renderer::resize(int width, int height) {
-	rend_mat.resize(width, height);
+	rend_mat.resize(256, 256);
 	rend_service.resize(width, height);
 	rend_selection.resize(width, height);
 	fbo_ds.resize(width, height);
 	fbo_out.resize(width, height);
+	img_mips.resize();
+	img_f_mips.resize();
 	tone_proc.resize();
 }
 
@@ -167,7 +179,7 @@ void Renderer::reloadShaders() {
 	shader_fxaa = nullptr;
 	if (tone_proc.shader_sum) delete tone_proc.shader_sum;
 	tone_proc.shader_sum = nullptr;
-	QString dir          = ":/shaders/";
+	QString dir          = SHADERS_DIR "/shaders/";
 	while (it.hasNext()) {
 		it.next();
 		loadShadersMulti(shaders[it.key()], dir + it.value(), true, shader_defines.value(it.key()), obr_defines);
@@ -221,6 +233,10 @@ void Renderer::initShaders() {
 		prog->setUniformValue("tex_coeff_brdf", trCoeffBRDF);
 		prog->setUniformValue("tex_env", trEnvironment);
 		setUniformMaps(prog);
+		prog->setUniformValue("tex_shadows_cone", (int)tarShadowsCone);
+		prog->setUniformValue("tex_shadows_omni", (int)tarShadowsOmni);
+		prog->setUniformValue("tex_depths_cone", (int)tarDepthsCone);
+		prog->setUniformValue("tex_depths_omni", (int)tarDepthsOmni);
 	}
 	if (bindShader(srFinalPass, &prog)) {
 		prog->setUniformValue("tex_g1", 0);
@@ -238,6 +254,9 @@ void Renderer::initShaders() {
 		prog->setUniformValue("tex_0", 0);
 		prog->setUniformValue("tex_sum", 1);
 	}
+	if (bindShader(srRescale, &prog)) {
+		prog->setUniformValue("tex_0", 0);
+	}
 }
 
 
@@ -293,6 +312,24 @@ void Renderer::fillObjectsBuffer(const ObjectBaseList & ol, RenderPass pass) {
 }
 
 
+void Renderer::setConeShadowMatrix() {
+	auto cone_ll = cur_lights.value(Light::Cone);
+	for (int i = 0; i < cone_ll.size(); ++i) {
+		Light * l     = cone_ll[i];
+		QMatrix4x4 pm = glMatrixPerspective(l->angle_end, 1., 0.1), om, vm;
+		om.translate(-l->worldAim());
+		vm.translate(0., 0., -l->distance());
+		// vm.rotate(-roll_, 0., 0., 1.);
+		QMatrix4x4 pmat = l->worldTransform();
+		pmat(0, 3) = pmat(1, 3) = pmat(2, 3) = 0.;
+		vm *= pmat.inverted();
+		auto vpm            = pm * (vm * om);
+		l->view_proj_matrix = vpm;
+		l->shadow_matrix    = mat_norm_to_tex_coord * vpm * mat_camera_fullview_inv;
+	}
+}
+
+
 void Renderer::renderObjects(Scene & scene, RenderPass pass) {
 	QOpenGLExtraFunctions * f = view;
 	QMapIterator<Mesh *, ObjectBaseList> it(scene.geometries_used[pass]);
@@ -343,24 +380,23 @@ void Renderer::renderLight(int first_wr_buff, bool clear_only) {
 			}*/
 			fbo_out.setWriteBuffer(first_wr_buff + pass.second);
 			glClearFramebuffer(back, false);
+			back = QColor(0, 0, 0, 0);
 			if (clear_only) continue;
-			setUniformCamera(prog, cam);
+			setUniformCamera(prog, cam, true, fbo_ds.size());
-			setUniformViewCorners(prog, cam);
+			setUniformViewCorners(prog, cam, fbo_ds.size());
 			prog->setUniformValue("lights_start", lights_start[pass.second]);
 			prog->setUniformValue("lights_count", (int)cur_lights[pass.second].size());
-			prog->setUniformValue("fog_color", view->fogColor());
+			prog->setUniformValue("fog_color", color2vector(view->fogColor()) / 2.);
 			prog->setUniformValue("fog_decay", qMax(view->fogDecay(), 0.001f));
 			prog->setUniformValue("fog_density", view->fogDensity());
 			prog->setUniformValue("view_mat", cam->viewMatrix().inverted().toGenericMatrix<3, 3>());
-			prog->setUniformValue("shadow_size", view->shadow_map_size);
 			prog->setUniformValue("noise_size", noise_size);
-			prog->setUniformValue("soft_shadows_enabled", view->soft_shadows);
+			prog->setUniformValue("shadows_enabled", view->shadows());
-			prog->setUniformValue("soft_shadows_samples", view->soft_shadows_samples);
+			if (view->shadows()) {
-			prog->setUniformValue("soft_shadows_quality", view->soft_shadows_quality);
+				prog->setUniformValue("shadow_size", view->shadow_map_size);
-			prog->setUniformValue("tex_shadows_cone", (int)tarShadowsCone);
+				prog->setUniformValue("soft_shadows_enabled", view->settings.soft_shadows);
-			prog->setUniformValue("tex_shadows_omni", (int)tarShadowsOmni);
+				prog->setUniformValue("soft_shadows_samples", view->settings.soft_shadows_samples);
-			prog->setUniformValue("tex_depths_cone", (int)tarDepthsCone);
+				prog->setUniformValue("soft_shadows_quality", view->settings.soft_shadows_quality);
-			prog->setUniformValue("tex_depths_omni", (int)tarDepthsOmni);
 				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);
@@ -370,6 +406,7 @@ void Renderer::renderLight(int first_wr_buff, bool clear_only) {
 				view->glTexParameteri(GL_TEXTURE_CUBE_MAP_ARRAY, GL_TEXTURE_MAG_FILTER, filter);
 				depth_maps_cone.bind(view, tarDepthsCone);
 				depth_maps_omni.bind(view, tarDepthsOmni);
+			}
 			renderQuad(prog, quad, cam);
 		}
 	}
@@ -393,19 +430,10 @@ void Renderer::renderConeShadows() {
 		depth_maps_cone.resize(f, view->shadow_map_size, cone_ll.size());
 		for (int i = 0; i < cone_ll.size(); ++i) {
 			Light * l = cone_ll[i];
-			QMatrix4x4 pm = glMatrixPerspective(l->angle_end, 1., 0.1), om, vm;
-			om.translate(-l->worldAim());
-			vm.translate(0., 0., -l->distance());
-			// vm.rotate(-roll_, 0., 0., 1.);
-			QMatrix4x4 pmat = l->worldTransform();
-			pmat(0, 3) = pmat(1, 3) = pmat(2, 3) = 0.;
-			vm *= pmat.inverted();
-			auto vpm = pm * (vm * om);
 			if (l->isCastShadows()) {
-				prog->setUniformValue("qgl_ViewProjMatrix", vpm);
+				prog->setUniformValue("qgl_ViewProjMatrix", l->view_proj_matrix);
 				renderConeShadow(i, l);
 			}
-			l->shadow_matrix = mat_norm_to_tex_coord * vpm * mat_camera_fullview_inv;
 		}
 	}
 }
@@ -508,10 +536,10 @@ void Renderer::renderScene() {
 	/// reload materials on change
 	phase.begin("scene reload");
 	if (scene_changed || scene.need_reload_materials) {
+		if (scene.need_reload_materials) emit view->materialsChanged();
 		rend_selection.generateObjectsID(scene);
 		reloadMaterials(scene);
 		if (edit_mode) recreateMaterialThumbnails();
-		emit view->materialsChanged();
 	}
 	phase.end();
 
@@ -522,6 +550,10 @@ void Renderer::renderScene() {
 	}
 	phase.end();
 
+	/// setup cone lights matrices
+	setConeShadowMatrix();
+
+	if (view->shadows()) {
 		/// cone shadows and shadow matrix
 		phase.begin("shadows cone");
 		renderConeShadows();
@@ -531,6 +563,7 @@ void Renderer::renderScene() {
 		phase.begin("shadows omni");
 		renderOmniShadows();
 		phase.end();
+	}
 
 	/// lights
 	phase.begin("lights prepare");
@@ -540,7 +573,7 @@ void Renderer::renderScene() {
 	}
 	if (use_camlight) {
 		cur_lights[Light::Omni] << cam_light;
-		cam_light->setPos(cam->pos());
+		cam_light->setPos(cam->worldPos());
 	}
 	if (scene.lights_changed) {
 		scene.lights_changed = false;
@@ -563,7 +596,7 @@ void Renderer::renderScene() {
 	glEnableDepth();
 	glClearFramebuffer();
 	if (bindShader(srGeometrySolidPass, &prog)) {
-		setUniformCamera(prog, cam);
+		setUniformCamera(prog, cam, true, fbo_ds.size());
 		textures_empty.bind(f, tarEmpty);
 		textures_maps.bind(f, tarMaps);
 		prog->setUniformValue("out_index_normal", dbrNormalZSolid);
@@ -592,7 +625,7 @@ void Renderer::renderScene() {
 	glClearFramebuffer(Qt::black, false);
 	fbo_ds.setWriteBuffers();
 	if (bindShader(srGeometryTransparentPass, &prog)) {
-		setUniformCamera(prog, cam);
+		setUniformCamera(prog, cam, true, fbo_ds.size());
 		textures_empty.bind(f, tarEmpty);
 		textures_maps.bind(f, tarMaps);
 		prog->setUniformValue("out_index_normal", dbrNormalZ);
@@ -628,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);
@@ -643,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);
@@ -664,24 +698,51 @@ void Renderer::renderScene() {
 	}
 
 	fbo_out.release();
+	glViewport(0, 0, view->pixelWidth(), view->pixelHeight());
 
 	/// apply hovers and selection frame
-	phase.begin("service");
 	if (edit_mode) {
+		phase.begin("service");
 		rend_selection.drawSelection(fbo_out, cur_write_plane);
 		rend_service.renderService();
 	} else {
-		fbo_out.blit(cur_write_plane, 0, 0, fbo_out.rect(), QRect(QPoint(), view->pixelSize()));
+		phase.begin("blit to screen");
+		if (fbo_out.rect() == view->pixelRect()) {
+			fbo_out.blit(cur_write_plane, 0, 0, fbo_out.rect(), view->pixelRect());
+		} else {
+			if (bindShader(srRescale, &prog)) {
+				fbo_out.bindColorTexture(cur_write_plane, 0);
+				renderQuad(prog, quad);
+			}
+		}
 	}
 	phase.end();
 
 	/// grab framebuffer
 	phase.begin("grab");
-	if (is_grabbing) {
+	if (view->grabFormats().testFlag(gfImage)) {
-		fbo_out.queryImage(0);
+		if (grab_mipmap == 0) {
+			fbo_out.queryImage(cur_write_plane);
 			last_img = fbo_out.getImage().mirrored();
-		// qDebug() << last_img.size();
+		} else {
+			img_mips.setIndexFrom(cur_write_plane);
+			img_mips.create();
+			img_mips.plane(grab_mipmap - 1).queryImage(0);
+			last_img = img_mips.plane(grab_mipmap - 1).getImage().mirrored();
 		}
+	}
+	if (view->grabFormats().testFlag(gfFloat)) {
+		if (grab_mipmap_f == 0) {
+			fbo_out.queryImageF(obrLighting);
+			last_img_f = fbo_out.getPointsFloat();
+		} else {
+			img_f_mips.setIndexFrom(obrLighting);
+			img_f_mips.create();
+			img_f_mips.plane(grab_mipmap_f - 1).queryImageF(0);
+			last_img_f = img_f_mips.plane(grab_mipmap_f - 1).getPointsFloat();
+		}
+	}
+	// qDebug() << last_img.size();
 	phase.end();
 
 	/*
@@ -719,11 +780,6 @@ void Renderer::setCameraLightMode(int m) {
 	view->scene()->setLightsChanged();
 }
 
-void Renderer::setGrabImage(bool on) {
-	is_grabbing = on;
-	// fbo_out.enablePixelBuffer();
-}
-
 
 void Renderer::addFramebufferEffect(FramebufferEffectBase * e) {
 	e->r = this;

src/core/render/renderer.h

@@ -20,6 +20,7 @@
 #define RENDERER_H
 
 #include "glcubemap.h"
+#include "glframebuffer.h"
 #include "glframebuffereffectbase.h"
 #include "renderer_base.h"
 #include "renderer_material.h"
@@ -59,6 +60,7 @@ class QGLENGINE_CORE_EXPORT Renderer: public RendererBase {
 		srTonemapPass,
 		srShadowConePass,
 		srShadowOmniPass,
+		srRescale
 	};
 	enum OutBufferRole {
 		obrSolidOmni,
@@ -92,6 +94,10 @@ public:
 
 		dbrBuffersCount,
 	};
+	enum GrabFormat {
+		gfImage = 1,
+		gfFloat = 2
+	};
 
 	void init(int width, int height);
 	void resize(int width, int height);
@@ -99,9 +105,8 @@ public:
 	void renderScene();
 	void setCameraLightMode(int m);
 	int cameraLightMode() const { return camera_light_mode; }
-	void setGrabImage(bool on);
-	bool isGrabImage() const { return is_grabbing; }
 	QImage getImage() const { return last_img; }
+	QVector<QVector4D> getImageF() const { return last_img_f; }
 	void addFramebufferEffect(FramebufferEffectBase * e);
 	void clearFramebufferEffects() { fb_effects.clear(); }
 	QVector<FramebufferEffectBase *> framebufferEffects() const { return fb_effects; }
@@ -112,6 +117,7 @@ public:
 
 protected:
 	void fillObjectsBuffer(const ObjectBaseList & ol, RenderPass pass);
+	void setConeShadowMatrix();
 	void renderObjects(Scene & scene, RenderPass pass);
 	void renderLight(int first_wr_buff, bool clear_only);
 	void renderConeShadows();
@@ -127,8 +133,8 @@ 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;
 	Framebuffer fbo_ds, fbo_out;
 	QMap<ShaderRole, QString> shader_files;
@@ -155,9 +161,10 @@ private:
 	QVector<QVector3D> hcontent;
 	QMap<int, QList<Light *>> cur_lights;
 	QVector<FramebufferEffectBase *> fb_effects;
+	FramebufferMipmap img_mips, img_f_mips;
 	QImage last_img;
+	QVector<QVector4D> last_img_f;
 	QString obr_defines, timings;
-	bool is_grabbing = false;
 };
 
 #endif // RENDERER_H

src/core/render/renderer_base.cpp

@@ -247,7 +247,7 @@ void RendererBase::reloadLightsParameters(const QMap<int, QList<Light *>> & ligh
 		so.decay_intensity[2] = l->decay_quadratic;
 		so.decay_intensity[3] = l->intensity;
 		so.size               = l->size;
-		so.flags              = l->cast_shadow ? 1 : 0;
+		so.flags              = l->isCastShadows() ? 1 : 0;
 		if (l->light_type == Light::Cone) l->light_map.copyToQGLMap(so.map);
 	}
 	buffer_lights.bind(view);

src/core/render/renderer_material.cpp

@@ -59,7 +59,7 @@ void RendererMaterial::init(int width, int height) {
 
 void RendererMaterial::resize(int width, int height) {
 	fbo_mat_thumb.enablePixelBuffer();
-	fbo_mat_thumb.resize(256, 256);
+	fbo_mat_thumb.resize(width, height);
 }
 
 

src/core/render/renderer_selection.cpp

@@ -129,7 +129,7 @@ void RendererSelection::renderSelection(Scene & scene) {
 		fbo_selection.setWriteBuffers();
 		glEnableDepth();
 		glClearFramebuffer(QColor(0, 0, 0, 0));
-		r->setUniformCamera(prog, view->camera());
+		r->setUniformCamera(prog, view->camera(), true, r->fbo_ds.size());
 		r->renderObjects(scene, rpSolid);
 		r->renderObjects(scene, rpTransparent);
 		view->glClear(GL_DEPTH_BUFFER_BIT);
@@ -138,10 +138,12 @@ void RendererSelection::renderSelection(Scene & scene) {
 		rs.drawLights();
 		rs.drawCameras();
 		rs.drawCurrentHandleObjects();
+		auto mapPoint = [this](QPoint p) { return (QPointF(p.x() * size_coeff.x(), p.y() * size_coeff.y()) * scale_).toPoint(); };
+		auto mapSize  = [this](QSize s) { return (QSizeF(s.width() * size_coeff.x(), s.height() * size_coeff.y()) * scale_).toSize(); };
 		if (r->mouse_rect.isNull())
-			fbo_selection.queryPoint(0, r->mouse_pos * scale_);
+			fbo_selection.queryPoint(0, mapPoint(r->mouse_pos));
 		else
-			fbo_selection.queryPoints(0, QRect(r->mouse_rect.topLeft() * scale_, r->mouse_rect.size() * scale_));
+			fbo_selection.queryPoints(0, QRect(mapPoint(r->mouse_rect.topLeft()), mapSize(r->mouse_rect.size())));
 
 		// qDebug() << id_hover;
 		fbo_selection.bindColorTexture(sbrSrcHover, sbrSrcHover);

src/core/render/renderer_selection.h

@@ -57,6 +57,7 @@ private:
 	Framebuffer fbo_selection;
 	Mesh * sel_frame;
 	float line_thick_, scale_;
+	QPointF size_coeff = {1., 1.};
 	QVector<uchar> cur_selections_;
 	QHash<uint, ObjectBase *> ids;
 	QHash<uint, ObjectBase *> aim_ids;

src/core/render/renderer_service.cpp

@@ -474,7 +474,7 @@ void RendererService::renderService() {
 		prog->setUniformValue("qgl_ProjMatrix", r->view->camera()->projectionMatrix(r->view->aspect));
 
 		/// lights
-		r->setUniformCamera(prog, r->view->camera());
+		r->setUniformCamera(prog, r->view->camera(), true, r->fbo_ds.size());
 
 		prog->setUniformValue("line_width", 2.f);
 		prog->setUniformValue("z_offset", 0.f);
@@ -486,7 +486,7 @@ void RendererService::renderService() {
 		drawCamerasFrame(Qt::black);
 	}
 	if (r->bindShader(Renderer::srServiceLine, &prog)) {
-		r->setUniformCamera(prog, r->view->camera());
+		r->setUniformCamera(prog, r->view->camera(), true, r->fbo_ds.size());
 		line_object.color = QColor2QVector(Qt::white);
 		line_spot_f->loadObject(f, line_object);
 		line_camera_f->loadObject(f, line_object);
@@ -495,7 +495,7 @@ void RendererService::renderService() {
 	}
 	glEnable(GL_CULL_FACE);
 	if (r->bindShader(Renderer::srServiceFill, &prog)) {
-		r->setUniformCamera(prog, r->view->camera());
+		r->setUniformCamera(prog, r->view->camera(), true, r->fbo_ds.size());
 
 		/// handles
 		f->glEnable(GL_BLEND);
@@ -504,13 +504,15 @@ void RendererService::renderService() {
 		f->glDisable(GL_BLEND);
 
 		/// axis
+		GLint prev_view[4];
+		f->glGetIntegerv(GL_VIEWPORT, prev_view);
 		f->glViewport(0, 0, axis_viewport.width(), axis_viewport.height());
 		axis_camera->setPos(-r->view->camera()->direction() * 3.);
 		axis_camera->setAim(QVector3D());
 		axis_camera->setRotation(r->view->camera()->rotation());
 		r->setUniformCamera(prog, axis_camera, true, axis_viewport);
 		axis_mesh->draw(f, 3);
-		f->glViewport(0, 0, r->view->pixelWidth(), r->view->pixelHeight());
+		f->glViewport(prev_view[0], prev_view[1], prev_view[2], prev_view[3]);
 	}
 	f->glDisable(GL_MULTISAMPLE);
 }

src/core/scene/glcamera.cpp

@@ -74,10 +74,13 @@ QMatrix4x4 Camera::viewMatrix() const {
 	// qDebug() << pos() << aim();
 	ret.translate(0., 0., -distance());
 	ret.rotate(-roll_, 0., 0., 1.);
-	ret *= trans.matrixRotateScale().inverted();
+	ret *= trans.matrixRotate().inverted();
 	if (parent_) {
-		QMatrix4x4 pmat = parent_->worldTransform();
+		Transform tr;
-		offset_         = pmat.column(3).toVector3D();
+		tr.setMatrix(parent_->worldTransform());
+		tr.setDirty();
+		QMatrix4x4 pmat = tr.matrixRotate();
+		offset_         = parent_->worldTransform().column(3).toVector3D();
 		pmat(0, 3) = pmat(1, 3) = pmat(2, 3) = 0.;
 		pmat.translate(aim());
 		ret *= pmat.inverted();

src/core/scene/globject.cpp

@@ -26,22 +26,12 @@
 // static int _count = 0;
 
 ObjectBase::ObjectBase(Mesh * geom, Material * mat) {
-	type_     = glMesh;
-	prev_pass = rpSolid;
-	parent_   = nullptr;
-	color_    = Qt::white;
-	is_root = is_init = selected_ = false;
-	visible_ = accept_fog = accept_light = cast_shadow = rec_shadow = select_ = true;
-	line_width                                                                = -1.;
-	id_                                                                       = 0;
 	blend_src  = GL_SRC_ALPHA;
 	blend_dest = GL_ONE_MINUS_SRC_ALPHA;
-	type_                                                                     = glMesh;
-	raw_matrix = selected_aim = false;
 	mat_.setToIdentity();
-	scene_    = nullptr;
 	mesh_ = geom;
-	material_ = mat;
+	setPreset(0);
+	currentPreset().material = mat;
 	// qDebug() << "ObjectBase, now" << ++_count;
 }
 
@@ -65,9 +55,8 @@ ObjectBase * ObjectBase::clone(bool withChildren) {
 	ObjectBase * o   = new ObjectBase();
 	o->prev_pass     = prev_pass;
 	o->is_init       = false;
-	o->accept_light  = accept_light;
+	o->presets       = presets;
-	o->accept_fog    = accept_fog;
+	o->cur_preset    = cur_preset;
-	o->visible_      = visible_;
 	o->color_        = color_;
 	o->type_         = type_;
 	o->raw_matrix    = raw_matrix;
@@ -80,7 +69,6 @@ ObjectBase * ObjectBase::clone(bool withChildren) {
 	o->blend_src     = blend_src;
 	o->blend_dest    = blend_dest;
 	o->pos_h         = pos_h;
-	o->material_     = material_;
 	o->mesh_         = mesh_;
 	o->meta          = meta;
 	o->scene_        = nullptr;
@@ -107,8 +95,8 @@ void ObjectBase::init() {
 
 RenderPass ObjectBase::pass() const {
 	RenderPass ret = rpSolid;
-	if (material_)
+	if (currentPreset().material)
-		if (material_->hasTransparency()) ret = rpTransparent;
+		if (currentPreset().material->hasTransparency()) ret = rpTransparent;
 	return ret;
 }
 
@@ -206,11 +194,11 @@ ObjectBaseList ObjectBase::children(bool all_) {
 
 
 bool ObjectBase::isVisible(bool check_parents) const {
-	if (!check_parents) return visible_;
+	if (!check_parents) return currentPreset().visible;
-	if (!visible_) return false;
+	if (!currentPreset().visible) return false;
 	ObjectBase * p = parent_;
 	while (p) {
-		if (!p->visible_) return false;
+		if (!p->currentPreset().visible) return false;
 		p = p->parent_;
 	}
 	return true;
@@ -218,19 +206,122 @@ bool ObjectBase::isVisible(bool check_parents) const {
 
 
 void ObjectBase::setVisible(bool v) {
-	visible_ = v;
+	currentPreset().visible = v;
 	setSceneTreeChanged();
 }
 
 
+void ObjectBase::setVisibleForAllPresets(bool v) {
+	for (auto & p: presets)
+		p.visible = v;
+}
+
+
+void ObjectBase::setReceiveShadows(bool on) {
+	currentPreset().receive_shadow = on;
+	setObjectsChanged();
+}
+
+
 void ObjectBase::setCastShadows(bool on) {
-	cast_shadow = on;
+	currentPreset().cast_shadow = on;
 	if (type_ == glLight)
 		((Light *)this)->apply();
 	else
 		setObjectsChanged();
 }
 
+void ObjectBase::move(const QVector3D & dv) {
+	trans.setTranslation(pos() + dv);
+	buildTransform();
+}
+
+
+void ObjectBase::moveTo(const QVector3D & dv) {
+	trans.setTranslation(dv);
+	buildTransform();
+}
+
+
+void ObjectBase::move(GLfloat dx, GLfloat dy, GLfloat dz) {
+	move(QVector3D(dx, dy, dz));
+	buildTransform();
+}
+
+
+void ObjectBase::moveTo(GLfloat dx, GLfloat dy, GLfloat dz) {
+	moveTo(QVector3D(dx, dy, dz));
+	buildTransform();
+}
+
+
+void ObjectBase::moveX(GLfloat o) {
+	trans.setTranslationX(posX() + o);
+	buildTransform();
+}
+
+
+void ObjectBase::moveY(GLfloat o) {
+	trans.setTranslationY(posY() + o);
+	buildTransform();
+}
+
+
+void ObjectBase::moveZ(GLfloat o) {
+	trans.setTranslationZ(posZ() + o);
+	buildTransform();
+}
+
+
+void ObjectBase::setPosX(GLfloat o) {
+	trans.setTranslationX(o);
+	buildTransform();
+}
+
+
+void ObjectBase::setPosY(GLfloat o) {
+	trans.setTranslationY(o);
+	buildTransform();
+}
+
+
+void ObjectBase::setPosZ(GLfloat o) {
+	trans.setTranslationZ(o);
+	buildTransform();
+}
+
+
+void ObjectBase::setPos(GLfloat x, GLfloat y, GLfloat z) {
+	trans.setTranslation(QVector3D(x, y, z));
+	buildTransform();
+}
+
+
+void ObjectBase::setPos(const QVector3D & p) {
+	trans.setTranslation(p);
+	buildTransform();
+}
+
+
+void ObjectBase::resetPos() {
+	trans.setTranslation(QVector3D());
+	buildTransform();
+}
+
+
+void ObjectBase::rotateX(GLfloat a) {
+	raw_matrix = false;
+	trans.setRotationX(trans.rotationX() + a);
+	buildTransform();
+}
+
+
+void ObjectBase::rotateY(GLfloat a) {
+	raw_matrix = false;
+	trans.setRotationY(trans.rotationY() + a);
+	buildTransform();
+}
+
 
 void ObjectBase::rotateZ(GLfloat a) {
 	raw_matrix = false;
@@ -242,6 +333,20 @@ void ObjectBase::rotateZ(GLfloat a) {
 }
 
 
+void ObjectBase::setRotationX(GLfloat a) {
+	raw_matrix = false;
+	trans.setRotationX(a);
+	buildTransform();
+}
+
+
+void ObjectBase::setRotationY(GLfloat a) {
+	raw_matrix = false;
+	trans.setRotationY(a);
+	buildTransform();
+}
+
+
 void ObjectBase::setRotationZ(GLfloat a) {
 	raw_matrix = false;
 	trans.setRotationZ(a);
@@ -252,6 +357,111 @@ void ObjectBase::setRotationZ(GLfloat a) {
 }
 
 
+void ObjectBase::setRotation(const QVector3D & a) {
+	raw_matrix = false;
+	trans.setRotation(a);
+	buildTransform();
+}
+
+
+void ObjectBase::resetRotation() {
+	raw_matrix = false;
+	trans.setRotation(QVector3D());
+	buildTransform();
+}
+
+
+void ObjectBase::scale(const QVector3D & sv) {
+	raw_matrix = false;
+	trans.setScale(trans.scale3D() * sv);
+	buildTransform();
+}
+
+
+void ObjectBase::scale(GLfloat sx, GLfloat sy, GLfloat sz) {
+	raw_matrix = false;
+	scale(QVector3D(sx, sy, sz));
+	buildTransform();
+}
+
+
+void ObjectBase::scale(GLfloat sx, GLfloat sy) {
+	raw_matrix = false;
+	scale(QVector3D(sx, sy, sy));
+	buildTransform();
+}
+
+
+void ObjectBase::scale(GLfloat sx) {
+	raw_matrix = false;
+	scale(QVector3D(sx, sx, sx));
+	buildTransform();
+}
+
+
+void ObjectBase::scaleX(GLfloat a) {
+	raw_matrix = false;
+	trans.setScaleX(trans.scale3D().x() + a);
+	buildTransform();
+}
+
+
+void ObjectBase::scaleY(GLfloat a) {
+	raw_matrix = false;
+	trans.setScaleY(trans.scale3D().y() + a);
+	buildTransform();
+}
+
+
+void ObjectBase::scaleZ(GLfloat a) {
+	raw_matrix = false;
+	trans.setScaleZ(trans.scale3D().z() + a);
+	buildTransform();
+}
+
+
+void ObjectBase::setScale(const QVector3D & a) {
+	raw_matrix = false;
+	trans.setScale(a);
+	buildTransform();
+}
+
+
+void ObjectBase::setScale(GLfloat a) {
+	raw_matrix = false;
+	trans.setScale(a);
+	buildTransform();
+}
+
+
+void ObjectBase::setScaleX(GLfloat a) {
+	raw_matrix = false;
+	trans.setScaleX(a);
+	buildTransform();
+}
+
+
+void ObjectBase::setScaleY(GLfloat a) {
+	raw_matrix = false;
+	trans.setScaleY(a);
+	buildTransform();
+}
+
+
+void ObjectBase::setScaleZ(GLfloat a) {
+	raw_matrix = false;
+	trans.setScaleZ(a);
+	buildTransform();
+}
+
+
+void ObjectBase::resetScale() {
+	raw_matrix = false;
+	trans.setScale(1.f);
+	buildTransform();
+}
+
+
 void ObjectBase::setTransform(const Transform & t) {
 	trans = t;
 	buildTransform();
@@ -308,6 +518,23 @@ void ObjectBase::removeProperty(const QString & pn) {
 }
 
 
+void ObjectBase::setPreset(int preset) {
+	if (preset < 0) preset = 0;
+	if (presets.size() <= preset) presets.resize(preset + 1);
+	cur_preset = preset;
+	for (auto * c: children_)
+		c->setPreset(preset);
+}
+
+
+QVector<int> ObjectBase::availablePresets() const {
+	QVector<int> ret;
+	for (int i = 0; i < presets.size(); ++i)
+		ret << i;
+	return ret;
+}
+
+
 void ObjectBase::setMatrix(const QMatrix4x4 & t) {
 	// raw_matrix = true;
 	// mat_ = t;
@@ -379,6 +606,18 @@ QGenericMatrix<3, 2, float> ObjectBase::textureGLMatrix() const {
 }
 
 
+void ObjectBase::setAcceptLight(bool yes) {
+	currentPreset().accept_light = yes;
+	setObjectsChanged();
+}
+
+
+void ObjectBase::setAcceptFog(bool yes) {
+	currentPreset().accept_fog = yes;
+	setObjectsChanged();
+}
+
+
 bool ObjectBase::isSelected(bool check_parents) const {
 	if (!check_parents) return selected_;
 	if (selected_) return true;
@@ -409,15 +648,32 @@ ObjectBase * ObjectBase::selectedParent() const {
 
 
 void ObjectBase::setMaterial(Material * m, bool with_children) {
-	material_ = m;
+	currentPreset().material = m;
 	if (with_children)
-		foreach(ObjectBase * i, children_)
+		for (auto * i: children_)
 			i->setMaterial(m, true);
 	setObjectsChanged();
 	if (scene_) scene_->mat_changed = scene_->tree_changed = true;
 }
 
 
+void ObjectBase::setMaterialForPreset(Material * m, int p, bool with_children) {
+	if (p < 0 || p >= presets.size()) return;
+	presets[p].material = m;
+	if (with_children)
+		for (auto * i: children_)
+			i->setMaterialForPreset(m, p, true);
+	setObjectsChanged();
+	if (scene_) scene_->mat_changed = scene_->tree_changed = true;
+}
+
+
+Material * ObjectBase::materialForPreset(int p) {
+	if (p < 0 || p >= presets.size()) return nullptr;
+	return presets[p].material;
+}
+
+
 void ObjectBase::setColor(QColor c, bool with_children) {
 	color_ = c;
 	if (with_children)
@@ -643,15 +899,24 @@ void Light::apply() {
 }
 
 
+QDataStream & operator<<(QDataStream & s, const ObjectBase::Preset & p) {
+	ChunkStream cs;
+	cs.add(1, p.visible).add(2, p.accept_light).add(3, p.accept_fog).add(4, p.cast_shadow).add(5, p.receive_shadow);
+	s << cs.data();
+	return s;
+}
+QDataStream & operator>>(QDataStream & s, ObjectBase::Preset & p) {
+	ChunkStream cs(s);
+	cs.readAll();
+	cs.get(1, p.visible).get(2, p.accept_light).get(3, p.accept_fog).get(4, p.cast_shadow).get(5, p.receive_shadow);
+	return s;
+}
+
+
 QDataStream & operator<<(QDataStream & s, const ObjectBase * p) {
 	ChunkStream cs;
 	// qDebug() << "place" << p->name() << "...";
 	cs.add(1, int(p->type_))
-		.add(2, p->accept_light)
-		.add(3, p->accept_fog)
-		.add(4, p->visible_)
-		.add(5, p->cast_shadow)
-		.add(6, p->rec_shadow)
 		.add(7, p->raw_matrix)
 		.add(8, p->line_width)
 		.add(14, p->mat_)
@@ -660,7 +925,8 @@ QDataStream & operator<<(QDataStream & s, const ObjectBase * p) {
 		.add(18, p->meta)
 		.add(19, p->color_)
 		.add(20, p->trans)
-		.add(21, p->trans_texture);
+		.add(21, p->trans_texture)
+		.add(22, p->presets);
 	// qDebug() << "place self done";
 	if (p->type_ == ObjectBase::glLight) {
 		// qDebug() << "place light ...";
@@ -721,19 +987,19 @@ QDataStream & operator>>(QDataStream & s, ObjectBase *& p) {
 			if (p) p->type_ = type;
 		} break;
 		case 2:
-			if (p) p->accept_light = cs.getData<bool>();
+			if (p) p->currentPreset().accept_light = cs.getData<bool>();
 			break;
 		case 3:
-			if (p) p->accept_fog = cs.getData<bool>();
+			if (p) p->currentPreset().accept_fog = cs.getData<bool>();
 			break;
 		case 4:
-			if (p) p->visible_ = cs.getData<bool>();
+			if (p) p->currentPreset().visible = cs.getData<bool>();
 			break;
 		case 5:
-			if (p) p->cast_shadow = cs.getData<bool>();
+			if (p) p->currentPreset().cast_shadow = cs.getData<bool>();
 			break;
 		case 6:
-			if (p) p->rec_shadow = cs.getData<bool>();
+			if (p) p->currentPreset().receive_shadow = cs.getData<bool>();
 			break;
 		case 7:
 			if (p) p->raw_matrix = cs.getData<bool>();
@@ -762,6 +1028,12 @@ QDataStream & operator>>(QDataStream & s, ObjectBase *& p) {
 		case 21:
 			if (p) p->trans_texture = cs.getData<Transform>();
 			break;
+		case 22:
+			if (p) {
+				p->presets = cs.getData<QVector<ObjectBase::Preset>>();
+				if (p->presets.isEmpty()) p->presets.resize(1);
+			}
+			break;
 		case 100:
 			if (l) l->setAim(cs.getData<QVector3D>());
 			break;

src/core/scene/globject.h

@@ -30,6 +30,7 @@ class QGLENGINE_CORE_EXPORT ObjectBase {
 	friend class RendererSelection;
 	friend QGLENGINE_CORE_EXPORT QDataStream & operator<<(QDataStream & s, const ObjectBase * p);
 	friend QGLENGINE_CORE_EXPORT QDataStream & operator>>(QDataStream & s, ObjectBase *& p);
+	friend QGLENGINE_CORE_EXPORT QDataStream & operator<<(QDataStream & s, const Scene * p);
 	friend QGLENGINE_CORE_EXPORT QDataStream & operator>>(QDataStream & s, Scene *& p);
 
 public:
@@ -40,7 +41,7 @@ public:
 		glParticlesSystem
 	};
 
-	explicit ObjectBase(Mesh * geom = 0, Material * mat = 0);
+	explicit ObjectBase(Mesh * geom = nullptr, Material * mat = nullptr);
 	virtual ~ObjectBase();
 
 	virtual ObjectBase * clone(bool withChildren = true);
@@ -81,67 +82,29 @@ public:
 	void setHidden(bool v) { setVisible(!v); }
 	void show() { setVisible(true); }
 	void hide() { setVisible(false); }
+	void setVisibleForAllPresets(bool v);
+	void setHiddenForAllPresets(bool v) { setVisibleForAllPresets(!v); }
+	void showForAllPresets() { setVisibleForAllPresets(true); }
+	void hideForAllPresets() { setVisibleForAllPresets(false); }
 
-	bool isReceiveShadows() const { return rec_shadow; }
+	bool isReceiveShadows() const { return currentPreset().receive_shadow; }
-	bool isCastShadows() const { return cast_shadow; }
+	bool isCastShadows() const { return currentPreset().cast_shadow; }
-	void setReceiveShadows(bool on) {
+	void setReceiveShadows(bool on);
-		rec_shadow = on;
-		setObjectsChanged();
-	}
 	void setCastShadows(bool on);
 
-	void move(const QVector3D & dv) {
+	void move(const QVector3D & dv);
-		trans.setTranslation(pos() + dv);
+	void moveTo(const QVector3D & dv);
-		buildTransform();
+	void move(GLfloat dx, GLfloat dy, GLfloat dz = 0.);
-	}
+	void moveTo(GLfloat dx, GLfloat dy, GLfloat dz = 0.);
-	void moveTo(const QVector3D & dv) {
+	void moveX(GLfloat o);
-		trans.setTranslation(dv);
+	void moveY(GLfloat o);
-		buildTransform();
+	void moveZ(GLfloat o);
-	}
+	void setPosX(GLfloat o);
-	void move(GLfloat dx, GLfloat dy, GLfloat dz = 0.) {
+	void setPosY(GLfloat o);
-		move(QVector3D(dx, dy, dz));
+	void setPosZ(GLfloat o);
-		buildTransform();
+	void setPos(GLfloat x, GLfloat y, GLfloat z);
-	}
+	void setPos(const QVector3D & p);
-	void moveTo(GLfloat dx, GLfloat dy, GLfloat dz = 0.) {
+	void resetPos();
-		moveTo(QVector3D(dx, dy, dz));
-		buildTransform();
-	}
-	void moveX(GLfloat o) {
-		trans.setTranslationX(posX() + o);
-		buildTransform();
-	}
-	void moveY(GLfloat o) {
-		trans.setTranslationY(posY() + o);
-		buildTransform();
-	}
-	void moveZ(GLfloat o) {
-		trans.setTranslationZ(posZ() + o);
-		buildTransform();
-	}
-	void setPosX(GLfloat o) {
-		trans.setTranslationX(o);
-		buildTransform();
-	}
-	void setPosY(GLfloat o) {
-		trans.setTranslationY(o);
-		buildTransform();
-	}
-	void setPosZ(GLfloat o) {
-		trans.setTranslationZ(o);
-		buildTransform();
-	}
-	void setPos(GLfloat x, GLfloat y, GLfloat z) {
-		trans.setTranslation(QVector3D(x, y, z));
-		buildTransform();
-	}
-	void setPos(const QVector3D & p) {
-		trans.setTranslation(p);
-		buildTransform();
-	}
-	void resetPos() {
-		trans.setTranslation(QVector3D());
-		buildTransform();
-	}
 
 	QVector3D pos() const { return trans.translation(); }
 	float posX() const { return trans.translation().x(); }
@@ -154,108 +117,32 @@ public:
 	float rotationX() const { return rotation().x(); }
 	float rotationY() const { return rotation().y(); }
 	float rotationZ() const { return rotation().z(); }
-	void rotateX(GLfloat a) {
+	void rotateX(GLfloat a);
-		raw_matrix = false;
+	void rotateY(GLfloat a);
-		trans.setRotationX(trans.rotationX() + a);
-		buildTransform();
-	}
-	void rotateY(GLfloat a) {
-		raw_matrix = false;
-		trans.setRotationY(trans.rotationY() + a);
-		buildTransform();
-	}
 	void rotateZ(GLfloat a);
-	void setRotationX(GLfloat a) {
+	void setRotationX(GLfloat a);
-		raw_matrix = false;
+	void setRotationY(GLfloat a);
-		trans.setRotationX(a);
-		buildTransform();
-	}
-	void setRotationY(GLfloat a) {
-		raw_matrix = false;
-		trans.setRotationY(a);
-		buildTransform();
-	}
 	void setRotationZ(GLfloat a);
-	void setRotation(const QVector3D & a) {
+	void setRotation(const QVector3D & a);
-		raw_matrix = false;
+	void resetRotation();
-		trans.setRotation(a);
-		buildTransform();
-	}
-	void resetRotation() {
-		raw_matrix = false;
-		trans.setRotation(QVector3D());
-		buildTransform();
-	}
 
 	QVector3D scale() { return trans.scale3D(); }
 	float scaleX() { return trans.scale3D().x(); }
 	float scaleY() { return trans.scale3D().y(); }
 	float scaleZ() { return trans.scale3D().z(); }
-	void scale(const QVector3D & sv) {
+	void scale(const QVector3D & sv);
-		raw_matrix = false;
+	void scale(GLfloat sx, GLfloat sy, GLfloat sz);
-		trans.setScale(trans.scale3D() * sv);
+	void scale(GLfloat sx, GLfloat sy);
-		buildTransform();
+	void scale(GLfloat sx);
-	}
+	void scaleX(GLfloat a);
-	void scale(GLfloat sx, GLfloat sy, GLfloat sz) {
+	void scaleY(GLfloat a);
-		raw_matrix = false;
+	void scaleZ(GLfloat a);
-		scale(QVector3D(sx, sy, sz));
+	void setScale(const QVector3D & a);
-		buildTransform();
+	void setScale(GLfloat a);
-	}
+	void setScaleX(GLfloat a);
-	void scale(GLfloat sx, GLfloat sy) {
+	void setScaleY(GLfloat a);
-		raw_matrix = false;
+	void setScaleZ(GLfloat a);
-		scale(QVector3D(sx, sy, sy));
+	void resetScale();
-		buildTransform();
-	}
-	void scale(GLfloat sx) {
-		raw_matrix = false;
-		scale(QVector3D(sx, sx, sx));
-		buildTransform();
-	}
-	void scaleX(GLfloat a) {
-		raw_matrix = false;
-		trans.setScaleX(trans.scale3D().x() + a);
-		buildTransform();
-	}
-	void scaleY(GLfloat a) {
-		raw_matrix = false;
-		trans.setScaleY(trans.scale3D().y() + a);
-		buildTransform();
-	}
-	void scaleZ(GLfloat a) {
-		raw_matrix = false;
-		trans.setScaleZ(trans.scale3D().z() + a);
-		buildTransform();
-	}
-	void setScale(const QVector3D & a) {
-		raw_matrix = false;
-		trans.setScale(a);
-		buildTransform();
-	}
-	void setScale(GLfloat a) {
-		raw_matrix = false;
-		trans.setScale(a);
-		buildTransform();
-	}
-	void setScaleX(GLfloat a) {
-		raw_matrix = false;
-		trans.setScaleX(a);
-		buildTransform();
-	}
-	void setScaleY(GLfloat a) {
-		raw_matrix = false;
-		trans.setScaleY(a);
-		buildTransform();
-	}
-	void setScaleZ(GLfloat a) {
-		raw_matrix = false;
-		trans.setScaleZ(a);
-		buildTransform();
-	}
-	void resetScale() {
-		raw_matrix = false;
-		trans.setScale(1.f);
-		buildTransform();
-	}
 
 	Transform transform() { return trans; }
 	void setTransform(const Transform & t);
@@ -273,17 +160,11 @@ public:
 	QMatrix4x4 textureMatrix() const;
 	QGenericMatrix<3, 2, float> textureGLMatrix() const;
 
-	bool isAcceptLight() const { return accept_light; }
+	bool isAcceptLight() const { return currentPreset().accept_light; }
-	void setAcceptLight(bool yes) {
+	void setAcceptLight(bool yes);
-		accept_light = yes;
-		setObjectsChanged();
-	}
 
-	bool isAcceptFog() const { return accept_fog; }
+	bool isAcceptFog() const { return currentPreset().accept_fog; }
-	void setAcceptFog(bool yes) {
+	void setAcceptFog(bool yes);
-		accept_fog = yes;
-		setObjectsChanged();
-	}
 
 	bool isSelected(bool check_parents = false) const;
 	void setSelected(bool yes);
@@ -302,7 +183,9 @@ public:
 	void setDestAlpha(GLenum mode) { blend_dest = mode; }
 
 	void setMaterial(Material * m, bool with_children = false);
-	Material * material() { return material_; }
+	void setMaterialForPreset(Material * m, int p, bool with_children = false);
+	Material * material() { return currentPreset().material; }
+	Material * materialForPreset(int p);
 
 	void setColor(QColor c, bool with_children = false);
 	QColor color() { return color_; }
@@ -319,9 +202,24 @@ public:
 	bool hasProperty(const QString & pn) const;
 	void removeProperty(const QString & pn);
 
+	void setPreset(int preset);
+
+	QVector<int> availablePresets() const;
+
 	QVector3D pos_h;
 
 protected:
+	struct Preset {
+		bool visible        = true;
+		bool accept_light   = true;
+		bool accept_fog     = true;
+		bool cast_shadow    = true;
+		bool receive_shadow = true;
+		Material * material = nullptr;
+	};
+	friend QGLENGINE_CORE_EXPORT QDataStream & operator<<(QDataStream & s, const ObjectBase::Preset & p);
+	friend QGLENGINE_CORE_EXPORT QDataStream & operator>>(QDataStream & s, ObjectBase::Preset & p);
+
 	virtual void transformChanged() {}
 	void addChildren(ObjectBaseList & list, ObjectBase * where);
 	void buildTransform(bool force = false);
@@ -330,24 +228,27 @@ protected:
 	void setObjectsChanged();
 	void localTransform(QMatrix4x4 & m);
 	QMatrix4x4 worldMatrix(QMatrix4x4 parent) const;
+	const Preset & currentPreset() const { return presets[cur_preset]; }
+	Preset & currentPreset() { return presets[cur_preset]; }
 
-	int prev_pass; // Pass
+	int prev_pass  = rpSolid; // Pass
-	bool is_init, accept_light, accept_fog, visible_, cast_shadow, rec_shadow, select_, selected_, raw_matrix;
+	int cur_preset = 0;
-	bool is_root, selected_aim;
+	bool is_init = false, select_ = true, selected_ = false, raw_matrix = false;
-	float line_width;
+	bool is_root = false, selected_aim = false;
-	QColor color_;
+	float line_width = -1.f;
-	uint id_;
+	QVector<Preset> presets;
-	Type type_;
+	QColor color_ = Qt::white;
+	uint id_      = 0;
+	Type type_    = glMesh;
 	Box3D bound;
 	Transform trans, trans_texture;
 	ObjectBaseList children_;
 	QMatrix4x4 itransform_, mat_;
 	QString name_;
 	GLenum blend_src, blend_dest;
-	ObjectBase * parent_;
+	ObjectBase * parent_ = nullptr;
-	Scene * scene_;
+	Scene * scene_       = nullptr;
-	Material * material_;
+	Mesh * mesh_         = nullptr;
-	Mesh * mesh_;
 	QVariantMap meta;
 };
 
@@ -426,7 +327,7 @@ public:
 	float size;
 	Type light_type;
 	Framebuffer shadow_map;
-	QMatrix4x4 shadow_matrix;
+	QMatrix4x4 shadow_matrix, view_proj_matrix;
 	Map light_map;
 };
 
@@ -441,6 +342,8 @@ inline T globject_cast(const ObjectBase * object) {
 }
 
 
+QGLENGINE_CORE_EXPORT QDataStream & operator<<(QDataStream & s, const ObjectBase::Preset & p);
+QGLENGINE_CORE_EXPORT QDataStream & operator>>(QDataStream & s, ObjectBase::Preset & p);
 QGLENGINE_CORE_EXPORT QDataStream & operator<<(QDataStream & s, const ObjectBase * p);
 QGLENGINE_CORE_EXPORT QDataStream & operator>>(QDataStream & s, ObjectBase *& p);
 

src/core/scene/glscene.cpp

@@ -91,6 +91,7 @@ void Scene::assignFrom(const Scene * s) {
 		addObject(s->root_->child(i)->clone());
 		// qDebug() << i << o->child(i)->pos();
 	}
+	setPreset(s->preset());
 	tree_changed = mat_changed = lights_changed = need_reload_materials = tree_struct_changed = true;
 }
 
@@ -107,6 +108,9 @@ void Scene::clear() {
 	emit __destroyed();
 	if (destroying) return;
 	emit treeChanged();
+	mat_changed = lights_changed = true;
+	need_reload_materials        = true;
+	tree_struct_changed          = true;
 }
 
 
@@ -321,11 +325,16 @@ Material * Scene::newMaterial(const QString & name) {
 void Scene::removeMaterial(Material * m) {
 	if (!m || !materials.contains(m)) return;
 	ObjectBaseList ol = root_->children(true);
-	foreach(ObjectBase * o, ol)
+	for (auto * o: ol)
-		if (o->material_ == m) o->setMaterial(0);
+		for (auto & p: o->presets)
+			if (p.material == m) {
+				p.material = nullptr;
+				o->setObjectsChanged();
+			}
 	materials.removeAll(m);
 	changed_materials.removeAll(m);
 	mat_changed  = true;
+	tree_changed = true;
 }
 
 
@@ -349,6 +358,15 @@ void Scene::removeLight(Light * l) {
 }
 
 
+void Scene::setPreset(int preset) {
+	if (cur_preset == preset) return;
+	cur_preset = preset;
+	root_->setPreset(cur_preset);
+	mat_changed = tree_changed = tree_struct_changed = lights_changed = true;
+	emit presetChanged(cur_preset);
+}
+
+
 void Scene::dump() {
 	qDebug() << "Scene" << name();
 	qDebug() << "Meshes:" << geometries.size();
@@ -371,28 +389,31 @@ void Scene::attachObject(ObjectBase * o) {
 		o->setMesh(attachMesh(o->mesh()));
 		setObjectMeshChanged(o);
 	}
-	if (o->material()) { // search suitable material in this scene
+	for (auto & p: o->presets) {
-		uint ohash    = o->material()->hash();
+		if (p.material) { // search suitable material in this scene
+			uint ohash    = p.material->hash();
 			bool need_new = true;
 			foreach(Material * m, materials) {
-			if (m == o->material()) { // already exists by ptr
+				if (m == p.material) { // already exists by ptr
 					need_new = false;
 					break;
 				}
 				if (m->hash() == ohash) { // already exists by hash
 					need_new   = false;
-				o->setMaterial(m);
+					p.material = m;
 					break;
 				}
 			}
 			if (need_new) { // need to clone material and add to scene
 				Material * nmat = new Material();
-			*nmat           = *(o->material());
+				*nmat           = *(p.material);
 				nmat->setMapsChanged();
-			o->setMaterial(nmat);
+				p.material = nmat;
 				materials << nmat;
 			}
 		}
+	}
+	o->setPreset(cur_preset);
 	setTreeStructChanged();
 }
 
@@ -507,15 +528,25 @@ void Scene::destroyUnused(QOpenGLExtraFunctions * f) {
 QDataStream & operator<<(QDataStream & s, const Scene * p) {
 	ChunkStream cs;
 	// qDebug() << "place" << p->name() << "...";
-	QVector<short> geom_ind, mat_ind;
+	QVector<short> geom_ind, mats;
+	QVector<QVector<short>> mat_ind;
 	ObjectBaseList cl = p->root_->children(true);
 	geom_ind.reserve(cl.size());
 	mat_ind.reserve(cl.size());
-	foreach(ObjectBase * c, cl) {
+	for (auto * c: cl) {
 		geom_ind << p->geometries.indexOf(c->mesh());
-		mat_ind << p->materials.indexOf(c->material());
+		mats.clear();
+		for (auto i: c->presets)
+			mats << p->materials.indexOf(i.material);
+		mat_ind << mats;
 	}
-	cs.add(1, p->name_).add(10, p->geometries).add(11, p->materials).add(20, p->root_).add(21, geom_ind).add(22, mat_ind);
+	cs.add(1, p->name_)
+		.add(10, p->geometries)
+		.add(11, p->materials)
+		.add(20, p->root_)
+		.add(21, geom_ind)
+		.add(23, mat_ind)
+		.add(24, p->cur_preset);
 	s << qCompress(cs.data());
 	return s;
 }
@@ -525,7 +556,9 @@ QDataStream & operator>>(QDataStream & s, Scene *& p) {
 	s >> ba;
 	ba = qUncompress(ba);
 	ChunkStream cs(ba);
-	QVector<short> geom_ind, mat_ind;
+	QVector<short> geom_ind, mat_ind_v0;
+	QVector<QVector<short>> mat_ind_v1;
+	int version = 0, preset = 0;
 	while (!cs.atEnd()) {
 		switch (cs.read()) {
 		case 1: cs.get(p->name_); break;
@@ -536,16 +569,44 @@ QDataStream & operator>>(QDataStream & s, Scene *& p) {
 			p->root_->setScene(p);
 			break;
 		case 21: cs.get(geom_ind); break;
-		case 22: cs.get(mat_ind); break;
+		case 22:
+			cs.get(mat_ind_v0);
+			version = 0;
+			break;
+		case 23:
+			cs.get(mat_ind_v1);
+			version = 1;
+			break;
+		case 24: cs.get(preset); break;
 		}
 	}
 	p->makeMaterialsUniqueNames();
 	ObjectBaseList cl = p->root_->children(true);
-	int cnt           = qMin(qMin(cl.size(), geom_ind.size()), mat_ind.size());
+	int cnt           = qMin(cl.size(), geom_ind.size());
 	for (int i = 0; i < cnt; ++i) {
 		ObjectBase * c(cl[i]);
 		if (geom_ind[i] >= 0) c->mesh_ = p->geometries[geom_ind[i]];
-		if (mat_ind[i] >= 0) c->material_ = p->materials[mat_ind[i]];
 	}
+	if (version == 0) {
+		cnt = qMin(cl.size(), mat_ind_v0.size());
+		for (int i = 0; i < cnt; ++i) {
+			if (mat_ind_v0[i] >= 0) cl[i]->currentPreset().material = p->materials[mat_ind_v0[i]];
+		}
+	} else if (version == 1) {
+		cnt = qMin(cl.size(), mat_ind_v1.size());
+		for (int i = 0; i < cnt; ++i) {
+			ObjectBase * c(cl[i]);
+			const auto & matv(mat_ind_v1[i]);
+			if (c->presets.size() < matv.size()) c->presets.resize(matv.size());
+			for (int j = 0; j < matv.size(); ++j) {
+				if (matv[j] >= 0)
+					c->presets[j].material = p->materials[matv[j]];
+				else
+					c->presets[j].material = nullptr;
+			}
+		}
+	}
+	p->cur_preset = -1;
+	p->setPreset(preset);
 	return s;
 }

src/core/scene/glscene.h

@@ -90,6 +90,9 @@ public:
 
 	void removeLight(Light * l);
 
+	void setPreset(int preset);
+	int preset() const { return cur_preset; }
+
 	void dump();
 	void destroy(QOpenGLExtraFunctions * f);
 	void destroyUnused(QOpenGLExtraFunctions * f);
@@ -126,6 +129,7 @@ protected:
 	QList<Camera *> cameras_used;
 	QVector<Material *> changed_materials;
 
+	int cur_preset = 0;
 	SelectionMode sel_mode_;
 	ObjectBaseList selected_, selected_top;
 
@@ -136,6 +140,7 @@ signals:
 	void __destroyed();
 	void treeChanged();
 	void selectionChanged();
+	void presetChanged(int);
 };
 
 

src/core/shaders.qrc

@@ -1,5 +1,5 @@
 <RCC>
-    <qresource prefix="/">
+    <qresource prefix="/qglengine">
         <file>../../shaders/ds_final.glsl</file>
         <file>../../shaders/ds_geom.glsl</file>
         <file>../../shaders/ds_light.glsl</file>
@@ -16,5 +16,6 @@
         <file>../../shaders/service_line.glsl</file>
         <file>../../shaders/sum.glsl</file>
         <file>../../shaders/shadow.glsl</file>
+        <file>../../shaders/rescale.glsl</file>
     </qresource>
 </RCC>

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/mouse_controller.cpp

@@ -103,7 +103,7 @@ void MouseController::mousePressEvent(QMouseEvent * e) {
 		view->renderer_.mouse_rect = QRect();
 		return;
 	}
-	if (!QRect(QPoint(), view->pixelSize()).contains(cpos)) return;
+	if (!view->pixelRect().contains(cpos)) return;
 	lastPos = cpos;
 	downPos = cpos;
 	emit view->glMousePressEvent(e);
@@ -206,7 +206,7 @@ void MouseController::mouseMoveEvent(QMouseEvent * e) {
 		}
 		return;
 	}
-	QRect g_rect(QPoint(), view->pixelSize());
+	QRect g_rect = view->pixelRect();
 	if (mouseRotate_) {
 		float dx = cpos.x() - lastPos.x();
 		float dy = cpos.y() - lastPos.y();

src/core/view/openglwindow.cpp

@@ -81,6 +81,11 @@ QSize OpenGLWindow::pixelSize() const {
 }
 
 
+QRect OpenGLWindow::pixelRect() const {
+	return QRect(0, 0, pixelWidth(), pixelHeight());
+}
+
+
 // void OpenGLWindow::setSamples(int samples) {
 //	QSurfaceFormat f = requestedFormat();
 //	if (f.samples() != samples) {

src/core/view/openglwindow.h

@@ -30,6 +30,7 @@ public:
 	int pixelWidth() const;
 	int pixelHeight() const;
 	QSize pixelSize() const;
+	QRect pixelRect() const;
 
 public slots:
 	void renderLater();

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,26 +35,6 @@ using namespace QGLEngineShaders;
 
 QGLView::QGLView(): OpenGLWindow(), renderer_(this), mouse(this) {
 	setIcon(QIcon(":/icons/qglview.png"));
-	is_init              = false;
-	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;
-	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);
@@ -77,8 +60,6 @@ QGLView::QGLView(): OpenGLWindow(), renderer_(this), mouse(this) {
 	// setFeature(qglDepthOfFieldAutoFocusSpeed, 0.1);
 	// setFeature(qglDepthOfFieldFocus, 1.);
 	// setFeature(qglDepthOfFieldDiaphragm, 8.);
-	hoverHalo_ = selectionHalo_ = true;
-	fogEnabled_ = shaders_bind = false;
 	scene_          = new Scene();
 	connect(scene_, SIGNAL(selectionChanged()), this, SIGNAL(selectionChanged()));
 	connect(scene_, SIGNAL(__destroyed()), this, SLOT(__destroyed()));
@@ -102,7 +83,6 @@ QGLView::QGLView(): OpenGLWindow(), renderer_(this), mouse(this) {
 
 QGLView::~QGLView() {
 	stop();
-	scene_->clear();
 	delete scene_;
 	delete default_camera;
 }
@@ -159,8 +139,16 @@ void QGLView::timerEvent(QTimerEvent *) {
 
 
 void QGLView::render() {
-	resizeGL(pixelWidth(), pixelHeight());
+	QSize render_size = pixelSize();
+	if (!framebuffer_size.isEmpty()) render_size = framebuffer_size;
+	resizeGL(render_size.width(), render_size.height());
 	emit glBeginPaint();
+	glPointSize(settings.lineWidth);
+	glLineWidth(settings.lineWidth);
+	default_camera->setDepthStart(settings.depthStart);
+	default_camera->setFOV(settings.FOV);
+	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();
 	renderer_.renderScene();
 	emit glEndPaint();
@@ -198,7 +186,6 @@ void QGLView::initialize() {
 
 void QGLView::checkCaps() {
 	glGetIntegerv(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, &max_anisotropic);
-	shaders_supported = QOpenGLShaderProgram::hasOpenGLShaderPrograms();
 }
 
 
@@ -279,22 +266,25 @@ void QGLView::restoreCamera(const QByteArray & ba) {
 }
 
 
-void QGLView::setShadowMapSize(QSize sz) {
-	shadow_map_size = sz;
-}
-
-
 void QGLView::setTextureMapSize(QSize sz) {
 	renderer_.maps_size = sz;
 	renderer_.markReloadMaterials();
 }
 
 
-QSize QGLView::shadowMapSize() const {
+QSize QGLView::actualFramebufferSize() const {
-	return shadow_map_size;
+	QSize render_size = pixelSize();
+	if (!framebuffer_size.isEmpty()) render_size = framebuffer_size;
+	return render_size;
 }
 
 
-QSize QGLView::textureMapSize() const {
+QByteArray QGLView::saveSetting() const {
-	return renderer_.maps_size;
+	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 FOV() const { return settings.FOV; }
-	float depthStart() const { return camera()->depthStart(); }
+	float depthStart() const { return settings.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; }
@@ -158,21 +156,36 @@ public:
 		context_menu.addActions(al);
 	}
 	void popupMenu(const QPoint & pos, QAction * at = nullptr) { context_menu.popup(pos, at); }
-	void setGrabImage(bool on) { renderer_.setGrabImage(on); }
+	void setGrabImage(bool on) { grab_formats.setFlag(Renderer::gfImage, on); }
-	bool isGrabImage() const { return renderer_.isGrabImage(); }
+	void setGrabImageF(bool on) { grab_formats.setFlag(Renderer::gfFloat, on); }
+	QFlags<Renderer::GrabFormat> grabFormats() const { return grab_formats; }
+	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) { renderer_.grab_mipmap = 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; }
 
-	int softShadowsSamples() const { return soft_shadows_samples; }
+	void setFramebufferSize(QSize sz) { framebuffer_size = sz; }
-	void setSoftShadowsSamples(int s) { soft_shadows_samples = s; }
+	void resetFramebufferSize() { framebuffer_size = QSize(); }
-	float softShadowsQuality() const { return soft_shadows_quality; }
+	QSize framebufferSize() const { return framebuffer_size; }
-	void setSoftShadowsQuality(float s) { soft_shadows_quality = s; }
+	QSize actualFramebufferSize() const;
-	bool softShadows() const { return soft_shadows; }
+
-	void setSoftShadows(bool on) { soft_shadows = on; }
+	int softShadowsSamples() const { return settings.soft_shadows_samples; }
+	void setSoftShadowsSamples(int s) { settings.soft_shadows_samples = s; }
+	float softShadowsQuality() const { return settings.soft_shadows_quality; }
+	void setSoftShadowsQuality(float s) { settings.soft_shadows_quality = s; }
+	bool softShadows() const { return settings.soft_shadows; }
+	void setSoftShadows(bool on) { settings.soft_shadows = on; }
+	bool shadows() const { return settings.shadows; }
+	void setShadows(bool on) { settings.shadows = on; }
+
+	QByteArray saveSetting() const;
+	void loadSetting(QByteArray data);
 
 	GLfloat aspect, iaspect;
 	Renderer renderer_;
@@ -206,50 +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;
+	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, 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 setFOV(const float & arg) { settings.FOV = arg; }
-	void setDepthStart(const float & arg) { camera()->setDepthStart(arg); }
+	void setDepthStart(const float & arg) { settings.depthStart = 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(); }
 
@@ -274,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,61 @@
+/*
+    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;
+
+	ID(19) float depthStart           = 0.1f;
+	ID(20) float FOV                  = 60.f;
+};
+
+#undef ID
+
+#endif

src/qglview_test/qglview_window.cpp

@@ -124,7 +124,6 @@ QGLViewWindow::QGLViewWindow(QWidget * parent): QMainWindow(parent), Ui::QGLView
 		spinDOFDiaphragm->setValue(view->view()->feature(QGLView::qglDepthOfFieldDiaphragm).toDouble());
 		spinDOFSpeed->setValue(view->view()->feature(QGLView::qglDepthOfFieldAutoFocusSpeed).toDouble());
 	*/
-	view->view()->start(-1);
 	startTimer(1000 / 60);
 
 	connect(view->view(), SIGNAL(keyEvent(Qt::Key, Qt::KeyboardModifiers)), this, SLOT(view_keyEvent(Qt::Key, Qt::KeyboardModifiers)));
@@ -140,6 +139,7 @@ QGLViewWindow::QGLViewWindow(QWidget * parent): QMainWindow(parent), Ui::QGLView
 	auto * o = primitiveEditor->createCurrent();
 	o->calculateBoundingBox();
 	view->view()->focusOn(o->boundingBox());
+	view->view()->start(-1);
 
 	session.load();
 

src/qglview_test/qglview_window.ui

@@ -662,7 +662,7 @@
                      <number>0</number>
                     </property>
                     <item>
-                     <widget class="PIValueTreeEdit" name="widgetParameters" native="true"/>
+                     <widget class="PIValueTreeEdit" name="widgetParameters"/>
                     </item>
                     <item>
                      <spacer name="verticalSpacer_3">
@@ -854,7 +854,7 @@
   </widget>
   <action name="actionExit">
    <property name="icon">
-    <iconset resource="../core/qglengine_core.qrc">
+    <iconset resource="../../../qad/libs/qglview/qglview.qrc">
      <normaloff>:/icons/application-exit.png</normaloff>:/icons/application-exit.png</iconset>
    </property>
    <property name="text">
@@ -863,7 +863,7 @@
   </action>
   <action name="actionImport">
    <property name="icon">
-    <iconset resource="../core/qglengine_core.qrc">
+    <iconset resource="../../../qad/libs/qglview/qglview.qrc">
      <normaloff>:/icons/document-import.png</normaloff>:/icons/document-import.png</iconset>
    </property>
    <property name="text">
@@ -887,7 +887,7 @@
   </action>
   <action name="actionSave">
    <property name="icon">
-    <iconset resource="../../../qad/libs/widgets/qad_widgets.qrc">
+    <iconset resource="../../../qad/libs/qglview/qglview.qrc">
      <normaloff>:/icons/document-save-all.png</normaloff>:/icons/document-save-all.png</iconset>
    </property>
    <property name="text">
@@ -899,7 +899,7 @@
   </action>
   <action name="actionReset">
    <property name="icon">
-    <iconset resource="../../../qad/libs/widgets/qad_widgets.qrc">
+    <iconset resource="../../../qad/libs/qglview/qglview.qrc">
      <normaloff>:/icons/document-new.png</normaloff>:/icons/document-new.png</iconset>
    </property>
    <property name="text">
@@ -985,6 +985,12 @@
   </action>
  </widget>
  <customwidgets>
+  <customwidget>
+   <class>PIValueTreeEdit</class>
+   <extends>QWidget</extends>
+   <header>pivaluetree_edit.h</header>
+   <container>1</container>
+  </customwidget>
   <customwidget>
    <class>SpinSlider</class>
    <extends>QWidget</extends>
@@ -1032,16 +1038,10 @@
    <header>textures_editor.h</header>
    <container>1</container>
   </customwidget>
-  <customwidget>
-   <class>PIValueTreeEdit</class>
-   <extends>QWidget</extends>
-   <header>pivaluetree_edit.h</header>
-   <container>1</container>
-  </customwidget>
  </customwidgets>
  <resources>
   <include location="../../../qad/libs/blockview/qad_blockview.qrc"/>
-  <include location="../../../qad/libs/widgets/qad_widgets.qrc"/>
+  <include location="../../../qad/libs/qglview/qglview.qrc"/>
   <include location="../core/qglengine_core.qrc"/>
  </resources>
  <connections/>

src/widgets/CMakeLists.txt

@@ -1,4 +1,4 @@
-cmake_minimum_required(VERSION 3.0)
+cmake_minimum_required(VERSION 3.13)
 project(qglengine_widgets)
 if (POLICY CMP0017)
 	cmake_policy(SET CMP0017 NEW)

src/widgets/material_editor.cpp

@@ -36,7 +36,7 @@ MaterialEditor::MaterialEditor(QWidget * parent): QWidget(parent) {
 	ui->label_13->hide();
 	mat         = 0;
 	active      = true;
-	ignore_next = 0;
+	ignore_next = false;
 }
 
 
@@ -51,7 +51,7 @@ void MaterialEditor::changeEvent(QEvent * e) {
 
 void MaterialEditor::materialChanged() {
 	if (!active || !mat) return;
-	ignore_next         = 2;
+	ignore_next         = true;
 	mat->_changed       = true;
 	mat->color_diffuse  = ui->mapDiffuse->color();
 	mat->color_emission = ui->mapEmission->color();
@@ -65,8 +65,8 @@ void MaterialEditor::materialChanged() {
 
 
 void MaterialEditor::setMaterial(Material * m) {
-	if (ignore_next > 0) {
+	if (ignore_next) {
-		// ignore_next = false;
+		ignore_next = false;
 		return;
 	}
 	active = false;

src/widgets/material_editor.h

@@ -40,7 +40,7 @@ protected:
 	void changeEvent(QEvent * e);
 
 	bool active;
-	int ignore_next;
+	bool ignore_next;
 	Ui::MaterialEditor * ui;
 	Material * mat;
 

src/widgets/material_map_editor.ui

@@ -94,10 +94,10 @@
             <double>0.200000000000000</double>
            </property>
            <property name="spinMinimum">
-            <double>0.000000000000000</double>
+            <double>-999.000000000000000</double>
            </property>
            <property name="spinMaximum">
-            <double>1.000000000000000</double>
+            <double>9999.000000000000000</double>
            </property>
           </widget>
          </item>
@@ -192,10 +192,10 @@
         <item row="1" column="1">
          <widget class="SpinSlider" name="sliderAmount">
           <property name="minimum">
-           <double>-1.000000000000000</double>
+           <double>-2.000000000000000</double>
           </property>
           <property name="maximum">
-           <double>1.000000000000000</double>
+           <double>2.000000000000000</double>
           </property>
           <property name="value">
            <double>1.000000000000000</double>
@@ -210,10 +210,10 @@
            <double>0.200000000000000</double>
           </property>
           <property name="spinMinimum">
-           <double>-99.000000000000000</double>
+           <double>-999.000000000000000</double>
           </property>
           <property name="spinMaximum">
-           <double>99.000000000000000</double>
+           <double>9999.000000000000000</double>
           </property>
          </widget>
         </item>
@@ -242,10 +242,10 @@
            <double>0.200000000000000</double>
           </property>
           <property name="spinMinimum">
-           <double>-99.000000000000000</double>
+           <double>-999.000000000000000</double>
           </property>
           <property name="spinMaximum">
-           <double>99.000000000000000</double>
+           <double>9999.000000000000000</double>
           </property>
          </widget>
         </item>

src/widgets/materials_editor.cpp

@@ -107,16 +107,18 @@ void MaterialsEditor::selectionChanged() {
 	if (!view) return;
 	// qDebug() << "selectionChanged";
 	ObjectBase * o = view->selectedObject();
-	if (o) selectMaterial(o->material());
+	if (!o) return;
+	if (o->material()) selectMaterial(o->material());
 }
 
 
 void MaterialsEditor::materialsChanged() {
-	if (ui->widgetMaterial->ignore_next > 0) {
+	if (ui->widgetMaterial->ignore_next) {
-		ui->widgetMaterial->ignore_next--;
+		ui->widgetMaterial->ignore_next = false;
 		return;
 	}
 	Material * cm = currentMaterial();
+	ui->comboMaterial->blockSignals(true);
 	ui->comboMaterial->clear();
 	if (!view) return;
 	QVector<Material *> mats = view->scene()->getMaterials();
@@ -127,6 +129,8 @@ void MaterialsEditor::materialsChanged() {
 		ui->comboMaterial->setItemIcon(i, QIcon(QPixmap::fromImage(view->materialThumbnail(m))));
 		if (cm == m) ui->comboMaterial->setCurrentIndex(i);
 	}
+	ui->comboMaterial->blockSignals(false);
+	if (currentMaterial() != cm) on_comboMaterial_currentIndexChanged(ui->comboMaterial->currentIndex());
 }
 
 
@@ -153,6 +157,7 @@ void MaterialsEditor::on_buttonRename_clicked() {
 	int ind = ui->comboMaterial->currentIndex();
 	ui->comboMaterial->setItemText(ind, QString("[%1] " + nn).arg(ind + 1));
 	ui->comboMaterial->setItemData(ind, nn);
+	view->scene()->treeChanged();
 }
 
 
@@ -193,6 +198,7 @@ void MaterialsEditor::on_buttonAssign_clicked() {
 	ObjectBaseList ol = view->selectedObjects();
 	foreach(ObjectBase * o, ol)
 		o->setMaterial(m, true);
+	view->scene()->treeChanged();
 }
 
 

src/widgets/object_editor.ui

@@ -60,7 +60,7 @@
       <property name="geometry">
        <rect>
         <x>0</x>
-        <y>-287</y>
+        <y>-306</y>
         <width>444</width>
         <height>1100</height>
        </rect>
@@ -590,7 +590,7 @@
              <bool>true</bool>
             </property>
             <property name="spinMaximum">
-             <double>999.000000000000000</double>
+             <double>9999.000000000000000</double>
             </property>
            </widget>
           </item>
@@ -847,6 +847,9 @@
             <property name="maximum">
              <double>999999999.000000000000000</double>
             </property>
+            <property name="singleStep">
+             <double>0.010000000000000</double>
+            </property>
             <property name="value">
              <double>0.100000000000000</double>
             </property>
@@ -874,7 +877,7 @@
              <number>1</number>
             </property>
             <property name="singleStep">
-             <double>5.000000000000000</double>
+             <double>1.000000000000000</double>
             </property>
             <property name="pageStep">
              <double>30.000000000000000</double>
@@ -966,6 +969,9 @@
    <class>ColorButton</class>
    <extends>QPushButton</extends>
    <header>colorbutton.h</header>
+   <slots>
+    <signal>colorChanged(QColor)</signal>
+   </slots>
   </customwidget>
   <customwidget>
    <class>ScrollSpinBox</class>

src/widgets/scene_tree.cpp

@@ -19,13 +19,16 @@
 #include "scene_tree.h"
 
 #include "glcamera.h"
+#include "glmesh.h"
 #include "qglview.h"
 #include "ui_scene_tree.h"
 
 #include <QAction>
 #include <QEvent>
+#include <QMessageBox>
 #include <QScrollBar>
 #include <QTreeWidget>
+#include <qad_types.h>
 
 enum Column {
 	cName,
@@ -109,9 +112,9 @@ QList<QAction *> SceneTree::actionsAdd() {
 QList<QAction *> SceneTree::actionsSelection() {
 	QList<QAction *> ret;
 	ret << ui->actionFocus << newSeparator() << ui->actionGroup << ui->actionClone << newSeparator() << ui->actionSelect_parent
-		<< ui->actionSelect_by_mesh << ui->actionSelect_by_material << newSeparator() << ui->actionMove_to_parent
+		<< ui->actionSelect_by_mesh << ui->actionSelect_by_material << newSeparator() << ui->actionMesh_info << newSeparator()
-		<< ui->actionTransfer_transform_to_children << newSeparator() << ui->actionActive_camera << ui->actionDefault_camera
+		<< ui->actionMove_to_parent << ui->actionTransfer_transform_to_children << newSeparator() << ui->actionActive_camera
-		<< newSeparator() << ui->actionRemove;
+		<< ui->actionDefault_camera << newSeparator() << ui->actionRemove;
 	return ret;
 }
 
@@ -309,6 +312,7 @@ void SceneTree::checkActions() {
 	ui->actionSelect_parent->setEnabled(has_1);
 	ui->actionSelect_by_mesh->setEnabled(has_mesh);
 	ui->actionSelect_by_material->setEnabled(has_mesh);
+	ui->actionMesh_info->setEnabled(has_mesh);
 	ui->actionActive_camera->setEnabled(has_cam);
 	ui->actionDefault_camera->setEnabled(!is_def_cam);
 }
@@ -506,8 +510,34 @@ void SceneTree::on_actionSelect_by_material_triggered() {
 }
 
 
+void SceneTree::on_actionMesh_info_triggered() {
+	if (!view) return;
+	ObjectBaseList sol = view->scene()->selectedObjects(true);
+	for (auto o: sol) {
+		if (o->mesh()) {
+			auto m             = o->mesh();
+			int objects        = 0;
+			ObjectBaseList aol = view->scene()->objects(true);
+			for (auto i: aol)
+				if (i->mesh() == m) ++objects;
+
+			auto bb = o->mesh()->boundingBox();
+			QString info;
+			QTextStream ts(&info);
+			ts << "Vertices: " << m->verticesCount() << "\n";
+			ts << "Triangles: " << m->trianglesCount() << "\n";
+			ts << "Bounding box: " << bb.length << "x" << bb.width << "x" << bb.height << "\n";
+			ts << "Objects with this mesh: " << objects << "\n";
+			QMessageBox::information(nullptr, tr("Mesh info"), info);
+			break;
+		}
+	}
+}
+
+
 void SceneTree::removeObjects() {
 	if (!view) return;
+	QAD::CursorOverrider curov;
 	QList<QTreeWidgetItem *> sil = ui->treeObjects->selectedItems();
 	foreach(QTreeWidgetItem * i, sil) {
 		ObjectBase * o = itemObject(i);

src/widgets/scene_tree.h

@@ -61,6 +61,10 @@ private:
 	QList<QTreeWidgetItem *> geo_items, cam_items;
 	QGLView * view;
 
+public slots:
+	void removeObjects();
+	void focusObjects();
+
 private slots:
 	void treeObjects_selectionCnahged();
 	void on_treeObjects_itemChanged(QTreeWidgetItem * item, int column);
@@ -84,8 +88,8 @@ private slots:
 	void on_actionSelect_by_mesh_triggered();
 	void on_actionSelect_by_material_triggered();
 
-	void removeObjects();
+	void on_actionMesh_info_triggered();
-	void focusObjects();
+
 	void objectsTreeChanged();
 	void selectionChanged();
 	void materialsChanged();

src/widgets/scene_tree.ui

@@ -130,7 +130,7 @@
   </layout>
   <action name="actionFocus">
    <property name="icon">
-    <iconset resource="../../../qad/libs/qglview/qglview.qrc">
+    <iconset resource="../core/qglengine_core.qrc">
      <normaloff>:/icons/type-camera.png</normaloff>:/icons/type-camera.png</iconset>
    </property>
    <property name="text">
@@ -175,7 +175,7 @@
   </action>
   <action name="actionSelect_by_mesh">
    <property name="icon">
-    <iconset resource="../../../qad/libs/qglview/qglview.qrc">
+    <iconset resource="../core/qglengine_core.qrc">
      <normaloff>:/icons/type-geo.png</normaloff>:/icons/type-geo.png</iconset>
    </property>
    <property name="text">
@@ -235,7 +235,7 @@
     <bool>true</bool>
    </property>
    <property name="icon">
-    <iconset resource="../../../qad/libs/qglview/qglview.qrc">
+    <iconset resource="../core/qglengine_core.qrc">
      <normaloff>:/icons/type-geo.png</normaloff>:/icons/type-geo.png</iconset>
    </property>
    <property name="text">
@@ -247,7 +247,7 @@
     <bool>true</bool>
    </property>
    <property name="icon">
-    <iconset resource="../../../qad/libs/qglview/qglview.qrc">
+    <iconset resource="../core/qglengine_core.qrc">
      <normaloff>:/icons/type-light.png</normaloff>:/icons/type-light.png</iconset>
    </property>
    <property name="text">
@@ -259,7 +259,7 @@
     <bool>true</bool>
    </property>
    <property name="icon">
-    <iconset resource="../../../qad/libs/qglview/qglview.qrc">
+    <iconset resource="../core/qglengine_core.qrc">
      <normaloff>:/icons/type-camera.png</normaloff>:/icons/type-camera.png</iconset>
    </property>
    <property name="text">
@@ -273,7 +273,7 @@
   </action>
   <action name="actionActive_camera">
    <property name="icon">
-    <iconset resource="../../../qad/libs/qglview/qglview.qrc">
+    <iconset resource="../core/qglengine_core.qrc">
      <normaloff>:/icons/type-camera.png</normaloff>:/icons/type-camera.png</iconset>
    </property>
    <property name="text">
@@ -282,7 +282,7 @@
   </action>
   <action name="actionDefault_camera">
    <property name="icon">
-    <iconset resource="../../../qad/libs/qglview/qglview.qrc">
+    <iconset resource="../core/qglengine_core.qrc">
      <normaloff>:/icons/type-camera.png</normaloff>:/icons/type-camera.png</iconset>
    </property>
    <property name="text">
@@ -298,6 +298,15 @@
     <string>Move to parent</string>
    </property>
   </action>
+  <action name="actionMesh_info">
+   <property name="icon">
+    <iconset resource="../../../cd/utils/pult/cdpult.qrc">
+     <normaloff>:/icons/dialog-information.png</normaloff>:/icons/dialog-information.png</iconset>
+   </property>
+   <property name="text">
+    <string>Mesh info ...</string>
+   </property>
+  </action>
  </widget>
  <customwidgets>
   <customwidget>
@@ -312,9 +321,9 @@
   </customwidget>
  </customwidgets>
  <resources>
+  <include location="../../../cd/utils/pult/cdpult.qrc"/>
   <include location="../../../qad/libs/application/qad_application.qrc"/>
   <include location="../../../qad/libs/blockview/qad_blockview.qrc"/>
-  <include location="../../../qad/libs/qglview/qglview.qrc"/>
   <include location="../core/qglengine_core.qrc"/>
   <include location="widgets.qrc"/>
  </resources>

src/widgets/view_editor.cpp

@@ -43,9 +43,30 @@ 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;
+	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());
 	ui->checkHoverHalo->setChecked(view->isHoverHaloEnabled());
@@ -54,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());
@@ -64,9 +87,11 @@ void ViewEditor::assignQGLView(QGLView * v) {
 	ui->colorFogBack->setColor(view->fogColor());
 	ui->spinFogDecay->setValue(view->fogDecay());
 	ui->spinFogDensity->setValue(view->fogDensity());
+	ui->groupShadows->setChecked(view->shadows());
 	ui->checkSoftShadows->setChecked(view->softShadows());
 	ui->spinSoftShadowSamples->setValue(view->softShadowsSamples());
 	ui->spinSoftShadowQuality->setValue(view->softShadowsQuality());
+	ui->spinLineWidth->setValue(view->lineWidth());
 	auto setMapSize = [](QComboBox * combo, QSize sz) {
 		for (int i = 0; i < combo->count(); ++i) {
 			if (combo->itemData(i).toSize() == sz) {
@@ -81,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);
@@ -115,6 +131,12 @@ void ViewEditor::on_comboViewRenderMode_currentIndexChanged(int val) {
 }
 
 
+void ViewEditor::on_groupShadows_clicked(bool val) {
+	if (!view || !active) return;
+	view->setShadows(val);
+}
+
+
 void ViewEditor::on_groupHalos_clicked(bool val) {
 	if (!view || !active) return;
 	view->setHoverHaloEnabled(val && ui->checkHoverHalo->isChecked());
@@ -206,6 +228,11 @@ void ViewEditor::on_buttonHDRSelect_clicked() {
 }
 
 
+void ViewEditor::on_buttonPresetSet_clicked() {
+	view->scene()->setPreset(ui->spinPreset->value());
+}
+
+
 void ViewEditor::on_colorFogBack_colorChanged(const QColor & color) {
 	if (!view || !active) return;
 	view->setFogColor(color);
@@ -254,6 +281,12 @@ void ViewEditor::on_spinSoftShadowQuality_valueChanged(double arg1) {
 }
 
 
+void ViewEditor::on_spinLineWidth_valueChanged(double v) {
+	if (!view || !active) return;
+	view->setLineWidth(v);
+}
+
+
 void ViewEditor::on_checkVSync_clicked(bool val) {
 	if (!view || !active) return;
 	view->setVSync(val);

src/widgets/view_editor.h

@@ -43,10 +43,12 @@ 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);
 	void on_comboViewRenderMode_currentIndexChanged(int val);
+	void on_groupShadows_clicked(bool val);
 	void on_groupHalos_clicked(bool val);
 	void on_checkHoverHalo_clicked(bool val);
 	void on_checkSelectionHalo_clicked(bool val);
@@ -62,6 +64,7 @@ private slots:
 	void on_checkVSync_clicked(bool val);
 	void on_buttonHDRClear_clicked();
 	void on_buttonHDRSelect_clicked();
+	void on_buttonPresetSet_clicked();
 	void on_colorFogBack_colorChanged(const QColor & color);
 	void on_spinFogDensity_valueChanged(double arg1);
 	void on_spinFogDecay_valueChanged(double arg1);
@@ -70,6 +73,7 @@ private slots:
 	void on_checkSoftShadows_clicked(bool arg1);
 	void on_spinSoftShadowSamples_valueChanged(double arg1);
 	void on_spinSoftShadowQuality_valueChanged(double arg1);
+	void on_spinLineWidth_valueChanged(double v);
 };
 
 #endif // VIEW_EDITOR_H

src/widgets/view_editor.ui

@@ -7,7 +7,7 @@
     <x>0</x>
     <y>0</y>
     <width>479</width>
-    <height>737</height>
+    <height>976</height>
    </rect>
   </property>
   <layout class="QVBoxLayout" name="verticalLayout_3">
@@ -36,8 +36,8 @@
        <rect>
         <x>0</x>
         <y>0</y>
-        <width>453</width>
+        <width>479</width>
-        <height>807</height>
+        <height>976</height>
        </rect>
       </property>
       <layout class="QVBoxLayout" name="verticalLayout">
@@ -161,6 +161,30 @@
        </item>
        <item>
         <layout class="QGridLayout" name="gridLayout_2">
+         <item row="1" column="0">
+          <widget class="QCheckBox" name="checkFXAA">
+           <property name="text">
+            <string>FXAA</string>
+           </property>
+          </widget>
+         </item>
+         <item row="2" column="0">
+          <widget class="QCheckBox" name="checkVSync">
+           <property name="text">
+            <string>VSync</string>
+           </property>
+           <property name="checked">
+            <bool>true</bool>
+           </property>
+          </widget>
+         </item>
+         <item row="0" column="0">
+          <widget class="QCheckBox" name="checkAutoExposure">
+           <property name="text">
+            <string>Auto exposure</string>
+           </property>
+          </widget>
+         </item>
          <item row="1" column="1">
           <widget class="QCheckBox" name="checkCameraLight">
            <property name="text">
@@ -181,55 +205,120 @@
            </property>
           </widget>
          </item>
-         <item row="1" column="0">
-          <widget class="QCheckBox" name="checkFXAA">
-           <property name="text">
-            <string>FXAA</string>
-           </property>
-          </widget>
-         </item>
-         <item row="0" column="0">
-          <widget class="QCheckBox" name="checkAutoExposure">
-           <property name="text">
-            <string>Auto exposure</string>
-           </property>
-          </widget>
-         </item>
-         <item row="2" column="0">
-          <widget class="QCheckBox" name="checkVSync">
-           <property name="text">
-            <string>VSync</string>
-           </property>
-           <property name="checked">
-            <bool>true</bool>
-           </property>
-          </widget>
-         </item>
          <item row="2" column="1">
-          <widget class="QCheckBox" name="checkSoftShadows">
+          <widget class="QWidget" name="widget_2" native="true">
+           <layout class="QHBoxLayout" name="horizontalLayout_2">
+            <property name="leftMargin">
+             <number>0</number>
+            </property>
+            <property name="topMargin">
+             <number>0</number>
+            </property>
+            <property name="rightMargin">
+             <number>0</number>
+            </property>
+            <property name="bottomMargin">
+             <number>0</number>
+            </property>
+            <item>
+             <widget class="QLabel" name="label_11">
               <property name="text">
-            <string>Soft shadows</string>
+               <string>Preset:</string>
               </property>
-           <property name="checked">
+             </widget>
-            <bool>true</bool>
+            </item>
+            <item>
+             <widget class="QSpinBox" name="spinPreset"/>
+            </item>
+            <item>
+             <widget class="QPushButton" name="buttonPresetSet">
+              <property name="minimumSize">
+               <size>
+                <width>1</width>
+                <height>1</height>
+               </size>
               </property>
+              <property name="text">
+               <string>Set</string>
+              </property>
+             </widget>
+            </item>
+            <item>
+             <widget class="QLabel" name="labelPreset">
+              <property name="text">
+               <string>0</string>
+              </property>
+             </widget>
+            </item>
+           </layout>
+          </widget>
+         </item>
+         <item row="3" column="0">
+          <widget class="QWidget" name="widget_3" native="true">
+           <layout class="QHBoxLayout" name="horizontalLayout_4">
+            <property name="leftMargin">
+             <number>0</number>
+            </property>
+            <property name="topMargin">
+             <number>0</number>
+            </property>
+            <property name="rightMargin">
+             <number>0</number>
+            </property>
+            <property name="bottomMargin">
+             <number>0</number>
+            </property>
+            <item>
+             <widget class="QLabel" name="label_12">
+              <property name="sizePolicy">
+               <sizepolicy hsizetype="Fixed" vsizetype="Preferred">
+                <horstretch>0</horstretch>
+                <verstretch>0</verstretch>
+               </sizepolicy>
+              </property>
+              <property name="text">
+               <string>Line width:</string>
+              </property>
+             </widget>
+            </item>
+            <item>
+             <widget class="QDoubleSpinBox" name="spinLineWidth">
+              <property name="decimals">
+               <number>1</number>
+              </property>
+              <property name="minimum">
+               <double>0.100000000000000</double>
+              </property>
+              <property name="value">
+               <double>1.000000000000000</double>
+              </property>
+             </widget>
+            </item>
+           </layout>
           </widget>
          </item>
         </layout>
        </item>
        <item>
+        <widget class="QGroupBox" name="groupShadows">
+         <property name="title">
+          <string>Shadows</string>
+         </property>
+         <property name="checkable">
+          <bool>true</bool>
+         </property>
          <layout class="QFormLayout" name="formLayout_2">
           <property name="labelAlignment">
            <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
           </property>
-         <item row="0" column="0">
+          <item row="1" column="0">
            <widget class="QLabel" name="label_9">
             <property name="text">
              <string>Soft shadow samples:</string>
             </property>
            </widget>
           </item>
-         <item row="0" column="1">
+          <item row="1" column="1">
            <widget class="SpinSlider" name="spinSoftShadowSamples">
             <property name="minimum">
              <double>1.000000000000000</double>
@@ -245,14 +334,14 @@
             </property>
            </widget>
           </item>
-         <item row="1" column="0">
+          <item row="2" column="0">
            <widget class="QLabel" name="label_10">
             <property name="text">
              <string>Soft shadow quality:</string>
             </property>
            </widget>
           </item>
-         <item row="1" column="1">
+          <item row="2" column="1">
            <widget class="SpinSlider" name="spinSoftShadowQuality">
             <property name="minimum">
              <double>0.100000000000000</double>
@@ -268,7 +357,18 @@
             </property>
            </widget>
           </item>
+          <item row="0" column="0" colspan="2">
+           <widget class="QCheckBox" name="checkSoftShadows">
+            <property name="text">
+             <string>Soft shadows</string>
+            </property>
+            <property name="checked">
+             <bool>true</bool>
+            </property>
+           </widget>
+          </item>
          </layout>
+        </widget>
        </item>
        <item>
         <widget class="QGroupBox" name="groupCamera">
@@ -343,8 +443,11 @@
               <property name="maximum">
                <double>999999999.000000000000000</double>
               </property>
+              <property name="singleStep">
+               <double>0.010000000000000</double>
+              </property>
               <property name="value">
-               <double>1.000000000000000</double>
+               <double>0.100000000000000</double>
               </property>
              </widget>
             </item>
@@ -484,32 +587,6 @@
               </property>
              </widget>
             </item>
-            <item row="1" column="1">
-             <layout class="QHBoxLayout" name="horizontalLayout_3">
-              <item>
-               <widget class="SpinSlider" name="spinFogDensity">
-                <property name="minimum">
-                 <double>0.000000000000000</double>
-                </property>
-                <property name="maximum">
-                 <double>10.000000000000000</double>
-                </property>
-                <property name="value">
-                 <double>0.000000000000000</double>
-                </property>
-                <property name="decimals">
-                 <number>3</number>
-                </property>
-                <property name="singleStep">
-                 <double>0.050000000000000</double>
-                </property>
-                <property name="pageStep">
-                 <double>0.100000000000000</double>
-                </property>
-               </widget>
-              </item>
-             </layout>
-            </item>
             <item row="2" column="0">
              <widget class="QLabel" name="label_25">
               <property name="text">
@@ -517,34 +594,6 @@
               </property>
              </widget>
             </item>
-            <item row="2" column="1">
-             <widget class="SpinSlider" name="spinFogDecay">
-              <property name="minimum">
-               <double>0.000000000000000</double>
-              </property>
-              <property name="maximum">
-               <double>9999.000000000000000</double>
-              </property>
-              <property name="value">
-               <double>10.000000000000000</double>
-              </property>
-              <property name="decimals">
-               <number>2</number>
-              </property>
-              <property name="singleStep">
-               <double>0.050000000000000</double>
-              </property>
-              <property name="pageStep">
-               <double>0.100000000000000</double>
-              </property>
-              <property name="squareScale">
-               <bool>true</bool>
-              </property>
-              <property name="spinMaximum">
-               <double>9999.000000000000000</double>
-              </property>
-             </widget>
-            </item>
             <item row="0" column="1">
              <widget class="ColorButton" name="colorFogBack">
               <property name="color">
@@ -563,6 +612,23 @@
               </property>
              </widget>
             </item>
+            <item row="1" column="1">
+             <widget class="ScrollSpinBox" name="spinFogDensity">
+              <property name="minimum">
+               <number>0</number>
+              </property>
+             </widget>
+            </item>
+            <item row="2" column="1">
+             <widget class="ScrollSpinBox" name="spinFogDecay">
+              <property name="value">
+               <double>10.000000000000000</double>
+              </property>
+              <property name="minimum">
+               <number>0</number>
+              </property>
+             </widget>
+            </item>
            </layout>
           </widget>
          </item>
@@ -634,6 +700,14 @@
    <class>ColorButton</class>
    <extends>QPushButton</extends>
    <header>colorbutton.h</header>
+   <slots>
+    <signal>colorChanged(QColor)</signal>
+   </slots>
+  </customwidget>
+  <customwidget>
+   <class>ScrollSpinBox</class>
+   <extends>QWidget</extends>
+   <header>scroll_spin_box.h</header>
   </customwidget>
  </customwidgets>
  <resources>

src/widgets/widgets.qrc

@@ -15,5 +15,6 @@
 	<file>../icons/group.png</file>
 	<file>../icons/legend.png</file>
 	<file>../icons/format-fill-color.png</file>
+	<file>../icons/dialog-information.png</file>
   </qresource>
 </RCC>