shadows flag in Renderer

.clang-format

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

CMakeLists.txt

@@ -1,4 +1,4 @@
-cmake_minimum_required(VERSION 3.13)
+cmake_minimum_required(VERSION 3.0)
 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    4)
+	set(QGLEngine_MINOR    0)
 	set(QGLEngine_REVISION 0)
 	set(QGLEngine_SUFFIX   "rc")
 	set(QGLEngine_COMPANY  SHS)

shaders/ds_light.glsl

@@ -21,14 +21,16 @@ 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];
+#ifdef SHADOWS
 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 bool soft_shadows_enabled = false, shadows_enabled = false;
+uniform bool soft_shadows_enabled = false;
 uniform float soft_shadows_quality = 1.;
 uniform int soft_shadows_samples = 16, noise_size = 64;
+#endif
 uniform samplerCube tex_env;
 uniform int lights_start, lights_count;
 uniform vec4 fog_color = vec4(0.5, 0.5, 0.5, 1.);
@@ -55,6 +57,7 @@ vec4 mapScreenToShadow(in int light_index, in vec3 offset) {
 }
 
 
+#ifdef SHADOWS
 #ifdef SPOT
 
 float getShadowCone(in vec3 uvz, in int layer) {
@@ -142,6 +145,7 @@ float rand(vec2 co) {
     float e = sin(mod(d, 3.14)) * c;
     return fract(e) - 0.5;
 }
+#endif // SHADOWS
 
 vec4 qgl_lightTexture(int index, vec2 coord, vec4 tex_shift) {
 	coord *= qgl_light_parameter[index].map.scale;
@@ -174,7 +178,8 @@ void calcLight(in int index, in vec3 n, in vec3 v) {
 	spot *= light_map_pix.a;
 #endif
 
-	if (shadows_enabled && (int(round(qgl_light_parameter[index].flags)) == 1) && (bitfieldExtract(flags, 3, 1) == 1) && (spot > 1E-4)) {
+#ifdef SHADOWS
+	if (int(round(qgl_light_parameter[index].flags)) == 1 && bitfieldExtract(flags, 3, 1) == 1 && (spot > 1E-4)) {
 #ifndef SPOT
 		vec3 odir = -(view_mat * ldir);
 #endif
@@ -261,6 +266,7 @@ void calcLight(in int index, in vec3 n, in vec3 v) {
 		//shadow += getShadowCone(shp.xyz, layer, vec2(0));
 		
 	}
+#endif // SHADOWS
 	
 	vec3 dist_decay = vec3(1., ldist, ldist*ldist);
 	spot /= dot(qgl_light_parameter[index].decay_intensity.xyz, dist_decay);
@@ -301,9 +307,7 @@ 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;
@@ -338,10 +342,7 @@ 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);
+	vec3 res_col = max(vec3(0.), li * diffuse + si * spec_col + emission);
-#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

@@ -1,15 +0,0 @@
-// 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,10 +11,9 @@ 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 = texture(fb_out   , stc);
+	vec4 src = texelFetch(fb_out   , tc, 0);
 	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.13)
+cmake_minimum_required(VERSION 3.0)
 project(qglengine_core)
 if (POLICY CMP0017)
 	cmake_policy(SET CMP0017 NEW)
@@ -22,9 +22,8 @@ set_deploy_property(${PROJECT_NAME} ${QGLEngine_LIB_TYPE}
 	COMPANY  "${QGLEngine_COMPANY}"
 	INFO "QGLEngine core library")
 make_rc(${PROJECT_NAME} _RC)
-pip_code_model(CCM0 "render/renderer.h" OPTIONS "-DQGLENGINE_CORE_EXPORT" "-Es" NAME "ccm_renderer")
+pip_code_model(CCM "render/renderer.h" OPTIONS "-DQGLENGINE_CORE_EXPORT" "-Es")
-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} ${CCM})
-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() - 1, rect_.width(), rect_.height(), GL_RGBA, pixel_format, 0);
+	f->glReadPixels(rect_.x(), height() - rect_.bottom(), rect_.width(), rect_.height(), GL_RGBA, pixel_format, 0);
 	pbo_queried = rect_.width() * rect_.height();
 	pbo.release(f);
 }
@@ -152,11 +152,6 @@ 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;
@@ -227,16 +222,7 @@ 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(),
+	f->glBlitFramebuffer(from.x(), from.y(), from.right(), from.bottom(), to.x(), to.y(), to.right(), to.bottom(), mask, filter);
-						 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,7 +48,6 @@ 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,12 +37,6 @@ 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,7 +37,6 @@ 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,24 +172,12 @@ bool Mesh::rebuffer(QOpenGLExtraFunctions * f) {
 	buffer_geom.load(f, data_.constData(), gsize);
 
 	buffer_ind.bind(f);
-	switch (geom_type) {
+	if (geom_type == GL_TRIANGLES) {
-	case GL_TRIANGLES:
 		buffer_ind.resize(f, tsize);
 		buffer_ind.load(f, triangles_.constData(), tsize);
-		break;
+	} else {
-	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();
@@ -204,12 +192,10 @@ void Mesh::draw(QOpenGLExtraFunctions * f, int count, int type) {
 
 	VertexObject * vao = vaoByType(type);
 	vao->bindBuffers(f, buffer_geom, buffer_ind);
-	switch (geom_type) {
+	if (geom_type == GL_TRIANGLES)
-	case GL_TRIANGLES: vao->draw(f, geom_type, triangles_.size() * 3, count); break;
+		vao->draw(f, geom_type, triangles_.size() * 3, count);
-	case GL_LINES: vao->draw(f, geom_type, lines_.size() * 2, count); break;
+	else
-	case GL_POINTS: vao->draw(f, geom_type, vertices_.size(), count); break;
+		vao->draw(f, geom_type, lines_.size() * 2, count);
-	default: break;
-	}
 }
 
 

src/core/core/gltransform.cpp

@@ -161,14 +161,6 @@ 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,7 +32,6 @@ 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,9 +196,6 @@ 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_renderer.h"
+#include "ccm_qglengine_core.h"
 #include "glmesh.h"
 #include "glshaders.h"
 #include "gltexture_manager.h"
@@ -31,8 +31,6 @@
 #include <piqt.h>
 #include <qad_types.h>
 
-#define SHADERS_DIR ":/qglengine"
-
 
 using namespace QGLEngineShaders;
 
@@ -47,9 +45,7 @@ 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);
@@ -100,13 +96,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";
+	shader_defines[srLightSpotPass] << "SHADOWS";
+	shader_defines[srLightOmniPass] << "SHADOWS";
 
-	PICodeInfo::EnumInfo * obre = PICODEINFO::enums().value("Renderer::DeferredBufferRole");
+	PICodeInfo::EnumInfo * obre = PICodeInfo::enumsInfo->value("Renderer::DeferredBufferRole");
 	if (obre) {
 		for (auto e: obre->members) {
 			obr_defines += "#define " + PI2QString(e.name) + " " + QString::number(e.value) + "\n";
@@ -139,12 +135,8 @@ 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(256, 256);
+	rend_mat.init(width, height);
 	rend_service.init(width, height);
 	rend_selection.init(width, height);
 	tone_proc.init();
@@ -153,19 +145,17 @@ void Renderer::init(int width, int height) {
 	initCoeffTextures();
 	markReloadTextures();
 	tex_env.init();
-	fbo_out.enablePixelBuffer();
+	if (is_grabbing) fbo_out.enablePixelBuffer();
 	need_init_shaders = true;
 }
 
 
 void Renderer::resize(int width, int height) {
-	rend_mat.resize(256, 256);
+	rend_mat.resize(width, height);
 	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();
 }
 
@@ -179,7 +169,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_DIR "/shaders/";
+	QString dir          = ":/shaders/";
 	while (it.hasNext()) {
 		it.next();
 		loadShadersMulti(shaders[it.key()], dir + it.value(), true, shader_defines.value(it.key()), obr_defines);
@@ -233,10 +223,6 @@ 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);
@@ -254,9 +240,6 @@ void Renderer::initShaders() {
 		prog->setUniformValue("tex_0", 0);
 		prog->setUniformValue("tex_sum", 1);
 	}
-	if (bindShader(srRescale, &prog)) {
-		prog->setUniformValue("tex_0", 0);
-	}
 }
 
 
@@ -312,24 +295,6 @@ 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]);
@@ -380,23 +345,25 @@ 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, true, fbo_ds.size());
+			setUniformCamera(prog, cam);
-			setUniformViewCorners(prog, cam, fbo_ds.size());
+			setUniformViewCorners(prog, cam);
 			prog->setUniformValue("lights_start", lights_start[pass.second]);
 			prog->setUniformValue("lights_count", (int)cur_lights[pass.second].size());
-			prog->setUniformValue("fog_color", color2vector(view->fogColor()) / 2.);
+			prog->setUniformValue("fog_color", view->fogColor());
 			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("noise_size", noise_size);
+			if (shadows_enabled) {
-			prog->setUniformValue("shadows_enabled", view->shadows());
-			if (view->shadows()) {
 				prog->setUniformValue("shadow_size", view->shadow_map_size);
-				prog->setUniformValue("soft_shadows_enabled", view->settings.soft_shadows);
+				prog->setUniformValue("noise_size", noise_size);
-				prog->setUniformValue("soft_shadows_samples", view->settings.soft_shadows_samples);
+				prog->setUniformValue("soft_shadows_enabled", view->soft_shadows);
-				prog->setUniformValue("soft_shadows_quality", view->settings.soft_shadows_quality);
+				prog->setUniformValue("soft_shadows_samples", view->soft_shadows_samples);
+				prog->setUniformValue("soft_shadows_quality", view->soft_shadows_quality);
+				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);
 				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);
@@ -429,11 +396,20 @@ 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];
+			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", l->view_proj_matrix);
+				prog->setUniformValue("qgl_ViewProjMatrix", vpm);
 				renderConeShadow(i, l);
 			}
+			l->shadow_matrix = mat_norm_to_tex_coord * vpm * mat_camera_fullview_inv;
 		}
 	}
 }
@@ -536,10 +512,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();
 
@@ -550,10 +526,7 @@ void Renderer::renderScene() {
 	}
 	phase.end();
 
-	/// setup cone lights matrices
+	if (shadows_enabled) {
-	setConeShadowMatrix();
-
-	if (view->shadows()) {
 		/// cone shadows and shadow matrix
 		phase.begin("shadows cone");
 		renderConeShadows();
@@ -573,7 +546,7 @@ void Renderer::renderScene() {
 	}
 	if (use_camlight) {
 		cur_lights[Light::Omni] << cam_light;
-		cam_light->setPos(cam->worldPos());
+		cam_light->setPos(cam->pos());
 	}
 	if (scene.lights_changed) {
 		scene.lights_changed = false;
@@ -596,7 +569,7 @@ void Renderer::renderScene() {
 	glEnableDepth();
 	glClearFramebuffer();
 	if (bindShader(srGeometrySolidPass, &prog)) {
-		setUniformCamera(prog, cam, true, fbo_ds.size());
+		setUniformCamera(prog, cam);
 		textures_empty.bind(f, tarEmpty);
 		textures_maps.bind(f, tarMaps);
 		prog->setUniformValue("out_index_normal", dbrNormalZSolid);
@@ -625,7 +598,7 @@ void Renderer::renderScene() {
 	glClearFramebuffer(Qt::black, false);
 	fbo_ds.setWriteBuffers();
 	if (bindShader(srGeometryTransparentPass, &prog)) {
-		setUniformCamera(prog, cam, true, fbo_ds.size());
+		setUniformCamera(prog, cam);
 		textures_empty.bind(f, tarEmpty);
 		textures_maps.bind(f, tarMaps);
 		prog->setUniformValue("out_index_normal", dbrNormalZ);
@@ -661,11 +634,10 @@ 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", view->settings.gamma);
+		prog->setUniformValue("gamma", gamma_);
 		prog->setUniformValue("frame_max", tone_proc.frameMax());
 		// qDebug() << tone_proc.frameMax();
 		fbo_out.bindColorTexture(prev_write_plane, 0);
@@ -677,7 +649,7 @@ void Renderer::renderScene() {
 
 	/// FXAA
 	phase.begin("fxaa");
-	if (view->settings.FXAA) {
+	if (view->FXAA_) {
 		prog = shader_fxaa;
 		if (bindShader(prog)) {
 			auto free = getFreePlanes(0);
@@ -698,51 +670,24 @@ 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 {
-		phase.begin("blit to screen");
+		fbo_out.blit(cur_write_plane, 0, 0, fbo_out.rect(), QRect(QPoint(), view->pixelSize()));
-		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 (view->grabFormats().testFlag(gfImage)) {
+	if (is_grabbing) {
-		if (grab_mipmap == 0) {
+		fbo_out.queryImage(0);
-			fbo_out.queryImage(cur_write_plane);
+		last_img = fbo_out.getImage().mirrored();
-			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();
 
 	/*
@@ -780,8 +725,24 @@ 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;
 	fb_effects << e;
 }
+
+void Renderer::setSadowsEnabled(bool on) {
+	shader_defines[srLightSpotPass].removeAll("SHADOWS");
+	shader_defines[srLightOmniPass].removeAll("SHADOWS");
+	if (on) {
+		shader_defines[srLightSpotPass] << "SHADOWS";
+		shader_defines[srLightOmniPass] << "SHADOWS";
+	}
+	shadows_enabled = on;
+	reloadShaders();
+}

src/core/render/renderer.h

@@ -20,7 +20,6 @@
 #define RENDERER_H
 
 #include "glcubemap.h"
-#include "glframebuffer.h"
 #include "glframebuffereffectbase.h"
 #include "renderer_base.h"
 #include "renderer_material.h"
@@ -60,7 +59,6 @@ class QGLENGINE_CORE_EXPORT Renderer: public RendererBase {
 		srTonemapPass,
 		srShadowConePass,
 		srShadowOmniPass,
-		srRescale
 	};
 	enum OutBufferRole {
 		obrSolidOmni,
@@ -94,10 +92,6 @@ public:
 
 		dbrBuffersCount,
 	};
-	enum GrabFormat {
-		gfImage = 1,
-		gfFloat = 2
-	};
 
 	void init(int width, int height);
 	void resize(int width, int height);
@@ -105,8 +99,9 @@ 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; }
@@ -115,9 +110,11 @@ public:
 	QImage materialThumbnail(Material * m) { return rend_mat.materialThumbnail(m); }
 	void recreateMaterialThumbnails(bool force_all = false) { rend_mat.recreateMaterialThumbnails(force_all); }
 
+	void setSadowsEnabled(bool on);
+	bool isShadowsEnabled() const { return shadows_enabled; }
+
 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();
@@ -133,8 +130,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;
@@ -161,10 +158,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 shadows_enabled = true;
+	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->isCastShadows() ? 1 : 0;
+		so.flags              = l->cast_shadow ? 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(width, height);
+	fbo_mat_thumb.resize(256, 256);
 }
 
 

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(), true, r->fbo_ds.size());
+		r->setUniformCamera(prog, view->camera());
 		r->renderObjects(scene, rpSolid);
 		r->renderObjects(scene, rpTransparent);
 		view->glClear(GL_DEPTH_BUFFER_BIT);
@@ -138,12 +138,10 @@ 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, mapPoint(r->mouse_pos));
+			fbo_selection.queryPoint(0, r->mouse_pos * scale_);
 		else
-			fbo_selection.queryPoints(0, QRect(mapPoint(r->mouse_rect.topLeft()), mapSize(r->mouse_rect.size())));
+			fbo_selection.queryPoints(0, QRect(r->mouse_rect.topLeft() * scale_, r->mouse_rect.size() * scale_));
 
 		// qDebug() << id_hover;
 		fbo_selection.bindColorTexture(sbrSrcHover, sbrSrcHover);

src/core/render/renderer_selection.h

@@ -57,7 +57,6 @@ 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(), true, r->fbo_ds.size());
+		r->setUniformCamera(prog, r->view->camera());
 
 		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(), true, r->fbo_ds.size());
+		r->setUniformCamera(prog, r->view->camera());
 		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(), true, r->fbo_ds.size());
+		r->setUniformCamera(prog, r->view->camera());
 
 		/// handles
 		f->glEnable(GL_BLEND);
@@ -504,15 +504,13 @@ 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(prev_view[0], prev_view[1], prev_view[2], prev_view[3]);
+		f->glViewport(0, 0, r->view->pixelWidth(), r->view->pixelHeight());
 	}
 	f->glDisable(GL_MULTISAMPLE);
 }

src/core/scene/glcamera.cpp

@@ -74,13 +74,10 @@ QMatrix4x4 Camera::viewMatrix() const {
 	// qDebug() << pos() << aim();
 	ret.translate(0., 0., -distance());
 	ret.rotate(-roll_, 0., 0., 1.);
-	ret *= trans.matrixRotate().inverted();
+	ret *= trans.matrixRotateScale().inverted();
 	if (parent_) {
-		Transform tr;
+		QMatrix4x4 pmat = parent_->worldTransform();
-		tr.setMatrix(parent_->worldTransform());
+		offset_         = pmat.column(3).toVector3D();
-		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,12 +26,22 @@
 // static int _count = 0;
 
 ObjectBase::ObjectBase(Mesh * geom, Material * mat) {
-	blend_src  = GL_SRC_ALPHA;
+	type_     = glMesh;
-	blend_dest = GL_ONE_MINUS_SRC_ALPHA;
+	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();
-	mesh_ = geom;
+	scene_    = nullptr;
-	setPreset(0);
+	mesh_     = geom;
-	currentPreset().material = mat;
+	material_ = mat;
 	// qDebug() << "ObjectBase, now" << ++_count;
 }
 
@@ -55,8 +65,9 @@ ObjectBase * ObjectBase::clone(bool withChildren) {
 	ObjectBase * o   = new ObjectBase();
 	o->prev_pass     = prev_pass;
 	o->is_init       = false;
-	o->presets       = presets;
+	o->accept_light  = accept_light;
-	o->cur_preset    = cur_preset;
+	o->accept_fog    = accept_fog;
+	o->visible_      = visible_;
 	o->color_        = color_;
 	o->type_         = type_;
 	o->raw_matrix    = raw_matrix;
@@ -69,6 +80,7 @@ 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;
@@ -95,8 +107,8 @@ void ObjectBase::init() {
 
 RenderPass ObjectBase::pass() const {
 	RenderPass ret = rpSolid;
-	if (currentPreset().material)
+	if (material_)
-		if (currentPreset().material->hasTransparency()) ret = rpTransparent;
+		if (material_->hasTransparency()) ret = rpTransparent;
 	return ret;
 }
 
@@ -194,11 +206,11 @@ ObjectBaseList ObjectBase::children(bool all_) {
 
 
 bool ObjectBase::isVisible(bool check_parents) const {
-	if (!check_parents) return currentPreset().visible;
+	if (!check_parents) return visible_;
-	if (!currentPreset().visible) return false;
+	if (!visible_) return false;
 	ObjectBase * p = parent_;
 	while (p) {
-		if (!p->currentPreset().visible) return false;
+		if (!p->visible_) return false;
 		p = p->parent_;
 	}
 	return true;
@@ -206,122 +218,19 @@ bool ObjectBase::isVisible(bool check_parents) const {
 
 
 void ObjectBase::setVisible(bool v) {
-	currentPreset().visible = v;
+	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) {
-	currentPreset().cast_shadow = on;
+	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;
@@ -333,20 +242,6 @@ 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);
@@ -357,111 +252,6 @@ 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();
@@ -518,23 +308,6 @@ 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;
@@ -606,18 +379,6 @@ 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;
@@ -648,32 +409,15 @@ ObjectBase * ObjectBase::selectedParent() const {
 
 
 void ObjectBase::setMaterial(Material * m, bool with_children) {
-	currentPreset().material = m;
+	material_ = m;
 	if (with_children)
-		for (auto * i: children_)
+		foreach(ObjectBase * 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)
@@ -899,24 +643,15 @@ 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_)
@@ -925,8 +660,7 @@ 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 ...";
@@ -987,19 +721,19 @@ QDataStream & operator>>(QDataStream & s, ObjectBase *& p) {
 			if (p) p->type_ = type;
 		} break;
 		case 2:
-			if (p) p->currentPreset().accept_light = cs.getData<bool>();
+			if (p) p->accept_light = cs.getData<bool>();
 			break;
 		case 3:
-			if (p) p->currentPreset().accept_fog = cs.getData<bool>();
+			if (p) p->accept_fog = cs.getData<bool>();
 			break;
 		case 4:
-			if (p) p->currentPreset().visible = cs.getData<bool>();
+			if (p) p->visible_ = cs.getData<bool>();
 			break;
 		case 5:
-			if (p) p->currentPreset().cast_shadow = cs.getData<bool>();
+			if (p) p->cast_shadow = cs.getData<bool>();
 			break;
 		case 6:
-			if (p) p->currentPreset().receive_shadow = cs.getData<bool>();
+			if (p) p->rec_shadow = cs.getData<bool>();
 			break;
 		case 7:
 			if (p) p->raw_matrix = cs.getData<bool>();
@@ -1028,12 +762,6 @@ 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,7 +30,6 @@ 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:
@@ -41,7 +40,7 @@ public:
 		glParticlesSystem
 	};
 
-	explicit ObjectBase(Mesh * geom = nullptr, Material * mat = nullptr);
+	explicit ObjectBase(Mesh * geom = 0, Material * mat = 0);
 	virtual ~ObjectBase();
 
 	virtual ObjectBase * clone(bool withChildren = true);
@@ -82,29 +81,67 @@ 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 currentPreset().receive_shadow; }
+	bool isReceiveShadows() const { return rec_shadow; }
-	bool isCastShadows() const { return currentPreset().cast_shadow; }
+	bool isCastShadows() const { return 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) {
-	void moveTo(const QVector3D & dv);
+		trans.setTranslation(pos() + dv);
-	void move(GLfloat dx, GLfloat dy, GLfloat dz = 0.);
+		buildTransform();
-	void moveTo(GLfloat dx, GLfloat dy, GLfloat dz = 0.);
+	}
-	void moveX(GLfloat o);
+	void moveTo(const QVector3D & dv) {
-	void moveY(GLfloat o);
+		trans.setTranslation(dv);
-	void moveZ(GLfloat o);
+		buildTransform();
-	void setPosX(GLfloat o);
+	}
-	void setPosY(GLfloat o);
+	void move(GLfloat dx, GLfloat dy, GLfloat dz = 0.) {
-	void setPosZ(GLfloat o);
+		move(QVector3D(dx, dy, dz));
-	void setPos(GLfloat x, GLfloat y, GLfloat z);
+		buildTransform();
-	void setPos(const QVector3D & p);
+	}
-	void resetPos();
+	void moveTo(GLfloat dx, GLfloat dy, GLfloat dz = 0.) {
+		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(); }
@@ -117,32 +154,108 @@ 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) {
-	void rotateY(GLfloat a);
+		raw_matrix = false;
+		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) {
-	void setRotationY(GLfloat a);
+		raw_matrix = false;
+		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) {
-	void resetRotation();
+		raw_matrix = false;
+		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) {
-	void scale(GLfloat sx, GLfloat sy, GLfloat sz);
+		raw_matrix = false;
-	void scale(GLfloat sx, GLfloat sy);
+		trans.setScale(trans.scale3D() * sv);
-	void scale(GLfloat sx);
+		buildTransform();
-	void scaleX(GLfloat a);
+	}
-	void scaleY(GLfloat a);
+	void scale(GLfloat sx, GLfloat sy, GLfloat sz) {
-	void scaleZ(GLfloat a);
+		raw_matrix = false;
-	void setScale(const QVector3D & a);
+		scale(QVector3D(sx, sy, sz));
-	void setScale(GLfloat a);
+		buildTransform();
-	void setScaleX(GLfloat a);
+	}
-	void setScaleY(GLfloat a);
+	void scale(GLfloat sx, GLfloat sy) {
-	void setScaleZ(GLfloat a);
+		raw_matrix = false;
-	void resetScale();
+		scale(QVector3D(sx, sy, sy));
+		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);
@@ -160,11 +273,17 @@ public:
 	QMatrix4x4 textureMatrix() const;
 	QGenericMatrix<3, 2, float> textureGLMatrix() const;
 
-	bool isAcceptLight() const { return currentPreset().accept_light; }
+	bool isAcceptLight() const { return accept_light; }
-	void setAcceptLight(bool yes);
+	void setAcceptLight(bool yes) {
+		accept_light = yes;
+		setObjectsChanged();
+	}
 
-	bool isAcceptFog() const { return currentPreset().accept_fog; }
+	bool isAcceptFog() const { return 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);
@@ -183,9 +302,7 @@ public:
 	void setDestAlpha(GLenum mode) { blend_dest = mode; }
 
 	void setMaterial(Material * m, bool with_children = false);
-	void setMaterialForPreset(Material * m, int p, bool with_children = false);
+	Material * material() { return material_; }
-	Material * material() { return currentPreset().material; }
-	Material * materialForPreset(int p);
 
 	void setColor(QColor c, bool with_children = false);
 	QColor color() { return color_; }
@@ -202,24 +319,9 @@ 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);
@@ -228,27 +330,24 @@ 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  = rpSolid; // Pass
+	int prev_pass; // Pass
-	int cur_preset = 0;
+	bool is_init, accept_light, accept_fog, visible_, cast_shadow, rec_shadow, select_, selected_, raw_matrix;
-	bool is_init = false, select_ = true, selected_ = false, raw_matrix = false;
+	bool is_root, selected_aim;
-	bool is_root = false, selected_aim = false;
+	float line_width;
-	float line_width = -1.f;
+	QColor color_;
-	QVector<Preset> presets;
+	uint id_;
-	QColor color_ = Qt::white;
+	Type type_;
-	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_ = nullptr;
+	ObjectBase * parent_;
-	Scene * scene_       = nullptr;
+	Scene * scene_;
-	Mesh * mesh_         = nullptr;
+	Material * material_;
+	Mesh * mesh_;
 	QVariantMap meta;
 };
 
@@ -327,7 +426,7 @@ public:
 	float size;
 	Type light_type;
 	Framebuffer shadow_map;
-	QMatrix4x4 shadow_matrix, view_proj_matrix;
+	QMatrix4x4 shadow_matrix;
 	Map light_map;
 };
 
@@ -342,8 +441,6 @@ 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,7 +91,6 @@ 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;
 }
 
@@ -108,9 +107,6 @@ void Scene::clear() {
 	emit __destroyed();
 	if (destroying) return;
 	emit treeChanged();
-	mat_changed = lights_changed = true;
-	need_reload_materials        = true;
-	tree_struct_changed          = true;
 }
 
 
@@ -325,16 +321,11 @@ Material * Scene::newMaterial(const QString & name) {
 void Scene::removeMaterial(Material * m) {
 	if (!m || !materials.contains(m)) return;
 	ObjectBaseList ol = root_->children(true);
-	for (auto * o: ol)
+	foreach(ObjectBase * o, ol)
-		for (auto & p: o->presets)
+		if (o->material_ == m) o->setMaterial(0);
-			if (p.material == m) {
-				p.material = nullptr;
-				o->setObjectsChanged();
-			}
 	materials.removeAll(m);
 	changed_materials.removeAll(m);
-	mat_changed  = true;
+	mat_changed = true;
-	tree_changed = true;
 }
 
 
@@ -358,15 +349,6 @@ 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();
@@ -389,31 +371,28 @@ void Scene::attachObject(ObjectBase * o) {
 		o->setMesh(attachMesh(o->mesh()));
 		setObjectMeshChanged(o);
 	}
-	for (auto & p: o->presets) {
+	if (o->material()) { // search suitable material in this scene
-		if (p.material) { // search suitable material in this scene
+		uint ohash    = o->material()->hash();
-			uint ohash    = p.material->hash();
+		bool need_new = true;
-			bool need_new = true;
+		foreach(Material * m, materials) {
-			foreach(Material * m, materials) {
+			if (m == o->material()) { // already exists by ptr
-				if (m == p.material) { // already exists by ptr
+				need_new = false;
-					need_new = false;
+				break;
-					break;
-				}
-				if (m->hash() == ohash) { // already exists by hash
-					need_new   = false;
-					p.material = m;
-					break;
-				}
 			}
-			if (need_new) { // need to clone material and add to scene
+			if (m->hash() == ohash) { // already exists by hash
-				Material * nmat = new Material();
+				need_new = false;
-				*nmat           = *(p.material);
+				o->setMaterial(m);
-				nmat->setMapsChanged();
+				break;
-				p.material = nmat;
-				materials << nmat;
 			}
 		}
+		if (need_new) { // need to clone material and add to scene
+			Material * nmat = new Material();
+			*nmat           = *(o->material());
+			nmat->setMapsChanged();
+			o->setMaterial(nmat);
+			materials << nmat;
+		}
 	}
-	o->setPreset(cur_preset);
 	setTreeStructChanged();
 }
 
@@ -528,25 +507,15 @@ void Scene::destroyUnused(QOpenGLExtraFunctions * f) {
 QDataStream & operator<<(QDataStream & s, const Scene * p) {
 	ChunkStream cs;
 	// qDebug() << "place" << p->name() << "...";
-	QVector<short> geom_ind, mats;
+	QVector<short> geom_ind, mat_ind;
-	QVector<QVector<short>> mat_ind;
 	ObjectBaseList cl = p->root_->children(true);
 	geom_ind.reserve(cl.size());
 	mat_ind.reserve(cl.size());
-	for (auto * c: cl) {
+	foreach(ObjectBase * c, cl) {
 		geom_ind << p->geometries.indexOf(c->mesh());
-		mats.clear();
+		mat_ind << p->materials.indexOf(c->material());
-		for (auto i: c->presets)
-			mats << p->materials.indexOf(i.material);
-		mat_ind << mats;
 	}
-	cs.add(1, p->name_)
+	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);
-		.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;
 }
@@ -556,9 +525,7 @@ QDataStream & operator>>(QDataStream & s, Scene *& p) {
 	s >> ba;
 	ba = qUncompress(ba);
 	ChunkStream cs(ba);
-	QVector<short> geom_ind, mat_ind_v0;
+	QVector<short> geom_ind, mat_ind;
-	QVector<QVector<short>> mat_ind_v1;
-	int version = 0, preset = 0;
 	while (!cs.atEnd()) {
 		switch (cs.read()) {
 		case 1: cs.get(p->name_); break;
@@ -569,44 +536,16 @@ QDataStream & operator>>(QDataStream & s, Scene *& p) {
 			p->root_->setScene(p);
 			break;
 		case 21: cs.get(geom_ind); break;
-		case 22:
+		case 22: cs.get(mat_ind); break;
-			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(cl.size(), geom_ind.size());
+	int cnt           = qMin(qMin(cl.size(), geom_ind.size()), mat_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,9 +90,6 @@ 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);
@@ -129,7 +126,6 @@ protected:
 	QList<Camera *> cameras_used;
 	QVector<Material *> changed_materials;
 
-	int cur_preset = 0;
 	SelectionMode sel_mode_;
 	ObjectBaseList selected_, selected_top;
 
@@ -140,7 +136,6 @@ signals:
 	void __destroyed();
 	void treeChanged();
 	void selectionChanged();
-	void presetChanged(int);
 };
 
 

src/core/shaders.qrc

@@ -1,21 +1,20 @@
 <RCC>
-    <qresource prefix="/qglengine">
+    <qresource prefix="/">
-        <file>../../shaders/ds_final.glsl</file>
+		<file>../../shaders/ds_final.glsl</file>
-        <file>../../shaders/ds_geom.glsl</file>
+		<file>../../shaders/ds_geom.glsl</file>
-        <file>../../shaders/ds_light.glsl</file>
+		<file>../../shaders/ds_light.glsl</file>
-        <file>../../shaders/ds_tonemap.glsl</file>
+		<file>../../shaders/ds_tonemap.glsl</file>
-        <file>../../shaders/fxaa.frag</file>
+		<file>../../shaders/fxaa.frag</file>
-        <file>../../shaders/fxaa.vert</file>
+		<file>../../shaders/fxaa.vert</file>
-        <file>../../shaders/fxaa_v3.h</file>
+		<file>../../shaders/fxaa_v3.h</file>
-        <file>../../shaders/selection.glsl</file>
+		<file>../../shaders/selection.glsl</file>
-        <file>../../shaders/selection_apply.glsl</file>
+		<file>../../shaders/selection_apply.glsl</file>
-        <file>../../shaders/selection_frame.glsl</file>
+		<file>../../shaders/selection_frame.glsl</file>
-        <file>../../shaders/selection_halo.glsl</file>
+		<file>../../shaders/selection_halo.glsl</file>
-        <file>../../shaders/service_fill.glsl</file>
+		<file>../../shaders/service_fill.glsl</file>
-        <file>../../shaders/service_frame.glsl</file>
+		<file>../../shaders/service_frame.glsl</file>
-        <file>../../shaders/service_line.glsl</file>
+		<file>../../shaders/service_line.glsl</file>
-        <file>../../shaders/sum.glsl</file>
+		<file>../../shaders/sum.glsl</file>
-        <file>../../shaders/shadow.glsl</file>
+		<file>../../shaders/shadow.glsl</file>
-        <file>../../shaders/rescale.glsl</file>
     </qresource>
 </RCC>

src/core/view/glwidget.cpp

@@ -62,6 +62,11 @@ qreal GLWidget::depthStart() const {
 }
 
 
+bool GLWidget::isLightEnabled() const {
+	return view_->isLightEnabled();
+}
+
+
 bool GLWidget::isGrabMouseEnabled() const {
 	return view_->isGrabMouseEnabled();
 }
@@ -152,6 +157,11 @@ 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,6 +56,7 @@ public:
 	qreal FOV() const;
 	qreal depthStart() const;
 	QColor ambientColor() const;
+	bool isLightEnabled() const;
 	bool isGrabMouseEnabled() const;
 	bool isMouseRotateEnabled() const;
 	bool isMouseSelectionEnabled() const;
@@ -77,6 +78,7 @@ 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 (!view->pixelRect().contains(cpos)) return;
+	if (!QRect(QPoint(), view->pixelSize()).contains(cpos)) return;
 	lastPos = cpos;
 	downPos = cpos;
 	emit view->glMousePressEvent(e);
@@ -206,7 +206,7 @@ void MouseController::mouseMoveEvent(QMouseEvent * e) {
 		}
 		return;
 	}
-	QRect g_rect = view->pixelRect();
+	QRect g_rect(QPoint(), view->pixelSize());
 	if (mouseRotate_) {
 		float dx = cpos.x() - lastPos.x();
 		float dy = cpos.y() - lastPos.y();

src/core/view/openglwindow.cpp

@@ -81,11 +81,6 @@ 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,7 +30,6 @@ public:
 	int pixelWidth() const;
 	int pixelHeight() const;
 	QSize pixelSize() const;
-	QRect pixelRect() const;
 
 public slots:
 	void renderLater();

src/core/view/qglview.cpp

@@ -18,7 +18,6 @@
 
 #include "qglview.h"
 
-#include "ccm_qglview.h"
 #include "glmesh.h"
 #include "gltexture_manager.h"
 
@@ -26,8 +25,6 @@
 #include <QKeyEvent>
 #include <QOpenGLTexture>
 #include <chunkstream.h>
-#include <pichunkstream.h>
-#include <piqt.h>
 #include <qad_types.h>
 
 using namespace QGLEngineShaders;
@@ -35,7 +32,27 @@ using namespace QGLEngineShaders;
 
 QGLView::QGLView(): OpenGLWindow(), renderer_(this), mouse(this) {
 	setIcon(QIcon(":/icons/qglview.png"));
-	shadow_map_size = QSize(512, 512);
+	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);
 	// setFeature(qglEyeAccomodationEnabled, false);
@@ -60,7 +77,9 @@ QGLView::QGLView(): OpenGLWindow(), renderer_(this), mouse(this) {
 	// setFeature(qglDepthOfFieldAutoFocusSpeed, 0.1);
 	// setFeature(qglDepthOfFieldFocus, 1.);
 	// setFeature(qglDepthOfFieldDiaphragm, 8.);
-	scene_          = new Scene();
+	hoverHalo_ = selectionHalo_ = true;
+	fogEnabled_ = shaders_bind = false;
+	scene_                     = new Scene();
 	connect(scene_, SIGNAL(selectionChanged()), this, SIGNAL(selectionChanged()));
 	connect(scene_, SIGNAL(__destroyed()), this, SLOT(__destroyed()));
 	connect(scene_, SIGNAL(__objectDeleted(ObjectBase *)), this, SLOT(__objectDeleted(ObjectBase *)));
@@ -83,6 +102,7 @@ QGLView::QGLView(): OpenGLWindow(), renderer_(this), mouse(this) {
 
 QGLView::~QGLView() {
 	stop();
+	scene_->clear();
 	delete scene_;
 	delete default_camera;
 }
@@ -139,17 +159,9 @@ void QGLView::timerEvent(QTimerEvent *) {
 
 
 void QGLView::render() {
-	QSize render_size = pixelSize();
+	resizeGL(pixelWidth(), pixelHeight());
-	if (!framebuffer_size.isEmpty()) render_size = framebuffer_size;
-	resizeGL(render_size.width(), render_size.height());
 	emit glBeginPaint();
-	glPointSize(settings.lineWidth);
+	renderer_.mouse_pos = mapFromGlobal(QCursor::pos()) * devicePixelRatio();
-	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();
 	fps_tm = time.elapsed();
@@ -186,6 +198,7 @@ void QGLView::initialize() {
 
 void QGLView::checkCaps() {
 	glGetIntegerv(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, &max_anisotropic);
+	shaders_supported = QOpenGLShaderProgram::hasOpenGLShaderPrograms();
 }
 
 
@@ -266,25 +279,22 @@ 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::actualFramebufferSize() const {
+QSize QGLView::shadowMapSize() const {
-	QSize render_size = pixelSize();
+	return shadow_map_size;
-	if (!framebuffer_size.isEmpty()) render_size = framebuffer_size;
-	return render_size;
 }
 
 
-QByteArray QGLView::saveSetting() const {
+QSize QGLView::textureMapSize() const {
-	return piqSerialize(settings);
+	return renderer_.maps_size;
-}
-
-
-void QGLView::loadSetting(QByteArray data) {
-	settings = piqDeserialize<QGLViewSettings>(data);
-	emit settingsLoaded();
 }

src/core/view/qglview.h

@@ -26,7 +26,6 @@
 #include "mouse_controller.h"
 #include "openglwindow.h"
 #include "qglengine_core_export.h"
-#include "qglview_settings.h"
 #include "renderer.h"
 
 #include <QElapsedTimer>
@@ -44,6 +43,7 @@ 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,33 +86,35 @@ public:
 	void stop();
 	void start(float freq = 0.);
 
-	float lineWidth() const { return settings.lineWidth; }
+	float lineWidth() const { return lineWidth_; }
-	float FOV() const { return settings.FOV; }
+	float FOV() const { return camera()->FOV(); }
-	float depthStart() const { return settings.depthStart; }
+	float depthStart() const { return camera()->depthStart(); }
 	float currentFPS() const { return fps_; }
-	float gamma() const { return settings.gamma; }
+	float gamma() const { return renderer_.gamma_; }
-	bool autoExposure() const { return settings.autoExposure; }
+	bool autoExposure() const { return renderer_.tone_proc.enabled; }
 	int maxAnisotropicLevel() const { return max_anisotropic; }
 	QString environmentMapFile() const { return renderer_.tex_env.fileHDR(); }
-	bool FXAA() const { return settings.FXAA; }
+	bool FXAA() const { return FXAA_; }
-	void setFXAA(bool on) { settings.FXAA = on; }
+	void setFXAA(bool on) { FXAA_ = on; }
 
-	QColor fogColor() const { return settings.fogColor; }
+	QColor fogColor() const { return fogColor_; }
-	float fogDensity() const { return settings.fogDensity; }
+	float fogDensity() const { return fogDensity_; }
-	float fogDecay() const { return settings.fogDecay; }
+	float fogDecay() const { return 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 settings.hoverHalo; }
+	bool isHoverHaloEnabled() const { return hoverHalo_; }
-	QColor hoverHaloColor() const { return settings.hoverHaloColor; }
+	QColor hoverHaloColor() const { return hoverHaloColor_; }
-	float hoverHaloFillAlpha() const { return settings.hoverHaloFill; }
+	float hoverHaloFillAlpha() const { return hoverHaloFill_; }
-	bool isSelectionHaloEnabled() const { return settings.selectionHalo; }
+	bool isSelectionHaloEnabled() const { return selectionHalo_; }
-	QColor selectionHaloColor() const { return settings.selectionHaloColor; }
+	QColor selectionHaloColor() const { return selectionHaloColor_; }
-	float selectionHaloFillAlpha() const { return settings.selectionHaloFill; }
+	float selectionHaloFillAlpha() const { return selectionHaloFill_; }
 
-	int renderMode() const { return settings.render_mode; }
+	int renderMode() const { return (int)render_mode; }
-	void setRenderMode(int mode) { settings.render_mode = mode; }
+	void setRenderMode(int mode) { render_mode = (RenderMode)mode; }
 
 	bool isServiceMode() const { return renderer_.edit_mode; }
 	void setServiceMode(bool yes) { renderer_.edit_mode = yes; }
@@ -156,36 +158,21 @@ public:
 		context_menu.addActions(al);
 	}
 	void popupMenu(const QPoint & pos, QAction * at = nullptr) { context_menu.popup(pos, at); }
-	void setGrabImage(bool on) { grab_formats.setFlag(Renderer::gfImage, on); }
+	void setGrabImage(bool on) { renderer_.setGrabImage(on); }
-	void setGrabImageF(bool on) { grab_formats.setFlag(Renderer::gfFloat, on); }
+	bool isGrabImage() const { return renderer_.isGrabImage(); }
-	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) { shadow_map_size = sz; }
+	void setShadowMapSize(QSize sz);
 	void setTextureMapSize(QSize sz);
-	QSize shadowMapSize() const { return shadow_map_size; }
+	QSize shadowMapSize() const;
-	QSize textureMapSize() const { return renderer_.maps_size; }
+	QSize textureMapSize() const;
 
-	void setFramebufferSize(QSize sz) { framebuffer_size = sz; }
+	int softShadowsSamples() const { return soft_shadows_samples; }
-	void resetFramebufferSize() { framebuffer_size = QSize(); }
+	void setSoftShadowsSamples(int s) { soft_shadows_samples = s; }
-	QSize framebufferSize() const { return framebuffer_size; }
+	float softShadowsQuality() const { return soft_shadows_quality; }
-	QSize actualFramebufferSize() const;
+	void setSoftShadowsQuality(float s) { soft_shadows_quality = s; }
-
+	bool softShadows() const { return soft_shadows; }
-	int softShadowsSamples() const { return settings.soft_shadows_samples; }
+	void setSoftShadows(bool on) { soft_shadows = on; }
-	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_;
@@ -219,45 +206,50 @@ private:
 	MouseController mouse;
 	QMenu context_menu;
 	QSet<int> keys_;
+	QColor fogColor_, hoverHaloColor_, selectionHaloColor_;
 	QElapsedTimer time;
-	GLint max_anisotropic = 1, max_texture_chanels = 8;
+	GLint max_anisotropic, max_texture_chanels;
-	QFlags<Renderer::GrabFormat> grab_formats;
+	RenderMode render_mode;
-	QSize prev_size, shadow_map_size, framebuffer_size;
+	QSize prev_size, shadow_map_size;
-	QGLViewSettings settings;
+	float lineWidth_, soft_shadows_quality;
-	float fps_ = 0.f, fps_tm = 0.f;
+	float fps_, fps_tm, fogDensity_, fogDecay_;
-	float m_motionBlurFactor = 1.f;
+	float hoverHaloFill_, selectionHaloFill_, m_motionBlurFactor;
-	int timer = 0, fps_cnt = 0, sh_id_loc = 0;
+	int timer, fps_cnt, sh_id_loc, soft_shadows_samples;
-	bool shaders_bind = false;
+	bool fogEnabled_, lightEnabled_, FXAA_;
-	bool is_init      = false;
+	bool shaders_supported, shaders_bind;
+	bool hoverHalo_, selectionHalo_;
+	bool is_init, soft_shadows;
 
 private slots:
 	void __destroyed();
 	void __objectDeleted(ObjectBase * o);
 
 public slots:
-	void setLineWidth(const float & arg) { settings.lineWidth = arg; }
+	void setLineWidth(const float & arg) { lineWidth_ = arg; }
-	void setFOV(const float & arg) { settings.FOV = arg; }
+	void setFOV(const float & arg) { camera()->setFOV(arg); }
-	void setDepthStart(const float & arg) { settings.depthStart = arg; }
+	void setDepthStart(const float & arg) { camera()->setDepthStart(arg); }
-	void setGamma(const float & arg) { settings.gamma = arg; }
+	void setGamma(const float & arg) { renderer_.gamma_ = arg; }
-	void setAutoExposure(bool arg) { settings.autoExposure = arg; }
+	void setAutoExposure(bool arg) { renderer_.tone_proc.enabled = arg; }
 	void setEnvironmentMapFile(QString file) {
 		renderer_.tex_env.setFileHDR(file);
 		renderer_.recreateMaterialThumbnails(true);
 	}
-	void setFogColor(const QColor & arg) { settings.fogColor = arg; }
+	void setFogColor(const QColor & arg) { fogColor_ = arg; }
-	void setFogDensity(const float & arg) { settings.fogDensity = arg; }
+	void setFogDensity(const float & arg) { fogDensity_ = arg; }
-	void setFogDecay(const float & arg) { settings.fogDecay = arg; }
+	void setFogDecay(const float & arg) { 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) { settings.hoverHalo = arg; }
+	void setHoverHaloEnabled(const bool & arg) { hoverHalo_ = arg; }
-	void setHoverHaloColor(const QColor & arg) { settings.hoverHaloColor = arg; }
+	void setHoverHaloColor(const QColor & arg) { hoverHaloColor_ = arg; }
-	void setHoverHaloFillAlpha(const float & arg) { settings.hoverHaloFill = arg; }
+	void setHoverHaloFillAlpha(const float & arg) { hoverHaloFill_ = arg; }
-	void setSelectionHaloEnabled(const bool & arg) { settings.selectionHalo = arg; }
+	void setSelectionHaloEnabled(const bool & arg) { selectionHalo_ = arg; }
-	void setSelectionHaloColor(const QColor & arg) { settings.selectionHaloColor = arg; }
+	void setSelectionHaloColor(const QColor & arg) { selectionHaloColor_ = arg; }
-	void setSelectionHaloFillAlpha(const float & arg) { settings.selectionHaloFill = arg; }
+	void setSelectionHaloFillAlpha(const float & arg) { selectionHaloFill_ = arg; }
 
 	void reloadShaders() { renderer_.reloadShaders(); }
 
@@ -282,7 +274,6 @@ signals:
 	void materialsChanged();
 	void materialThumbnailCreated(Material *);
 	void doubleClick();
-	void settingsLoaded();
 };
 
 #endif // QGLVIEW_H

src/core/view/qglview_settings.h

@@ -1,61 +0,0 @@
-/*
-    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,6 +124,7 @@ 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)));
@@ -139,7 +140,6 @@ 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"/>
+                     <widget class="PIValueTreeEdit" name="widgetParameters" native="true"/>
                     </item>
                     <item>
                      <spacer name="verticalSpacer_3">
@@ -854,7 +854,7 @@
   </widget>
   <action name="actionExit">
    <property name="icon">
-    <iconset resource="../../../qad/libs/qglview/qglview.qrc">
+    <iconset resource="../core/qglengine_core.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="../../../qad/libs/qglview/qglview.qrc">
+    <iconset resource="../core/qglengine_core.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/qglview/qglview.qrc">
+    <iconset resource="../../../qad/libs/widgets/qad_widgets.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/qglview/qglview.qrc">
+    <iconset resource="../../../qad/libs/widgets/qad_widgets.qrc">
      <normaloff>:/icons/document-new.png</normaloff>:/icons/document-new.png</iconset>
    </property>
    <property name="text">
@@ -985,12 +985,6 @@
   </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>
@@ -1038,10 +1032,16 @@
    <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/qglview/qglview.qrc"/>
+  <include location="../../../qad/libs/widgets/qad_widgets.qrc"/>
   <include location="../core/qglengine_core.qrc"/>
  </resources>
  <connections/>

src/widgets/CMakeLists.txt

@@ -1,4 +1,4 @@
-cmake_minimum_required(VERSION 3.13)
+cmake_minimum_required(VERSION 3.0)
 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 = false;
+	ignore_next = 0;
 }
 
 
@@ -51,7 +51,7 @@ void MaterialEditor::changeEvent(QEvent * e) {
 
 void MaterialEditor::materialChanged() {
 	if (!active || !mat) return;
-	ignore_next         = true;
+	ignore_next         = 2;
 	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) {
+	if (ignore_next > 0) {
-		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;
-	bool ignore_next;
+	int 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>-999.000000000000000</double>
+            <double>0.000000000000000</double>
            </property>
            <property name="spinMaximum">
-            <double>9999.000000000000000</double>
+            <double>1.000000000000000</double>
            </property>
           </widget>
          </item>
@@ -192,10 +192,10 @@
         <item row="1" column="1">
          <widget class="SpinSlider" name="sliderAmount">
           <property name="minimum">
-           <double>-2.000000000000000</double>
+           <double>-1.000000000000000</double>
           </property>
           <property name="maximum">
-           <double>2.000000000000000</double>
+           <double>1.000000000000000</double>
           </property>
           <property name="value">
            <double>1.000000000000000</double>
@@ -210,10 +210,10 @@
            <double>0.200000000000000</double>
           </property>
           <property name="spinMinimum">
-           <double>-999.000000000000000</double>
+           <double>-99.000000000000000</double>
           </property>
           <property name="spinMaximum">
-           <double>9999.000000000000000</double>
+           <double>99.000000000000000</double>
           </property>
          </widget>
         </item>
@@ -242,10 +242,10 @@
            <double>0.200000000000000</double>
           </property>
           <property name="spinMinimum">
-           <double>-999.000000000000000</double>
+           <double>-99.000000000000000</double>
           </property>
           <property name="spinMaximum">
-           <double>9999.000000000000000</double>
+           <double>99.000000000000000</double>
           </property>
          </widget>
         </item>

src/widgets/materials_editor.cpp

@@ -107,18 +107,16 @@ void MaterialsEditor::selectionChanged() {
 	if (!view) return;
 	// qDebug() << "selectionChanged";
 	ObjectBase * o = view->selectedObject();
-	if (!o) return;
+	if (o) selectMaterial(o->material());
-	if (o->material()) selectMaterial(o->material());
 }
 
 
 void MaterialsEditor::materialsChanged() {
-	if (ui->widgetMaterial->ignore_next) {
+	if (ui->widgetMaterial->ignore_next > 0) {
-		ui->widgetMaterial->ignore_next = false;
+		ui->widgetMaterial->ignore_next--;
 		return;
 	}
 	Material * cm = currentMaterial();
-	ui->comboMaterial->blockSignals(true);
 	ui->comboMaterial->clear();
 	if (!view) return;
 	QVector<Material *> mats = view->scene()->getMaterials();
@@ -129,8 +127,6 @@ 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());
 }
 
 
@@ -157,7 +153,6 @@ 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();
 }
 
 
@@ -198,7 +193,6 @@ 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>-306</y>
+        <y>-287</y>
         <width>444</width>
         <height>1100</height>
        </rect>
@@ -590,7 +590,7 @@
              <bool>true</bool>
             </property>
             <property name="spinMaximum">
-             <double>9999.000000000000000</double>
+             <double>999.000000000000000</double>
             </property>
            </widget>
           </item>
@@ -847,9 +847,6 @@
             <property name="maximum">
              <double>999999999.000000000000000</double>
             </property>
-            <property name="singleStep">
-             <double>0.010000000000000</double>
-            </property>
             <property name="value">
              <double>0.100000000000000</double>
             </property>
@@ -877,7 +874,7 @@
              <number>1</number>
             </property>
             <property name="singleStep">
-             <double>1.000000000000000</double>
+             <double>5.000000000000000</double>
             </property>
             <property name="pageStep">
              <double>30.000000000000000</double>
@@ -969,9 +966,6 @@
    <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,16 +19,13 @@
 #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,
@@ -112,9 +109,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->actionMesh_info << newSeparator()
+		<< ui->actionSelect_by_mesh << ui->actionSelect_by_material << newSeparator() << ui->actionMove_to_parent
-		<< ui->actionMove_to_parent << ui->actionTransfer_transform_to_children << newSeparator() << ui->actionActive_camera
+		<< ui->actionTransfer_transform_to_children << newSeparator() << ui->actionActive_camera << ui->actionDefault_camera
-		<< ui->actionDefault_camera << newSeparator() << ui->actionRemove;
+		<< newSeparator() << ui->actionRemove;
 	return ret;
 }
 
@@ -312,7 +309,6 @@ 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);
 }
@@ -510,34 +506,8 @@ 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,10 +61,6 @@ 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);
@@ -88,8 +84,8 @@ private slots:
 	void on_actionSelect_by_mesh_triggered();
 	void on_actionSelect_by_material_triggered();
 
-	void on_actionMesh_info_triggered();
+	void removeObjects();
-
+	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="../core/qglengine_core.qrc">
+    <iconset resource="../../../qad/libs/qglview/qglview.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="../core/qglengine_core.qrc">
+    <iconset resource="../../../qad/libs/qglview/qglview.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="../core/qglengine_core.qrc">
+    <iconset resource="../../../qad/libs/qglview/qglview.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="../core/qglengine_core.qrc">
+    <iconset resource="../../../qad/libs/qglview/qglview.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="../core/qglengine_core.qrc">
+    <iconset resource="../../../qad/libs/qglview/qglview.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="../core/qglengine_core.qrc">
+    <iconset resource="../../../qad/libs/qglview/qglview.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="../core/qglengine_core.qrc">
+    <iconset resource="../../../qad/libs/qglview/qglview.qrc">
      <normaloff>:/icons/type-camera.png</normaloff>:/icons/type-camera.png</iconset>
    </property>
    <property name="text">
@@ -298,15 +298,6 @@
     <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>
@@ -321,9 +312,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,30 +43,9 @@ 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());
@@ -75,8 +54,6 @@ void ViewEditor::setup() {
 	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());
@@ -87,11 +64,9 @@ void ViewEditor::setup() {
 	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) {
@@ -106,6 +81,15 @@ void ViewEditor::setup() {
 }
 
 
+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);
@@ -131,12 +115,6 @@ 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());
@@ -228,11 +206,6 @@ 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);
@@ -281,12 +254,6 @@ 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,12 +43,10 @@ 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);
@@ -64,7 +62,6 @@ 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);
@@ -73,7 +70,6 @@ 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>976</height>
+    <height>737</height>
    </rect>
   </property>
   <layout class="QVBoxLayout" name="verticalLayout_3">
@@ -36,8 +36,8 @@
        <rect>
         <x>0</x>
         <y>0</y>
-        <width>479</width>
+        <width>453</width>
-        <height>976</height>
+        <height>807</height>
        </rect>
       </property>
       <layout class="QVBoxLayout" name="verticalLayout">
@@ -161,30 +161,6 @@
        </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">
@@ -205,170 +181,94 @@
            </property>
           </widget>
          </item>
-         <item row="2" column="1">
+         <item row="1" column="0">
-          <widget class="QWidget" name="widget_2" native="true">
+          <widget class="QCheckBox" name="checkFXAA">
-           <layout class="QHBoxLayout" name="horizontalLayout_2">
+           <property name="text">
-            <property name="leftMargin">
+            <string>FXAA</string>
-             <number>0</number>
+           </property>
-            </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>Preset:</string>
-              </property>
-             </widget>
-            </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">
+         <item row="0" column="0">
-          <widget class="QWidget" name="widget_3" native="true">
+          <widget class="QCheckBox" name="checkAutoExposure">
-           <layout class="QHBoxLayout" name="horizontalLayout_4">
+           <property name="text">
-            <property name="leftMargin">
+            <string>Auto exposure</string>
-             <number>0</number>
+           </property>
-            </property>
+          </widget>
-            <property name="topMargin">
+         </item>
-             <number>0</number>
+         <item row="2" column="0">
-            </property>
+          <widget class="QCheckBox" name="checkVSync">
-            <property name="rightMargin">
+           <property name="text">
-             <number>0</number>
+            <string>VSync</string>
-            </property>
+           </property>
-            <property name="bottomMargin">
+           <property name="checked">
-             <number>0</number>
+            <bool>true</bool>
-            </property>
+           </property>
-            <item>
+          </widget>
-             <widget class="QLabel" name="label_12">
+         </item>
-              <property name="sizePolicy">
+         <item row="2" column="1">
-               <sizepolicy hsizetype="Fixed" vsizetype="Preferred">
+          <widget class="QCheckBox" name="checkSoftShadows">
-                <horstretch>0</horstretch>
+           <property name="text">
-                <verstretch>0</verstretch>
+            <string>Soft shadows</string>
-               </sizepolicy>
+           </property>
-              </property>
+           <property name="checked">
-              <property name="text">
+            <bool>true</bool>
-               <string>Line width:</string>
+           </property>
-              </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">
+        <layout class="QFormLayout" name="formLayout_2">
-         <property name="title">
+         <property name="labelAlignment">
-          <string>Shadows</string>
+          <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
          </property>
-         <property name="checkable">
+         <item row="0" column="0">
-          <bool>true</bool>
+          <widget class="QLabel" name="label_9">
-         </property>
+           <property name="text">
-         <layout class="QFormLayout" name="formLayout_2">
+            <string>Soft shadow samples:</string>
-          <property name="labelAlignment">
+           </property>
-           <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
+          </widget>
-          </property>
+         </item>
-          <item row="1" column="0">
+         <item row="0" column="1">
-           <widget class="QLabel" name="label_9">
+          <widget class="SpinSlider" name="spinSoftShadowSamples">
-            <property name="text">
+           <property name="minimum">
-             <string>Soft shadow samples:</string>
+            <double>1.000000000000000</double>
-            </property>
+           </property>
-           </widget>
+           <property name="maximum">
-          </item>
+            <double>256.000000000000000</double>
-          <item row="1" column="1">
+           </property>
-           <widget class="SpinSlider" name="spinSoftShadowSamples">
+           <property name="value">
-            <property name="minimum">
+            <double>32.000000000000000</double>
-             <double>1.000000000000000</double>
+           </property>
-            </property>
+           <property name="decimals">
-            <property name="maximum">
+            <number>0</number>
-             <double>256.000000000000000</double>
+           </property>
-            </property>
+          </widget>
-            <property name="value">
+         </item>
-             <double>32.000000000000000</double>
+         <item row="1" column="0">
-            </property>
+          <widget class="QLabel" name="label_10">
-            <property name="decimals">
+           <property name="text">
-             <number>0</number>
+            <string>Soft shadow quality:</string>
-            </property>
+           </property>
-           </widget>
+          </widget>
-          </item>
+         </item>
-          <item row="2" column="0">
+         <item row="1" column="1">
-           <widget class="QLabel" name="label_10">
+          <widget class="SpinSlider" name="spinSoftShadowQuality">
-            <property name="text">
+           <property name="minimum">
-             <string>Soft shadow quality:</string>
+            <double>0.100000000000000</double>
-            </property>
+           </property>
-           </widget>
+           <property name="maximum">
-          </item>
+            <double>10.000000000000000</double>
-          <item row="2" column="1">
+           </property>
-           <widget class="SpinSlider" name="spinSoftShadowQuality">
+           <property name="value">
-            <property name="minimum">
+            <double>1.000000000000000</double>
-             <double>0.100000000000000</double>
+           </property>
-            </property>
+           <property name="decimals">
-            <property name="maximum">
+            <number>1</number>
-             <double>10.000000000000000</double>
+           </property>
-            </property>
+          </widget>
-            <property name="value">
+         </item>
-             <double>1.000000000000000</double>
+        </layout>
-            </property>
-            <property name="decimals">
-             <number>1</number>
-            </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">
@@ -443,11 +343,8 @@
               <property name="maximum">
                <double>999999999.000000000000000</double>
               </property>
-              <property name="singleStep">
-               <double>0.010000000000000</double>
-              </property>
               <property name="value">
-               <double>0.100000000000000</double>
+               <double>1.000000000000000</double>
               </property>
              </widget>
             </item>
@@ -587,6 +484,32 @@
               </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">
@@ -594,6 +517,34 @@
               </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">
@@ -612,23 +563,6 @@
               </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>
@@ -700,14 +634,6 @@
    <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,6 +15,5 @@
 	<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>