small refactoring

core/glcubemap.cpp

@@ -86,12 +86,6 @@ QVector<QVector3D> loadFileHDR(const QString & path, QSize * size) {
 }
 
 
-//#define GL_TEXTURE_CUBE_MAP_POSITIVE_X    0x8515
-//#define GL_TEXTURE_CUBE_MAP_NEGATIVE_X    0x8516
-//#define GL_TEXTURE_CUBE_MAP_POSITIVE_Y    0x8517
-//#define GL_TEXTURE_CUBE_MAP_NEGATIVE_Y    0x8518
-//#define GL_TEXTURE_CUBE_MAP_POSITIVE_Z    0x8519
-//#define GL_TEXTURE_CUBE_MAP_NEGATIVE_Z    0x851A
 QVector<QVector3D> faceHDR(const QVector<QVector3D> & data, QSize sz, QSize & fsz, int face) {
 	QVector<QVector3D> ret;
 	if (data.isEmpty() || sz.isNull()) return ret;
@@ -175,13 +169,6 @@ bool CubeTexture::init() {
 	f->glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);
 	f->glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
 	f->glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
-	//glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_GENERATE_MIPMAP_SGIS, GL_TRUE);
-	//glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X, 0, format_, size, size, 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr);
-	//glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_X, 0, format_, size, size, 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr);
-	//glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Y, 0, format_, size, size, 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr);
-	//glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, 0, format_, size, size, 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr);
-	//glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Z, 0, format_, size, size, 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr);
-	//glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, 0, format_, size, size, 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr);
 	changed_ = false;
 	return id_ > 0;
 }
@@ -213,7 +200,6 @@ void CubeTexture::loadHDR(const QVector<QVector3D> & data, QSize sz) {
 	for (int i = 0; i < 6; ++i) {
 		fd = faceHDR(data, sz, fsz, GL_TEXTURE_CUBE_MAP_POSITIVE_X + i);
 		//qDebug() << "load cube" << fd[0];
-		//f->glBindBuffer(GL_PIXEL_UNPACK_BUFFER, 0);
 		f->glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X + i, 0, format_, fsz.width(), fsz.height(), 0, GL_RGB, GL_FLOAT, fd.isEmpty() ? 0 : fd.constData());
 		//qDebug() << QString::number(GetLastError(), 16);
 	}
@@ -245,37 +231,3 @@ void CubeTexture::load() {
 	changed_ = false;
 }
 
-/*
-void CubeTexture::load() {
-	if (isEmpty()) return;
-	create();
-	if (!path(0).isEmpty()) loadFront(path(0));
-	if (!path(1).isEmpty()) loadBack(path(1));
-	if (!path(2).isEmpty()) loadLeft(path(2));
-	if (!path(3).isEmpty()) loadRight(path(3));
-	if (!path(4).isEmpty()) loadTop(path(4));
-	if (!path(5).isEmpty()) loadBottom(path(5));
-}
-
-
-void CubeTexture::loadFromDirectory(const QString & dir) {
-	QDir d(dir); QFileInfoList sl;
-	sl = d.entryInfoList(QStringList("front.*"), QDir::Files | QDir::NoDotAndDotDot); if (!sl.isEmpty()) loadFront(sl[0].absoluteFilePath());
-	sl = d.entryInfoList(QStringList("back.*"), QDir::Files | QDir::NoDotAndDotDot); if (!sl.isEmpty()) loadBack(sl[0].absoluteFilePath());
-	sl = d.entryInfoList(QStringList("left.*"), QDir::Files | QDir::NoDotAndDotDot); if (!sl.isEmpty()) loadLeft(sl[0].absoluteFilePath());
-	sl = d.entryInfoList(QStringList("right.*"), QDir::Files | QDir::NoDotAndDotDot); if (!sl.isEmpty()) loadRight(sl[0].absoluteFilePath());
-	sl = d.entryInfoList(QStringList("top.*"), QDir::Files | QDir::NoDotAndDotDot); if (!sl.isEmpty()) loadTop(sl[0].absoluteFilePath());
-	sl = d.entryInfoList(QStringList("bottom.*"), QDir::Files | QDir::NoDotAndDotDot); if (!sl.isEmpty()) loadBottom(sl[0].absoluteFilePath());
-}
-
-
-void CubeTexture::loadPathesFromDirectory(const QString & dir) {
-	QDir d(dir); QFileInfoList sl;
-	sl = d.entryInfoList(QStringList("front.*"), QDir::Files | QDir::NoDotAndDotDot); if (!sl.isEmpty()) pathes[0] = sl[0].absoluteFilePath();
-	sl = d.entryInfoList(QStringList("back.*"), QDir::Files | QDir::NoDotAndDotDot); if (!sl.isEmpty()) pathes[1] = sl[0].absoluteFilePath();
-	sl = d.entryInfoList(QStringList("left.*"), QDir::Files | QDir::NoDotAndDotDot); if (!sl.isEmpty()) pathes[2] = sl[0].absoluteFilePath();
-	sl = d.entryInfoList(QStringList("right.*"), QDir::Files | QDir::NoDotAndDotDot); if (!sl.isEmpty()) pathes[3] = sl[0].absoluteFilePath();
-	sl = d.entryInfoList(QStringList("top.*"), QDir::Files | QDir::NoDotAndDotDot); if (!sl.isEmpty()) pathes[4] = sl[0].absoluteFilePath();
-	sl = d.entryInfoList(QStringList("bottom.*"), QDir::Files | QDir::NoDotAndDotDot); if (!sl.isEmpty()) pathes[5] = sl[0].absoluteFilePath();
-}
-*/

core/glcubemap.h

@@ -35,22 +35,10 @@ public:
 	void loadHDR(const QVector<QVector3D> & data, QSize sz);
 	void setFileHDR(const QString & path);
 	QString fileHDR() const {return hdr_path;}
-	//void loadFromDirectory(const QString & dir);
-	//void loadFront(const QString & path) {bind(); pathes[0] = path; createGLTexture(id_, rotateQImageLeft(QImage(path)).scaled(size, size, Qt::IgnoreAspectRatio, Qt::SmoothTransformation), format_, GL_TEXTURE_CUBE_MAP_POSITIVE_X);}
-	//void loadBack(const QString & path) {bind(); pathes[1] = path; createGLTexture(id_, rotateQImageRight(QImage(path)).scaled(size, size, Qt::IgnoreAspectRatio, Qt::SmoothTransformation), format_, GL_TEXTURE_CUBE_MAP_NEGATIVE_X);}
-	//void loadLeft(const QString & path) {bind(); pathes[2] = path; createGLTexture(id_, QImage(path).scaled(size, size, Qt::IgnoreAspectRatio, Qt::SmoothTransformation), format_, GL_TEXTURE_CUBE_MAP_NEGATIVE_Y);}
-	//void loadRight(const QString & path) {bind(); pathes[3] = path; createGLTexture(id_, rotateQImage180(QImage(path)).scaled(size, size, Qt::IgnoreAspectRatio, Qt::SmoothTransformation), format_, GL_TEXTURE_CUBE_MAP_POSITIVE_Y);}
-	//void loadTop(const QString & path) {bind(); pathes[4] = path; createGLTexture(id_, rotateQImageLeft(QImage(path)).scaled(size, size, Qt::IgnoreAspectRatio, Qt::SmoothTransformation), format_, GL_TEXTURE_CUBE_MAP_NEGATIVE_Z);}
-	//void loadBottom(const QString & path) {bind(); pathes[5] = path; createGLTexture(id_, rotateQImageLeft(QImage(path)).scaled(size, size, Qt::IgnoreAspectRatio, Qt::SmoothTransformation), format_, GL_TEXTURE_CUBE_MAP_POSITIVE_Z);}
-	//void load();
-	//bool isEmpty() const {foreach (const QString & i, pathes) if (!i.isEmpty()) return false; return true;}
 	GLenum format() const {return format_;}
 	void setFormat(GLenum f) {format_ = f; changed_ = true;}
 	GLuint id() const {return id_;}
 	bool isInit() const {return id_ != 0;}
-	//const QString & path(int side) const {return pathes[side];}
-	//void setPath(int side, const QString & p) {pathes[side] = p;}
-	//void loadPathesFromDirectory(const QString & dir);
 	void load();
 private:
 
@@ -60,7 +48,6 @@ private:
 	GLenum format_;
 	GLuint id_;
 	QString hdr_path;
-	//QVector<QString> pathes;
 };
 
 

core/glframebuffer.cpp

@@ -21,8 +21,8 @@
 #include <QTime>
 
 
-Framebuffer::Framebuffer(QOpenGLExtraFunctions * f_, int colorAttachments_, bool withDepth, GLenum colorFormat_, GLenum _target): f(f_),
+Framebuffer::Framebuffer(QOpenGLExtraFunctions * f_, int colorAttachments_, bool withDepth, GLenum colorFormat_, GLenum _target)
-		pbo(GL_PIXEL_PACK_BUFFER, GL_STREAM_DRAW) {
+: f(f_), pbo(GL_PIXEL_PACK_BUFFER, GL_STREAM_DRAW) {
 	is_depth = withDepth;
 	target_ = _target;
 	color_formats.fill(colorFormat_, colorAttachments_);
@@ -35,8 +35,8 @@ Framebuffer::Framebuffer(QOpenGLExtraFunctions * f_, int colorAttachments_, bool
 }
 
 
-Framebuffer::Framebuffer(QOpenGLExtraFunctions * f_, QVector<GLenum> colors_, bool withDepth, GLenum _target): f(f_),
+Framebuffer::Framebuffer(QOpenGLExtraFunctions * f_, QVector<GLenum> colors_, bool withDepth, GLenum _target)
-		pbo(GL_PIXEL_PACK_BUFFER, GL_STREAM_DRAW) {
+: f(f_), pbo(GL_PIXEL_PACK_BUFFER, GL_STREAM_DRAW) {
 	is_depth = withDepth;
 	target_ = _target;
 	color_formats = colors_;
@@ -73,7 +73,6 @@ void Framebuffer::resize(int width, int height, bool force) {
 		f->glTexParameteri(target_, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
 		f->glTexParameteri(target_, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
 		f->glTexParameteri(target_, GL_TEXTURE_MAX_LEVEL, 4);
-		//f->glTexParameteri(target_, GL_GENERATE_MIPMAP_SGIS, GL_FALSE);
 		f->glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0 + i, target_, colors[i], 0);
 	}
 	if (is_depth) {
@@ -88,7 +87,6 @@ void Framebuffer::resize(int width, int height, bool force) {
 		f->glTexParameteri(target_, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
 		f->glTexParameteri(target_, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
 		f->glTexParameteri(target_, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
-		//f->glTexParameteri(target_, GL_GENERATE_MIPMAP_SGIS, GL_FALSE);
 		f->glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, target_, tex_d, 0);
 	}
 	f->glBindFramebuffer(GL_FRAMEBUFFER, 0);
@@ -289,8 +287,6 @@ void Framebuffer::bindColorTextures() {
 	for (int i = colors.size() - 1; i >= 0; --i) {
 		f->glActiveTexture(GL_TEXTURE0 + i);
 		f->glBindTexture(GL_TEXTURE_2D, colors[i]);
-		//f->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
-		//f->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
 	}
 }
 

core/glframebuffer.h

@@ -32,7 +32,6 @@ public:
 
 	GLuint id() const {return fbo;}
 	GLuint colorTexture(int index = 0) const {return colors[index];}
-	//GLenum colorFormat() const {return color_format;}
 	GLuint depthTexture() const {return tex_d;}
 	GLenum target() const {return target_;}
 	bool isInit() const {return fbo != 0;}
@@ -61,7 +60,6 @@ public:
 	void setWriteBuffers(const QVector<int> & indeces) {setWriteBuffers(indeces.constData(), indeces.size());}
 	void setWriteBuffers();
 	void unsetWriteBuffers();
-	//void setColorFormat(GLenum format) {color_format = format; is_changed = true;}
 	void enablePixelBuffer();
 	void setColorTextureFiltering(int index, GLenum filter);
 
@@ -83,7 +81,6 @@ private:
 	GLenum target_;
 	GLuint fbo, drbo, tex_d;
 	GLint prev_view[4], wid, hei;
-
 };
 
 #endif // GLFRAMEBUFFER_H

core/glmaterial.cpp

@@ -62,7 +62,7 @@ void Map::copyToQGLMap(QGLMap & m) const {
 
 
 
-Material::Material(const QString _name)/*: map_reflection(512)*/ {
+Material::Material(const QString _name) {
 	setTypes();
 	name = _name;
 	color_diffuse = Qt::white;

core/glmaterial.h

@@ -70,7 +70,6 @@ public:
 	Map map_relief   ;
 	bool _changed;
 	int _index;
-	//GLCubeTexture map_reflection;
 };
 
 
@@ -93,13 +92,10 @@ inline QDataStream & operator <<(QDataStream & s, const Material * m) {
 	cs.add(1, m->name).add(2, m->color_diffuse).add(4, m->color_emission)
 	  .add(5, m->transparency).add(6, m->reflectivity).add(7, m->glass).add(8, m->map_diffuse).add(9, m->map_normal)
 	  .add(10, m->map_relief).add(11, m->map_metalness).add(12, m->map_roughness).add(13, m->map_emission);
-	s << /*qCompress*/(cs.data()); return s;
+	s << (cs.data()); return s;
 }
 inline QDataStream & operator >>(QDataStream & s, Material *& m) {
 	m = new Material();
-	//QByteArray ba;
-	//s >> ba;
-	//ba = qUncompres(ba);
 	ChunkStream cs(s);
 	while (!cs.atEnd()) {
 		switch (cs.read()) {

core/glmesh.cpp

@@ -37,7 +37,6 @@ Mesh::Mesh(GLenum geom_type_): geom_type(geom_type_),
 
 Mesh::~Mesh() {
 	//qDebug() << "~Mesh, now" << --_count;
-	//destroy();
 }
 
 
@@ -401,15 +400,12 @@ QDataStream & operator <<(QDataStream & s, const Mesh * m) {
 	cs.add(1, m->vertices_).add(2, m->normals_).add(3, m->texcoords_)
 		.add(6, m->triangles_).add(7, m->lines_).add(10, int(m->geom_type));
 	//qDebug() << "place VBO done" << cs.data().size() << "...";
-	s << /*qCompress*/(cs.data()); return s;
+	s << cs.data(); return s;
 }
 
 
 QDataStream & operator >>(QDataStream & s, Mesh *& m) {
 	m = new Mesh();
-	//QByteArray ba;
-	//s >> ba;
-	//ba = qUncompress(ba);
 	ChunkStream cs(s);
 	while (!cs.atEnd()) {
 		switch (cs.read()) {

core/glmesh.h

@@ -25,9 +25,6 @@
 
 class Mesh
 {
-	friend class ObjectBase;
-	friend class Scene;
-	friend class Renderer;
 	friend QDataStream & operator <<(QDataStream & s, const Mesh * m);
 	friend QDataStream & operator >>(QDataStream & s, Mesh *& m);
 public:
@@ -36,8 +33,6 @@ public:
 
 	Mesh * clone();
 
-	//GLVBO & operator =(const GLVBO & o) {return *this;}
-
 	void init    (QOpenGLExtraFunctions * f);
 	void destroy (QOpenGLExtraFunctions * f);
 	bool rebuffer(QOpenGLExtraFunctions * f);
@@ -100,7 +95,6 @@ private:
 	mutable bool hash_changed;
 	int vert_count;
 	bool changed;
-
 };
 
 

core/glprimitives.cpp

@@ -248,7 +248,6 @@ Mesh * Primitive::cylinder(int segments, float radius, float height, float end_a
 	if (end_angle < 360.) {
 		Mesh * cap = Primitive::plane(radius, height);
 		cap->rotatePoints(90, 1, 0, 0);
-		//cap->rotatePoints(-90, 0, 0, 1);
 		cap->translatePoints(radius/2, 0, height/2);
 		ret->append(cap);
 		cap->flipNormals();

core/glprimitives.h

@@ -52,53 +52,4 @@ Mesh * coneFrame(int segments, float radius = 1., float height = 1.);
 
 }
 
-/*
-class GLPrimitivePoint: public GLObjectBase
-{
-public:
-	GLPrimitivePoint(double size = 1., QVector3D pos = QVector3D()) {sz = 8.;}
-	virtual void draw(QOpenGLShaderProgram * prog, bool simplest = false);
-private:
-	double sz;
-};
-
-
-
-
-class GLPrimitiveLine: public GLObjectBase
-{
-public:
-	GLPrimitiveLine(QVector3D p0_ = QVector3D(), QVector3D p1_ = QVector3D()) {p0 = p0_; p1 = p1_;}
-	virtual void draw(QOpenGLShaderProgram * prog, bool simplest = false);
-	QVector3D point0() const {return p0;}
-	QVector3D point1() const {return p1;}
-	void setPoint0(const QVector3D & p) {p0 = p;}
-	void setPoint1(const QVector3D & p) {p1 = p;}
-private:
-	QVector3D p0, p1;
-};
-
-
-
-
-class GLPrimitiveEllipsoid: public GLObjectBase
-{
-public:
-	GLPrimitiveEllipsoid(float width = 1., float length = 1., float height = 1., int seg_wl = 10, int seg_h = 10, QVector3D pos = QVector3D());
-	virtual void init();
-private:
-	void putTriangle(const QVector3D & v0, const QVector3D & v1, const QVector3D & v2);
-	float w, l, h;
-	int swl, sh;
-};
-
-
-class GLPrimitiveAxis: public GLObjectBase
-{
-public:
-	GLPrimitiveAxis() {accept_fog = accept_light = cast_shadow = rec_shadow = select_ = false;}
-	virtual void draw(QOpenGLShaderProgram * prog, bool simplest = false);
-};
-*/
-
 #endif // GLPRIMITIVE_CUBE_H

core/glshaders_headers.h

@@ -85,7 +85,6 @@ const char qgl_structs[] =
 	"};\n"
 	"struct QGLMaterial {\n"
 	"	vec4 color_diffuse;\n"
-	//"	vec4 color_specular;\n"
 	"	vec4 color_emission;\n"
 	"	float transparency;\n"
 	"	float reflectivity;\n"
@@ -97,11 +96,6 @@ const char qgl_structs[] =
 	"	vec4 color;\n"
 	"	vec4 decay_intensity;\n"
 	"	vec4 angles;\n"
-	//"	sampler2DShadow shadow;\n"
-	//"	sampler2D shadowColor\n"
-	//"	mat4 shadowMatrix;\n"
-	//"	vec4 shadowDir0;\n"
-	//"	vec4 shadowDir1;\n"
 	"};\n"
 	"struct QGLLightPosition {\n"
 	"	vec4 position;\n"

core/glshaders_types.h

@@ -125,8 +125,6 @@ struct QGLLightParameter {
 	QVector4D color;
 	QVector4D decay_intensity; // [^0, ^1, ^2, intensity]
 	QVector4D angles; // [start, cos(start), end, cos(end)]
-	//GLfloat shadow;
-	//GLfloat shadowMatrix[16];
 };
 struct QGLLightPosition {
 	QVector4D position;

core/gltexturearray.h

@@ -24,7 +24,6 @@
 
 class Texture2DArray
 {
-	friend class ObjectBase;
 public:
 	Texture2DArray(bool filter);
 	~Texture2DArray();
@@ -49,7 +48,6 @@ private:
 	QSize size_;
 	int layers_;
 	bool filtering_;
-
 };
 
 

core/gltransform.cpp

@@ -398,7 +398,6 @@ QVector3D Transform::fromDirection(QVector3D d, float pitch) {
 
 
 QVector3D Transform::fromRotationMatrix(const QMatrix3x3 & m) {
-	//return QQuaternion::fromRotationMatrix(m);
 	float sy = sqrt(m(0,0) * m(0,0) + m(1,0) * m(1,0));
 	bool singular = sy < 1.E-6; // If
 	float x, y, z;

core/gltransform.h

@@ -96,19 +96,9 @@ protected:
 
 
 inline QDataStream & operator <<(QDataStream & s, const Transform & v) {
-	//ChunkStream cs;
-	//cs.add(1, v.matrix());
-	//s << cs.data(); return s;
 	s << v.matrix(); return s;
 }
 inline QDataStream & operator >>(QDataStream & s, Transform & v) {
-	//ChunkStream cs(s);
-	//while (!cs.atEnd()) {
-	//	switch (cs.read()) {
-	//	case 1: v.setMatrix(cs.getData<QMatrix4x4>()); break;
-	//	}
-	//}
-	//return s;
 	QMatrix4x4 m;
 	s >> m;
 	v.setMatrix(m);

core/gltypes.cpp

@@ -22,9 +22,6 @@
 
 #include <QPainter>
 
-//__GLWidget__ * currentQGLView;
-//QMutex globMutex;
-
 
 QString readCharsUntilNull(QDataStream & s) {
 	QString str;
@@ -55,7 +52,6 @@ QString findFile(const QString & file, const QStringList & pathes) {
 
 
 void glDrawQuad(QOpenGLShaderProgram * prog, QVector4D * corner_dirs, GLfloat x, GLfloat y, GLfloat w, GLfloat h) {
-	//glResetAllTransforms();
 	glSetPolygonMode(GL_FILL);
 	glDisable(GL_LIGHTING);
 	glEnable(GL_TEXTURE_2D);
@@ -63,7 +59,6 @@ void glDrawQuad(QOpenGLShaderProgram * prog, QVector4D * corner_dirs, GLfloat x,
 		locv = prog ? prog->attributeLocation("qgl_Vertex")  : -1,
 		loct = prog ? prog->attributeLocation("qgl_Texture") : -1,
 		locc = prog ? prog->attributeLocation("view_corner") : -1;
-	//if (prog) {qDebug() << locv << loct << locc;}
 	QOpenGLFunctions * glFuncs = QOpenGLContext::currentContext()->functions();
 	if (prog) {
 		static const GLfloat cols [] = {1.f, 1.f, 1.f,  1.f, 1.f, 1.f,  1.f, 1.f, 1.f,  1.f, 1.f, 1.f};
@@ -137,12 +132,10 @@ void qglMultMatrix(const QMatrix4x4 & m) {
 
 
 void createGLTexture(QOpenGLExtraFunctions * f, GLuint & tex, int width, int height, const GLenum & format, const GLenum & target) {
-	//glClearError();
 	if (tex == 0) {
 		f->glGenTextures(1, &tex);
 		f->glBindTexture(target, tex);
 	}
-	//glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
 	if (format == GL_DEPTH_COMPONENT || format == GL_DEPTH_COMPONENT16 || format == GL_DEPTH_COMPONENT24 || format == GL_DEPTH_COMPONENT32)
 		f->glTexImage2D(target, 0, format, width, height, 0, GL_DEPTH_COMPONENT, GL_UNSIGNED_BYTE, nullptr);
 	else {
@@ -153,7 +146,6 @@ void createGLTexture(QOpenGLExtraFunctions * f, GLuint & tex, int width, int hei
 		if (format == GL_RGB32F || format == GL_RGB16F || format == GL_RGB8 || format == GL_RGB)
 			fmt = GL_RGB;
 		f->glTexImage2D(target, 0, format, width, height, 0, fmt, type, nullptr);
-		//glGenerateMipmap(target);
 		//qDebug() << "glTexImage2D" << width << height << QString::number(t, 16);
 	}
 	//qDebug() << QString::number(glGetError(), 16);
@@ -166,7 +158,6 @@ void createGLTexture(QOpenGLExtraFunctions * f, GLuint & tex, const QImage & ima
 	}
 	f->glBindTexture(target, tex);
 	QImage im = image.mirrored(false, true).convertToFormat(QImage::Format_RGBA8888);
-	//const QImage & cim(im);
 	f->glTexParameteri(target, GL_TEXTURE_WRAP_T, GL_REPEAT);
 	f->glTexParameteri(target, GL_TEXTURE_WRAP_S, GL_REPEAT);
 	f->glTexParameteri(target, GL_TEXTURE_WRAP_R, GL_REPEAT);
@@ -197,8 +188,8 @@ QMatrix4x4 glMatrixPerspective(float angle, float aspect, float near_) {
 		ret(0, 0) = t;
 		ret(1, 1) = t * aspect;
 	}
-	ret(2, 2) = e - 1.f;//far_ / (far_ - near_) - 1.;
+	ret(2, 2) = e - 1.f;
-	ret(2, 3) = (e - 2.f) * near_;//2. * far_ * near_ / (far_ - near_);
+	ret(2, 3) = (e - 2.f) * near_;
 	ret(3, 2) = -1.f;
 	ret(3, 3) = 0.f;
 	return ret;
@@ -294,7 +285,6 @@ Vector3i::Vector3i(const QString & str) {
 
 void glEnableDepth() {
 	glEnable(GL_DEPTH_TEST);
-	//glDepthFunc(GL_GREATER);
 	glDepthFunc(GL_LESS);
 	glDepthMask(GL_TRUE);
 }
@@ -308,7 +298,6 @@ void glDisableDepth() {
 
 void glClearFramebuffer(const QColor & color, bool depth) {
 	glClearColor(color.redF(), color.greenF(), color.blueF(), color.alphaF());
-	//glClearDepth(0.);
 	if (depth)
 		glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 	else

core/glvertexobject.h

@@ -25,7 +25,6 @@
 
 class VertexObject
 {
-	friend class Mesh;
 public:
 	VertexObject();
 	~VertexObject();
@@ -57,7 +56,6 @@ private:
 	GLuint vao_;
 	Buffer buffer_obj, buffer_sel;
 	bool buffers_binded, objects_changed, selected_changed;
-
 };
 
 

glcamera.cpp

@@ -24,7 +24,6 @@ Camera::Camera() {
 	type_ = glCamera;
 	fov_ = 60.;
 	roll_ = 0.;
-	//setRotationX(90.f);
 	depth_start = 0.1f;
 	mirror_x = mirror_y = false;
 }
@@ -36,20 +35,6 @@ QMatrix4x4 Camera::offsetMatrix() const {
 	return ret;
 }
 
-/*
-void Camera::localTransform(QMatrix4x4 & m) {
-	return;
-	if (parent_)
-		m *= parent_->worldTransform();
-	QMatrix4x4 ret;
-	//qDebug() << "local camera";
-	ret.translate(0., 0., -distance());
-	ret.rotate(angles_.y(), 1., 0., 0.);
-	ret.rotate(angles_.x(), 0., 1., 0.);
-	ret.rotate(angles_.z(), 0., 0., 1.);
-	//m *= ret.inverted();
-}
-*/
 
 void Camera::assign(const Camera & c) {
 	trans = c.trans;
@@ -64,9 +49,8 @@ void Camera::assign(const Camera & c) {
 
 ObjectBase * Camera::clone(bool withChildren) {
 	Camera * o = new Camera(*this);
-	//GLObjectBase::clone(withChildren);
 	o->is_init = false;
-	o->name_ = name_;// + "_copy";
+	o->name_ = name_;
 	o->scene_ = nullptr;
 	o->children_.clear();
 	if (withChildren) {
@@ -91,9 +75,6 @@ QMatrix4x4 Camera::viewMatrix() const {
 	ret.translate(0., 0., -distance());
 	ret.rotate(-roll_, 0., 0., 1.);
 	ret *= trans.matrixRotateScale().inverted();
-	//ret.rotate(angles_.y(), 1., 0., 0.);
-	//ret.rotate(angles_.x(), 0., 1., 0.);
-	//pm.translate(-aim_);
 	if (parent_) {
 		QMatrix4x4 pmat = parent_->worldTransform();
 		offset_ = pmat.column(3).toVector3D();

glcamera.h

@@ -21,13 +21,9 @@
 
 #include "globject.h"
 
-//extern QMatrix4x4 globCameraMatrix;
-//extern Camera * currentCamera;
 
 class Camera: public AimedObject
 {
-	friend class QGLView;
-	friend class GLParticlesSystem;
 	friend QDataStream & operator <<(QDataStream & s, const ObjectBase * p);
 	friend QDataStream & operator >>(QDataStream & s, ObjectBase *& p);
 public:
@@ -64,7 +60,6 @@ private:
 	GLfloat depth_start;
 	bool mirror_x;
 	bool mirror_y;
-
 };
 
 #endif // GLCAMERA_H

globject.h

@@ -27,12 +27,8 @@
 
 class ObjectBase
 {
-	friend class QGLView;
 	friend class Scene;
-	friend class Renderer;
-	friend class RendererService;
 	friend class RendererSelection;
-	friend class MouseController;
 	friend QDataStream & operator <<(QDataStream & s, const ObjectBase * p);
 	friend QDataStream & operator >>(QDataStream & s, ObjectBase *& p);
 	friend QDataStream & operator >>(QDataStream & s, Scene *& p);
@@ -53,6 +49,7 @@ public:
 	bool isInit() const {return is_init;}
 	Type type() const {return type_;}
 	RenderPass pass() const;
+	uint id() const {return id_;}
 
 	RenderMode renderMode() const {return render_mode;}
 	void setRenderMode(RenderMode mode) {render_mode = mode;}
@@ -161,12 +158,11 @@ public:
 	void select() {setSelected(true);}
 	void deselect() {setSelected(false);}
 	ObjectBase * selectedParent() const;
+	void setAimSelected(bool yes) {selected_aim = yes;}
+	bool isAimSelected() const {return selected_aim;}
 
 	bool isSelectable() const {return select_;}
 	void setSelectable(bool yes) {select_ = yes;}
-	/*
-	bool isWriteDepth() const {return write_depth_;}
-	void setWriteDepth(bool yes) {write_depth_ = yes;}*/
 
 	GLenum srcAlpha() const {return blend_src;}
 	GLenum destAlpha() const {return blend_dest;}
@@ -193,8 +189,6 @@ public:
 
 	QVector3D pos_h;
 
-	//QVector<GLfloat> d_vertices, d_normals, d_uvs;
-
 protected:
 	virtual void transformChanged() {}
 	void addChildren(ObjectBaseList & list, ObjectBase * where);
@@ -224,7 +218,6 @@ protected:
 	Material * material_;
 	Mesh * mesh_;
 	QVariantMap meta;
-
 };
 
 inline bool operator <(const ObjectBase & f, const ObjectBase & s) {return f.pos_h.z() < s.pos_h.z();}
@@ -292,9 +285,6 @@ public:
 	Type light_type;
 	Framebuffer shadow_map;
 	QMatrix4x4 shadow_matrix;
-
-protected:
-
 };
 
 template <class T>

glrendererbase.cpp

@@ -32,7 +32,7 @@ GLRendererBase::GLRendererBase(QGLView * view_): view(view_) {
 
 
 void GLRendererBase::setupLight(const Light & l, int inpass_index, int gl_index) {
-	QVector3D lp = l.worldPos(), ld;// = (l.itransform_ * QVector4D(l.direction, 0.)).toVector3D().normalized();
+	QVector3D lp = l.worldPos(), ld;
 	GLfloat pos[] = {0.f, 0.f, 0.f, 0.f};
 	GLfloat dir[] = {0.f, 0.f, 0.f};
 	GLfloat col[] = {0.f, 0.f, 0.f};
@@ -43,11 +43,7 @@ void GLRendererBase::setupLight(const Light & l, int inpass_index, int gl_index)
 	dir[0] = ld.x();
 	dir[1] = ld.y();
 	dir[2] = ld.z();
-	//col[0] = l.visible_ ? l.color().redF() * l.intensity : 0.f;
-	//col[1] = l.visible_ ? l.color().greenF() * l.intensity : 0.f;
-	//col[2] = l.visible_ ? l.color().blueF() * l.intensity : 0.f;
 	glEnable(gl_index);
-	//glLightfv(gl_index, GL_AMBIENT, ambient);
 	glLightfv(gl_index, GL_DIFFUSE, col);
 	glLightfv(gl_index, GL_SPECULAR, col);
 	glLightfv(gl_index, GL_POSITION, pos);
@@ -68,23 +64,14 @@ void GLRendererBase::setupLight(const Light & l, int inpass_index, int gl_index)
 void GLRendererBase::setupAmbientLight(const QColor & a, bool first_pass) {
 	GLfloat ambient[] = {0.0f, 0.0f, 0.0f, 1.f};
 	if (first_pass) {
-		ambient[0] = view->ambientColor_.redF();
+		ambient[0] = view->ambientColor().redF();
-		ambient[1] = view->ambientColor_.greenF();
+		ambient[1] = view->ambientColor().greenF();
-		ambient[2] = view->ambientColor_.blueF();
+		ambient[2] = view->ambientColor().blueF();
 	}
 	glLightModelfv(GL_LIGHT_MODEL_AMBIENT, ambient);
 }
 
 
-void GLRendererBase::setupShadersLights(int lights_count) {
-	/*foreach (QOpenGLShaderProgram * i, view->shaders_ppl) {
-		i->bind();
-		i->setUniformValue("lightsCount", lights_count);
-		i->setUniformValue("acc_light", lights_count > 0);
-		//i->setUniformValue("mat", mvm);
-	}*/
-}
-
 
 #define BIND_TEXTURE(ch, map) if (rp.prev_tex[ch] != mat.map.bitmap_id) { \
 								rp.prev_tex[ch] = mat.map.bitmap_id; \
@@ -97,177 +84,16 @@ void GLRendererBase::setupTextures(ObjectBase & o, GLRendererBase::RenderingPara
 #undef BIND_TEXTURE
 
 
-void GLRendererBase::setupLights(int pass, int lights_per_pass) {
-	/*int light_start, light_end, lmax;
-	light_start = pass * lights_per_pass;
-	light_end = qMin<int>((pass + 1) * lights_per_pass, view->lights_.size());
-	setupAmbientLight(view->ambientColor_, pass == 0);
-	if (!view->lights_.isEmpty()) {
-		setupShadersLights(light_end - light_start);
-		for (int i = light_start; i < light_end; ++i)
-			setupLight(*view->lights_[i], i - light_start, GL_LIGHT0 + i - light_start);
-		lmax = light_start + 8;
-		for (int i = light_end; i < lmax; ++i)
-			glDisable(GL_LIGHT0 + i - light_start);
-	} else {
-		setupShadersLights(0);
-		for (int i = 0; i < 8; ++i)
-			glDisable(GL_LIGHT0 + i);
-	}*/
-}
-
-
 void GLRendererBase::applyFilteringParameters() {
-	/*if (view->isFeatureEnabled(QGLView::qglLinearFiltering)) {
-		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
-		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
-	} else {
-		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
-		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_NEAREST);
-	}*/
 	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, view->feature(QGLView::qglAnisotropicLevel).toInt());
 }
 
 
-void GLRendererBase::renderObjects(int pass, int light_pass, void * shaders, bool textures, bool light, bool fog) {
-	/*RenderingParameters rpl;
-	rpl.pass = pass;
-	rpl.light_pass = light_pass;
-	rpl.shaders = shaders;
-	rpl.textures = textures;
-	rpl.light = rpl.prev_light = light;
-	rpl.fog = rpl.prev_fog = fog;
-	rpl.view_matrix = rp.view_matrix;
-	rpl.prev_view_matrix = rp.prev_view_matrix;
-	rpl.proj_matrix = rp.proj_matrix;
-	rpl.prev_proj_matrix = rp.prev_proj_matrix;
-	rpl.cam_offset_matrix = view->camera()->offsetMatrix();
-	//qDebug() << "view:" << rp.view_matrix;
-	for (int i = 0; i < 32; ++i) rpl.prev_tex[i] = 0;
-	setupTextures(view->objects_, rpl, true);
-	glSetCapEnabled(GL_TEXTURE_2D, rpl.textures);
-	glSetCapEnabled(GL_BLEND, pass == ObjectBase::Transparent);
-	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
-	glDisable(GL_TEXTURE_CUBE_MAP);
-	glPushMatrix();
-	renderSingleObject(view->objects_, rpl);
-	glPopMatrix();*/
-}
-
-
-void GLRendererBase::renderSingleObject(ObjectBase & o, RenderingParameters & rpl) {
-//	if (!o.isInit())
-//		o.init();
-//	if (!o.isTexturesLoaded())
-//		o.loadTextures();
-//	if (!o.visible_) return;
-//	if (rpl.pass == o.pass_) {
-//		//Material & mat(o.material_);
-//		QMatrix4x4 curview = rpl.view_matrix * rpl.cam_offset_matrix * o.itransform_, prevview = rpl.prev_view_matrix * rpl.cam_offset_matrix * o.itransform_;
-//		//setupTextures(o, rpl, false);
-//		//mat.apply((QOpenGLShaderProgram*)rpl.shaders);
-//		glSetPolygonMode(o.render_mode != ObjectBase::View ? o.render_mode : (view->rmode != ObjectBase::View ? view->rmode : GL_FILL));
-//		glLineWidth(o.line_width > 0.f ? o.line_width : view->lineWidth_);
-//		glPointSize(o.line_width > 0.f ? o.line_width : view->lineWidth_);
-//		o.update();
-//		/*if (o.pass_ == GLObjectBase::Transparent) {
-//			glActiveTexture(GL_TEXTURE0 + 3);
-//			if (mat.reflectivity > 0.f) {
-//				glEnable(GL_TEXTURE_CUBE_MAP);
-//				//if (!mat.map_reflection.isEmpty()) mat.map_reflection.bind();
-//				//else glDisable(GL_TEXTURE_CUBE_MAP);
-//			} else glDisable(GL_TEXTURE_CUBE_MAP);
-//			if (rpl.light_pass > 0) glDisable(GL_TEXTURE_CUBE_MAP);
-//			GLfloat gm[16], bc[4] = {mat.reflectivity, mat.reflectivity, mat.reflectivity, mat.reflectivity};
-//			glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE);
-//			glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB, GL_INTERPOLATE);
-//			glTexEnvi(GL_TEXTURE_ENV, GL_SRC2_RGB, GL_CONSTANT);
-//			glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND2_RGB, GL_SRC_COLOR);
-//			glTexEnvfv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, bc);
-//			glGetFloatv(GL_MODELVIEW_MATRIX, gm);
-//			glMatrixMode(GL_TEXTURE);
-//			///glLoadTransposeMatrixf(gm);
-//			glScalef(-1., -1., -1.);
-//			glMatrixMode(GL_MODELVIEW);
-//			glActiveTexture(GL_TEXTURE0);
-//		}*/
-//		if (rpl.shaders) {
-//			//qDebug() << o.name() << curview << curview->determinant();
-//			//setUniformMatrices((QOpenGLShaderProgram*)rpl.shaders, rpl.proj_matrix, curview, rpl.prev_proj_matrix, prevview);
-//		} else {
-//			glMatrixMode(GL_MODELVIEW);
-//			//setGLMatrix(curview);
-//		}
-//		o.draw((QOpenGLShaderProgram*)rpl.shaders);
-//	}
-//	foreach (ObjectBase * i, o.children_)
-//		renderSingleObject(*i, rpl);
-}
-
-
-void GLRendererBase::renderShadow(Light * l, QOpenGLShaderProgram * prog, QMatrix4x4 mat) {
-	Camera cam;
-	QVector3D wp = l->worldPos();
-	cam.setPos(wp);
-	cam.setAim(wp + (l->worldTransform() * QVector4D(l->direction())).toVector3D());
-	cam.setDepthStart(view->camera()->depthStart());
-	cam.setFOV(l->angle_end);
-	//cam.apply(1.);
-	/*cam.rotateXY(l->angle_end);
-	QVector3D rdir = l->direction * cos(l->angle_end / 2. * deg2rad);
-	l->dir0 = cam.direction() - rdir;
-	cam.rotateXY(-l->angle_end);
-	cam.rotateZ(l->angle_end);
-	l->dir1 = cam.direction() - rdir;*/
-	//qDebug() << rdir << l->dir0 << l->dir1;
-	RenderingParameters rpl;
-	rpl.shaders = prog;
-	rpl.textures = rpl.light = rpl.fog = false;
-	//rpl.view_matrix = getGLMatrix(GL_MODELVIEW_MATRIX);
-	//rpl.proj_matrix = getGLMatrix(GL_PROJECTION_MATRIX);
-	rpl.cam_offset_matrix = cam.offsetMatrix();
-	QMatrix4x4 mbias;
-	mbias.scale(0.5, 0.5, 0.5);
-	mbias.translate(1., 1., 1.);
-	l->shadow_matrix = mbias*rpl.proj_matrix*rpl.view_matrix*rpl.cam_offset_matrix*mat;//;// * mbias;
-	//qDebug() << mbias;
-	//glPushMatrix();
-	//renderSingleShadow(view->objects_, rpl);
-	//glPopMatrix();
-}
-
-
-void GLRendererBase::renderSingleShadow(ObjectBase & o, RenderingParameters & rpl) {
-//	if (!o.isInit())
-//		o.init();
-//	if (!o.visible_) return;
-//	if (rpl.shaders) {
-//		//qDebug() << o.name() << curview << curview->determinant();
-//		//setUniformMatrices((QOpenGLShaderProgram*)rpl.shaders, rpl.proj_matrix, rpl.view_matrix * rpl.cam_offset_matrix * o.itransform_);
-//	} else {
-//		glMatrixMode(GL_MODELVIEW);
-//		//setGLMatrix(rpl.view_matrix * rpl.cam_offset_matrix * o.itransform_);
-//	}
-//	glPolygonMode(GL_FRONT_AND_BACK, o.render_mode != ObjectBase::View ? o.render_mode : (view->rmode != ObjectBase::View ? view->rmode : GL_FILL));
-//	glLineWidth(o.line_width > 0.f ? o.line_width : view->lineWidth_);
-//	glPointSize(o.line_width > 0.f ? o.line_width : view->lineWidth_);
-//	o.draw((QOpenGLShaderProgram*)rpl.shaders, true);
-//	foreach (ObjectBase * i, o.children_)
-//		renderSingleShadow(*i, rpl);
-}
-
-
-
-
 GLRendererBase::RenderingParameters::RenderingParameters() {
-	shaders = nullptr;
-	cur_shader = nullptr;
 }
 
 
 void GLRendererBase::RenderingParameters::prepare() {
-	//proj_matrix = getGLMatrix(GL_PROJECTION_MATRIX);
-	//view_matrix = getGLMatrix(GL_MODELVIEW_MATRIX);
 	viewproj_matrix = proj_matrix * view_matrix;
 	normal_matrix = view_matrix.normalMatrix();
 	proj_matrix_i = proj_matrix.inverted();

glrendererbase.h

@@ -22,6 +22,7 @@
 #include "glcamera.h"
 #include "glshaders.h"
 
+
 class GLRendererBase: public QObject , protected QOpenGLExtraFunctions
 {
 	friend class QGLView;
@@ -35,21 +36,10 @@ public:
 		RenderingParameters();
 		void prepare();
 		void setUniform(QOpenGLShaderProgram * prog);
-		int pass;
+		QMatrix4x4 view_matrix, view_matrix_i;
-		int light_pass;
+		QMatrix4x4 proj_matrix, proj_matrix_i;
-		bool light;
-		bool fog;
-		bool textures;
-		bool prev_light;
-		bool prev_fog;
-		GLuint prev_tex[32];
-		void * shaders;
-		QMatrix4x4 view_matrix, view_matrix_i, prev_view_matrix;
-		QMatrix4x4 proj_matrix, proj_matrix_i, prev_proj_matrix;
 		QMatrix4x4 viewproj_matrix, viewproj_matrix_i;
 		QMatrix3x3 normal_matrix;
-		QMatrix4x4 cam_offset_matrix;
-		QOpenGLShaderProgram * cur_shader;
 	};
 
 	RenderingParameters rp;
@@ -57,24 +47,18 @@ public:
 protected:
 	virtual void setupLight(const Light & l, int inpass_index, int gl_index);
 	virtual void setupAmbientLight(const QColor & a, bool first_pass);
-	virtual void setupShadersLights(int lights_count);
+	virtual void setupShadersLights(int lights_count) {}
 	virtual void setupTextures(ObjectBase & object, GLRendererBase::RenderingParameters & rp, bool first_object = false);
 	virtual void setupShadersTextures(ObjectBase & object, GLRendererBase::RenderingParameters & rp) {}
 	virtual void reloadShaders() {}
 	virtual void init(int width, int height) {}
 	virtual void resize(int width, int height) {}
 
-	void setupLights(int pass, int lights_per_pass);
 	inline void applyFilteringParameters();
-	void renderObjects(int pass, int light_pass, void * shaders = 0, bool textures = true, bool light = true, bool fog = true);
-	void renderSingleObject(ObjectBase & o, RenderingParameters & rpl);
-	void renderShadow(Light * l, QOpenGLShaderProgram * prog = 0, QMatrix4x4 mat = QMatrix4x4());
-	void renderSingleShadow(ObjectBase & o, RenderingParameters & rpl);
 
 	QGLView * view;
 	QImage white_image, violent_image;
 	GLuint white_image_id, violent_image_id;
-
 };
 
 #endif // GLRENDERERBASE_H

glscene.cpp

@@ -106,7 +106,7 @@ void Scene::clear() {
 
 void Scene::objectsCountInternal(int * cnt, ObjectBase * where) {
 	++(*cnt);
-	foreach (ObjectBase * i, where->children_)
+	foreach (ObjectBase * i, where->children())
 		objectsCountInternal(cnt, i);
 }
 int Scene::objectsCount(bool all) {
@@ -119,7 +119,7 @@ int Scene::objectsCount(bool all) {
 
 void Scene::removeObjectInternal(ObjectBase * o, ObjectBase * where) {
 	if (destroying) return;
-	foreach (ObjectBase * i, where->children_) {
+	foreach (ObjectBase * i, where->children()) {
 		if (o == i) {
 			where->removeChild(i);
 			setObjectMeshChanged(i);
@@ -250,7 +250,8 @@ void Scene::clearSelection() {
 	selected_top.clear();
 	ObjectBaseList ol = root_->children(true);
 	foreach (ObjectBase * o, ol) {
-		o->selected_ = o->selected_aim = false;
+		o->setSelected(false);
+		o->setAimSelected(false);
 	}
 	emitSelectionChanged();
 }
@@ -275,9 +276,6 @@ void gatherMeshes(ObjectBase * o, QSet<Mesh*> & ums) {
 void Scene::cleanUnused() {
 	QSet<Mesh*> ums;
 	gatherMeshes(root_, ums);
-	/*QMapIterator<int, QMap<Mesh*, ObjectBaseList>> it(geometries_used);
-	while (it.hasNext())
-		ums |= it.next().value().keys().toSet();*/
 	for (int i = 0; i < geometries.size(); ++i) {
 		if (ums.contains(geometries[i])) continue;
 		td_geometries << geometries[i];
@@ -344,7 +342,7 @@ void Scene::gatherSelection() {
 	selected_.clear();
 	ObjectBaseList ol = root_->children(true);
 	foreach (ObjectBase * o, ol)
-		if (o->selected_)
+		if (o->isSelected())
 			selected_ << o;
 }
 
@@ -353,7 +351,7 @@ void Scene::attachObject(ObjectBase * o) {
 	if (!o) return;
 	o->setScene(this);
 	if (o->mesh()) { // search suitable mesh in this scene
-		o->mesh_ = attachMesh(o->mesh());
+		o->setMesh(attachMesh(o->mesh()));
 		setObjectMeshChanged(o);
 	}
 	if (o->material()) { // search suitable material in this scene
@@ -483,7 +481,6 @@ void Scene::destroy(QOpenGLExtraFunctions * f) {
 
 
 void Scene::destroyUnused(QOpenGLExtraFunctions * f) {
-	//if (!td_geometries.isEmpty()) qDebug() << "destroyUnused" << td_geometries.size();
 	foreach (Mesh * i, td_geometries)
 		i->destroy(f);
 	qDeleteAll(td_geometries);
@@ -505,18 +502,14 @@ QDataStream & operator <<(QDataStream & s, const Scene * p) {
 	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);
 	s << qCompress(cs.data());
-	//s << cs.data();
 	return s;
 }
 QDataStream & operator >>(QDataStream & s, Scene *& p) {
 	p = new Scene();
-	//ChunkStream cs(s);
-
 	QByteArray ba;
 	s >> ba;
 	ba = qUncompress(ba);
 	ChunkStream cs(ba);
-
 	QVector<short> geom_ind, mat_ind;
 	while (!cs.atEnd()) {
 		switch (cs.read()) {

glscene.h

@@ -24,7 +24,6 @@
 
 class Scene: public QObject {
 	Q_OBJECT
-	friend class QGLView;
 	friend class RendererBase;
 	friend class Renderer;
 	friend class RendererMaterial;
@@ -119,8 +118,8 @@ protected:
 	QVector<Mesh*> geometries, td_geometries;
 	QVector<Material*> materials;
 
-	QMap<int, QMap<Mesh*, ObjectBaseList>> geometries_used; // [pass][mesh] = ObjectBaseList
+	QMap<int, QMap<Mesh*, ObjectBaseList>> geometries_used;
-	QMap<int, QList<Light*>> lights_used; // by Light::Type
+	QMap<int, QList<Light*>> lights_used;
 	QList<Camera*> cameras_used;
 	QVector<Material*> changed_materials;
 
@@ -129,14 +128,11 @@ protected:
 
 protected slots:
 
-
 signals:
 	void __objectDeleted(ObjectBase * o);
 	void __destroyed();
 	void treeChanged();
-	//void treeStructChanged();
 	void selectionChanged();
-
 };
 
 

gltexture_manager.cpp

@@ -44,7 +44,7 @@ GLuint TextureManager::loadTexture(const QString & path, bool ownership, bool bu
 	if (bump) convertToNormal(image);
 	//qDebug() << p << image.width() << image.height() << image.format() << bump;
 	GLuint tid_ = tid;
-	createGLTexture(f, tid_, image);///currentQGLView->bindTexture(image, GL_TEXTURE_2D);
+	createGLTexture(f, tid_, image);
 	tid = tid_;
 	if (tid == 0) {
 		qDebug() << "[TextureManager] Can`t load" << p;
@@ -64,7 +64,7 @@ GLuint TextureManager::loadTexture(const QImage & im, bool ownership, bool bump)
 	QImage image(im);
 	if (bump) convertToNormal(image);
 	GLuint tid = 0;
-	createGLTexture(f, tid, im);///currentQGLView->bindTexture(image, GL_TEXTURE_2D);
+	createGLTexture(f, tid, im);
 	if (tid == 0) {
 		qDebug() << "[TextureManager] Can`t load image";
 		return tid;

gltexture_manager.h

@@ -56,9 +56,7 @@ protected:
 	QMap<QString, GLuint> tex_ids[2];
 	QMap<QString, QImage> tex_im [2];
 	QStringList tex_pathes;
-
 	QOpenGLExtraFunctions * f;
-
 };
 
 

glwidget.h

@@ -97,8 +97,6 @@ private:
 	QWidget * container;
 	QGLView * view_;
 	QLayout * lay;
-
-signals:
 };
 
 #endif // GLWIDGET_H

mouse_controller.cpp

@@ -57,7 +57,7 @@ void MouseController::mouseReleaseEvent(QMouseEvent * e) {
 		selecting_ = false;
 		canSelect_ = true;
 		view->renderer_.mouse_rect = QRect();
-		view->scene_->selectObjects(hov_objects.toList(), add_ts);
+		view->scene()->selectObjects(hov_objects.toList(), add_ts);
 		return;
 	}
 	if (canSelect_ && mouseSelect_) {
@@ -68,16 +68,16 @@ void MouseController::mouseReleaseEvent(QMouseEvent * e) {
 					view->scene()->clearSelection();
 				} else {
 					if (!hov_objects.isEmpty())
-						view->scene_->selectObject(hov_objects[0], add_ts);
+						view->scene()->selectObject(hov_objects[0], add_ts);
 					if (!hov_aims.isEmpty()) {
-						view->scene_->selectObject(hov_aims[0], add_ts);
+						view->scene()->selectObject(hov_aims[0], add_ts);
-						hov_aims[0]->selected_aim = true;
+						hov_aims[0]->setAimSelected(true);
 					}
 				}
 			}
 			if (e->button() == Qt::RightButton) {
 				if (view->renderer_.edit_mode && !view->scene()->selectedObjects().isEmpty())
-					view->context_menu.popup(e->globalPos());
+					view->popupMenu(e->globalPos());
 			}
 		}
 	}
@@ -107,7 +107,7 @@ void MouseController::mouseMoveEvent(QMouseEvent * e) {
 	QPoint cpos = e->pos();
 	if (cur_action != RendererService::haNoAction && (e->buttons() == Qt::LeftButton)) {
 		RendererService & rs(view->renderer_.rend_service);
-		ObjectBaseList objects = view->scene_->selectedObjects(true);
+		ObjectBaseList objects = view->scene()->selectedObjects(true);
 		QVector<int> axis;
 		switch (cur_action) {
 		case RendererService::haMove:
@@ -146,7 +146,7 @@ void MouseController::mouseMoveEvent(QMouseEvent * e) {
 					if (o->parent())
 						pmat = o->parent()->worldTransform().inverted();
 					QVector3D dv = pmat.mapVector(axe_vector);
-					if (o->selected_aim) {
+					if (o->isAimSelected()) {
 						AimedObject * ao = (AimedObject*)o;
 						ao->setAim(ao->aim() + dv);
 					} else
@@ -168,7 +168,6 @@ void MouseController::mouseMoveEvent(QMouseEvent * e) {
 				scales << axe_vector;
 			}
 		}
-		//if (cur_handle >= RendererService::htScaleX  && cur_handle <= RendererService::htScaleZ ) cs = Qt::SplitHCursor;
 		if (cur_action == RendererService::haScale) {
 			double sc = 0., max = 0.;
 			foreach (const QVector3D & s, scales) {
@@ -222,7 +221,7 @@ void MouseController::mouseMoveEvent(QMouseEvent * e) {
 	if (customMouseMove_) emit view->customMouseMoveEvent(e->pos(), lastPos, e->buttons());
 	lastPos = e->pos();
 	if (e->buttons() == 0) {
-		cur_handle = 0;
+		cur_handle = QFlags<RendererService::HandleMesh>();
 		cur_action = RendererService::haNoAction;
 		Qt::CursorShape cs = Qt::CrossCursor;
 		if (view->renderer_.edit_mode) {
@@ -242,7 +241,7 @@ void MouseController::mouseMoveEvent(QMouseEvent * e) {
 			}
 		}
 		if (cur_action == RendererService::haNoAction)
-			cur_handle = 0;
+			cur_handle = QFlags<RendererService::HandleMesh>();
 		view->setCursor(cs);
 		view->renderer_.rend_service.current_handle = cur_handle;
 	}

openglwindow.cpp

@@ -42,7 +42,6 @@ OpenGLWindow::OpenGLWindow(QWindow *parent)
 #endif
 	format.setDepthBufferSize(24);
 	format.setSamples(8);
-//	format.setStencilBufferSize(8);
 	setFormat(format);
 	QSurfaceFormat::setDefaultFormat(format);
 }

openglwindow.h

@@ -24,7 +24,7 @@ class QOpenGLContext;
 class QOpenGLPaintDevice;
 
 
-class OpenGLWindow: public QWindow, protected QOpenGLExtraFunctions
+class OpenGLWindow: public QWindow, public QOpenGLExtraFunctions
 {
 	Q_OBJECT
 public:
@@ -33,9 +33,7 @@ public:
 
 	virtual void render(QPainter *painter);
 	virtual void render();
-
 	virtual void initialize();
-
 	QOpenGLContext * context() {return m_context;}
 
 public slots:
@@ -44,7 +42,6 @@ public slots:
 
 protected:
 	bool event(QEvent *event) override;
-
 	void exposeEvent(QExposeEvent *event) override;
 
 private:

qglview.cpp

@@ -76,8 +76,6 @@ QGLView::QGLView(): OpenGLWindow(), renderer_(this), mouse(this) {
 	hoverHalo_ = selectionHalo_ = true;
 	fogEnabled_ = is_init = shaders_bind = changed_ = false;
 	rmode = ObjectBase::Fill;
-//	sel_pen = QPen(Qt::black, 1, Qt::DashLine);
-//	sel_brush = QBrush(QColor(170, 100, 255, 120));
 	scene_ = new Scene();
 	connect(scene_, SIGNAL(selectionChanged()), this, SIGNAL(selectionChanged()));
 	connect(scene_, SIGNAL(__destroyed()), this, SLOT(__destroyed()));
@@ -89,22 +87,14 @@ QGLView::QGLView(): OpenGLWindow(), renderer_(this), mouse(this) {
 //	qDebug() << camera_->aim();
 	default_camera->setName("Camera");
 	emit cameraPosChanged(default_camera->pos());
-	//camera().aim_ = camera().pos_;
 	ktm_.restart();
 
-	//Mesh * m = Primitive::torus(100, 40, 1., 0.4, 360);
 	Mesh * m = Primitive::cube(10, 10, 10);
 	m->flipNormals();
-	//QMatrix4x4 mat;
-	//mat.rotate(90, 0,1,0);
-	//mat.translate(0, 0, 2);
-	//mat.rotate(180, 1,0,0);
-	//m->transformPoints(mat);
 	ObjectBase * o = new ObjectBase(m);
 	o->setColor(Qt::cyan);
 	scene()->addObject(o);
 	delete m;
-
 }
 
 
@@ -156,7 +146,6 @@ void QGLView::resizeEvent(QResizeEvent * e) {
 
 void QGLView::timerEvent(QTimerEvent *) {
 	renderNow();
-	//if (ktm_.elapsed() < QApplication::keyboardInputInterval()) return;
 	Qt::KeyboardModifiers km = QApplication::keyboardModifiers();
 	foreach (int i, keys_)
 		emit keyEvent((Qt::Key)i, km);

qglview.h

@@ -33,17 +33,7 @@
 
 class QGLView: public OpenGLWindow
 {
-	friend class MouseController;
-	friend class GLRendererBase;
-	friend class TextureManager;
-	friend class ObjectBase;
-	friend class Scene;
-	friend class RendererBase;
-	friend class Renderer;
-	friend class RendererMaterial;
-	friend class RendererService;
 	friend class RendererSelection;
-	friend class TonemappingProc;
 	Q_OBJECT
 	Q_PROPERTY (QColor backColor READ backColor WRITE setBackColor)
 	Q_PROPERTY (float lineWidth READ lineWidth WRITE setLineWidth)
@@ -115,8 +105,8 @@ public:
 
 	QColor backColor() const {return backColor_;}
 	float lineWidth() const {return lineWidth_;}
-	float FOV() const {return camera()->fov_;}
+	float FOV() const {return camera()->FOV();}
-	float depthStart() const {return camera()->depth_start;}
+	float depthStart() const {return camera()->depthStart();}
 	float currentFPS() const {return fps_;}
 	float gamma() const {return renderer_.gamma_;}
 	bool autoExposure() const {return renderer_.tone_proc.enabled;}
@@ -186,6 +176,7 @@ public:
 	QImage materialThumbnail(Material * m) {return renderer_.materialThumbnail(m);}
 	void setCurrentAction(RendererService::HandleAction ha) {renderer_.rend_service.setCurrentAction(ha);}
 	void setContextActions(QList<QAction*> al) {context_menu.clear(); context_menu.addActions(al);}
+	void popupMenu(const QPoint &pos, QAction *at = nullptr) {context_menu.popup(pos, at);}
 
 	GLfloat aspect, iaspect;
 	Renderer renderer_;
@@ -241,8 +232,8 @@ private slots:
 public slots:
 	void setBackColor(const QColor & arg) {backColor_ = arg;}
 	void setLineWidth(const float & arg) {lineWidth_ = arg;}
-	void setFOV(const float & arg) {camera()->fov_ = arg;}
+	void setFOV(const float & arg) {camera()->setFOV(arg);}
-	void setDepthStart(const float & arg) {camera()->depth_start = arg;}
+	void setDepthStart(const float & arg) {camera()->setDepthStart(arg);}
 	void setGamma(const float & arg) {renderer_.gamma_ = arg;}
 	void setAutoExposure(bool arg) {renderer_.tone_proc.enabled = arg;}
 	void setAmbientColor(const QColor & arg) {ambientColor_ = arg;}
@@ -287,7 +278,6 @@ signals:
 	void materialsChanged();
 	void materialThumbnailCreated(Material*);
 	void doubleClick();
-
 };
 
 #endif // QGLVIEW_H

renderer.cpp

@@ -51,22 +51,6 @@ Renderer::Renderer(QGLView * view_): RendererBase(view_),
 	shader_files[srFinalPass    ] = "ds_final.glsl";
 	shader_files[srTonemapPass  ] = "ds_tonemap.glsl";
 
-	/*shaders << ShaderPair("FXAA", &shader_fxaa)
-			<< ShaderPair("dsl_pass_0", &shader_ds_0)
-			<< ShaderPair("dsl_pass_1", &shader_ds_1)
-			<< ShaderPair("hdr", &shader_hdr)
-			<< ShaderPair("downscale", &shader_small)
-			<< ShaderPair("bloom_pass_0", &shader_bloom_0)
-			<< ShaderPair("bloom_pass_1", &shader_bloom_1)
-			<< ShaderPair("fbo_add", &shader_fbo_add)
-			<< ShaderPair("motion_blur", &shader_motion_blur)
-			<< ShaderPair("shadow", &shader_shadow)
-			<< ShaderPair("ssr", &shader_ssr)
-			<< ShaderPair("ssr_blur", &shader_ssr_blur)
-			<< ShaderPair("ssr_merge", &shader_ssr_merge)
-			<< ShaderPair("ssao_blur", &shader_ssao_blur)
-			<< ShaderPair("ssao_merge", &shader_ssao_merge)
-			<< ShaderPair("dof", &shader_dof);*/
 	shader_fxaa = 0;
 	gamma_ = 1.;
 	edit_mode = need_init_shaders = true;
@@ -159,7 +143,6 @@ void Renderer::initShaders() {
 		for (int i = 0; i < 5; ++i)
 			prog->setUniformValue(QString("tex_%1").arg(i).toLatin1().constData(), i);
 		prog->setUniformValue("tex_coeffs[0]", (int)Renderer::dbrBuffersCount);
-		//prog->setUniformValue("tex_coeffs[1]", (int)Renderer::dbrBuffersCount+1);
 		prog->setUniformValue("tex_env", (int)Renderer::dbrBuffersCount+1);
 	}
 	if (bindShader(srFinalPass, &prog)) {
@@ -194,9 +177,9 @@ void Renderer::fillObjectsBuffer(const ObjectBaseList & ol, RenderPass pass) {
 			so.color = QVector4D(1,1,1,1);
 		} else {
 			so.material = 0;
-			so.color = QColor2QVector(o->color_);
+			so.color = QColor2QVector(o->color());
 		}
-		so.object_id = o->id_;
+		so.object_id = o->id();
 		o->worldTransform().transposed().copyDataTo(so.modelmatrix);
 		//qDebug() << "load obj" << o->name() << o->worldTransform();
 	}
@@ -242,11 +225,10 @@ void Renderer::renderLight(int first_wr_buff, bool clear_only) {
 	fbo_ds.bindColorTextures();
 	fbo_out.bind();
 	tex_env.bind((int)Renderer::dbrBuffersCount+1);
-	//int ri = 1, wi = 0;
 	typedef QPair<Renderer::ShaderRole, Light::Type> PassPair;
 	QVector<PassPair> passes;
 	passes << PassPair(srLightOmniPass, Light::Omni) << PassPair(srLightSpotPass, Light::Cone);
-	QColor back = view->fogColor_;
+	QColor back = view->fogColor();
 	back.setAlpha(0);
 	foreach (PassPair pass, passes) {
 		if (bindShader(pass.first, &prog)) {
@@ -257,9 +239,9 @@ void Renderer::renderLight(int first_wr_buff, bool clear_only) {
 			setUniformViewCorners(prog, cam);
 			prog->setUniformValue("lights_start", lights_start[pass.second]);
 			prog->setUniformValue("lights_count", cur_lights[pass.second].size());
-			prog->setUniformValue("fog_color", view->fogColor_);
+			prog->setUniformValue("fog_color", view->fogColor());
-			prog->setUniformValue("fog_decay", qMax(view->fogDecay_, 0.001f));
+			prog->setUniformValue("fog_decay", qMax(view->fogDecay(), 0.001f));
-			prog->setUniformValue("fog_density", view->fogDensity_);
+			prog->setUniformValue("fog_density", view->fogDensity());
 			prog->setUniformValue("view_mat", cam->viewMatrix().inverted().toGenericMatrix<3,3>());
 			renderQuad(prog, quad, cam);
 		}
@@ -271,7 +253,7 @@ void Renderer::renderScene() {
 	initShaders();
 	tex_env.load();
 	QOpenGLExtraFunctions * f = view;
-	Scene & scene(*(view->scene_));
+	Scene & scene(*(view->scene()));
 	Camera * cam = view->camera();
 	QOpenGLShaderProgram * prog = 0;
 	bool scene_changed = scene.prepare();
@@ -279,8 +261,6 @@ void Renderer::renderScene() {
 
 	/// reload materials on change
 	if (scene_changed || scene.need_reload_materials) {
-		//if (scene.need_reload_materials)
-		//	maps_hash = 0;
 		rend_selection.generateObjectsID(scene);
 		reloadMaterials(scene);
 		if (edit_mode)
@@ -342,7 +322,6 @@ void Renderer::renderScene() {
 
 	/// blending layers
 	if (bindShader(srFinalPass, &prog)) {
-		//fbo_ds .bindColorTexture(dbrNormalZ        , 0);
 		fbo_out.bindColorTexture(obrSolidOmni      , 1);
 		fbo_out.bindColorTexture(obrSolidSpot      , 2);
 		fbo_out.bindColorTexture(obrTransparentOmni, 3);
@@ -371,8 +350,6 @@ void Renderer::renderScene() {
 	} else {
 		fbo_out.blit(obrTonemap, 0, 0, fbo_out.rect(), QRect(QPoint(), view->size()));
 	}
-	//fbo_small_16.blit(0, 0, 0, fbo_small_16.rect(), fbo_small_16.rect(), GL_COLOR_BUFFER_BIT, GL_LINEAR);
-
 }
 
 

renderer.h

@@ -31,7 +31,6 @@
 class Renderer: public RendererBase {
 	friend class QGLView;
 	friend class MouseController;
-	friend class RendererBase;
 	friend class RendererMaterial;
 	friend class RendererService;
 	friend class RendererSelection;
@@ -105,10 +104,6 @@ private:
 	int camera_light_mode;
 	bool edit_mode, need_init_shaders, need_render_sum;
 	Framebuffer fbo_ds, fbo_out;
-	/*QOpenGLShaderProgram * shader_fxaa, * shader_ds_0, * shader_ds_1, * shader_hdr, * shader_small;
-	QOpenGLShaderProgram * shader_bloom_0, * shader_bloom_1, * shader_motion_blur, * shader_fbo_add;
-	QOpenGLShaderProgram * shader_shadow, * shader_ssr, * shader_ssr_blur, * shader_ssr_merge;
-	QOpenGLShaderProgram * shader_ssao_blur, * shader_ssao_merge, * shader_dof;*/
 	QMap<ShaderRole, QString> shader_files;
 	QMap<ShaderRole, QStringList> shader_defines;
 	QMap<ShaderRole, QOpenGLShaderProgram*> shaders;
@@ -130,7 +125,6 @@ private:
 	QVector4D corner_dirs[4];
 	QVector<QVector3D> hcontent;
 	QMap<int, QList<Light*>> cur_lights;
-
 };
 
 #endif // RENDERER_H

renderer_base.cpp

@@ -191,7 +191,6 @@ void RendererBase::reloadMaterials(Scene & scene) {
 			qDebug() << "[QGLEngine] Warning: Too many materials! Maximum" << max_materials;
 			break;
 		}
-		//m->load(textures_manager);
 		m->_index = cur_materials_.size();
 		m->_changed = false;
 		glm.color_diffuse  = QColor2QVector(m->color_diffuse );
@@ -209,8 +208,6 @@ void RendererBase::reloadMaterials(Scene & scene) {
 		cur_materials_ << glm;
 	}
 	//qDebug() << "load" << cur_materials_.size() << "materials";
-	//textures_maps.resize(maps_size, );
-	//cur_materials_[0].color_diffuse = QColor2QVector(Qt::red);
 	buffer_materials.bind(view);
 	buffer_materials.resize(view, cur_materials_.size() * sizeof(QGLMaterial));
 	buffer_materials.load(view, cur_materials_.constData(), cur_materials_.size() * sizeof(QGLMaterial));
@@ -247,8 +244,6 @@ void RendererBase::reloadLightsParameters(const QMap<int, QList<Light*>> & light
 		so.decay_intensity[1] = l->decay_linear;
 		so.decay_intensity[2] = l->decay_quadratic;
 		so.decay_intensity[3] = l->intensity;
-		//so.shadow = shadow;
-		//so.shadowColor = shadow;
 	}
 	buffer_lights.bind(view);
 	buffer_lights.resize(view, cur_lights_params_.size() * sizeof(QGLLightParameter));
@@ -263,12 +258,11 @@ void RendererBase::reloadLightsPositions(Camera * cam) {
 		QGLLightPosition & so(cur_lights_pos_[i]);
 		Light * l = current_lights[i];
 		QMatrix4x4 m = mat * l->worldTransform();
-		QVector4D pos(0, 0, 0, 1.), dir(QVector3D(0,0,-1), 1);//, dir0(light->dir0), dir1(light->dir1);
+		QVector4D pos(0, 0, 0, 1.), dir(QVector3D(0,0,-1), 1);
 		pos = m * pos;
-		dir = (m * QVector4D(QVector3D(0,0,-1),0)).normalized();//((m * dir) - pos).normalized();
+		dir = (m * QVector4D(QVector3D(0,0,-1),0)).normalized();
 		so.position = pos;
 		so.direction = dir;
-		//so.shadowMatrix = l->shadow_matrix;
 	}
 	buffer_lights_pos.bind(view);
 	buffer_lights_pos.resize(view, cur_lights_pos_.size() * sizeof(QGLLightPosition));
@@ -279,7 +273,7 @@ void RendererBase::reloadLightsPositions(Camera * cam) {
 void RendererBase::markReloadTextures() {
 	maps_hash = 0;
 	textures_manager->clearImageCache();
-	view->scene_->need_reload_materials = true;
+	view->scene()->need_reload_materials = true;
 }
 
 
@@ -305,7 +299,7 @@ void RendererBase::renderQuad(QOpenGLShaderProgram * prog, Mesh * mesh, Camera *
 }
 
 
-
+// ----------------------------------------------------------------------------
 
 float RadicalInverse_VdC(uint bits) {
 	bits = (bits << 16u) | (bits >> 16u);
@@ -315,10 +309,13 @@ float RadicalInverse_VdC(uint bits) {
 	bits = ((bits & 0x00FF00FFu) << 8u) | ((bits & 0xFF00FF00u) >> 8u);
 	return float(bits) * 2.3283064365386963e-10; // / 0x100000000
 }
-// ----------------------------------------------------------------------------
+
+
 QVector2D Hammersley(uint i, uint N) {
 	return QVector2D(float(i)/float(N), RadicalInverse_VdC(i));
 }
+
+
 QVector3D ImportanceSampleGGX(QVector2D Xi, QVector3D N, float roughness) {
 	float a = roughness*roughness;
 	float phi = 2.0 * M_PI * Xi[0];
@@ -336,12 +333,16 @@ QVector3D ImportanceSampleGGX(QVector2D Xi, QVector3D N, float roughness) {
 	QVector3D sampleVec = tangent * H[0] + bitangent * H[1] + N * H[2];
 	return sampleVec.normalized();
 }
+
+
 float GeometrySchlickGGX(float NdotV, float roughness) {
 	float k = (roughness * roughness) / 2.0;
 	float nom   = NdotV;
 	float denom = NdotV * (1.0 - k) + k;
 	return nom / denom;
 }
+
+
 float GeometrySmith(QVector3D N, QVector3D V, QVector3D L, float roughness) {
 	float NdotV = piMax(QVector3D::dotProduct(N, V), 0.f);
 	float NdotL = piMax(QVector3D::dotProduct(N, L), 0.f);
@@ -349,6 +350,8 @@ float GeometrySmith(QVector3D N, QVector3D V, QVector3D L, float roughness) {
 	float ggx1 = GeometrySchlickGGX(NdotL, roughness);
 	return ggx1 * ggx2;
 }
+
+
 QVector2D IntegrateBRDF(float NdotV, float roughness) {
 	QVector3D V;
 	V[0] = sqrt(1.f - NdotV*NdotV);
@@ -378,49 +381,19 @@ QVector2D IntegrateBRDF(float NdotV, float roughness) {
 	return QVector2D(A, B);
 }
 
+
 void RendererBase::initCoeffTextures() {
 	QImage im = QImage(":/coeffs_brdf.png").mirrored();
 	int size = im.width();
 	QVector<QVector2D> data(size*size);
 	int ind = -1;
 	for (int x = 0; x < size; ++x) {
-		//float c = x / double(size - 1) + 1.E-3;
 		for (int y = 0; y < size; ++y) {
-			//float r = y / double(size - 1);
 			QColor p = im.pixelColor(x, y);
-			data[++ind] = QVector2D(p.redF(), p.greenF());//IntegrateBRDF(c, 1.f - r + 1.E-3);
+			data[++ind] = QVector2D(p.redF(), p.greenF());
 		}
 	}
 	createCoeffTexture(tex_coeff[0], data.constData(), size, 2);
-	/*const int size = 512;
-	QVector<float> data_diff(size*size), data_spec(size*size);
-	double r, c, c2;
-	int ind = -1;
-	for (int x = 0; x < size; ++x) {
-		c = x / double(size - 1);
-		c = sqrt(c);
-		c = piMax(1.E-16, c);
-		c2 = c*c;
-		for (int y = 0; y < size; ++y) {
-			r = y / double(size - 1);
-			double r_d = r;
-			double r_s = r*r*r;
-			r_d = piMax(1.E-16, r_d);
-			r_s = piMax(1.E-16, r_s);
-
-			double ndlc = (1. - c2) / c2;
-			double diff = 2. / (1. + sqrt(1. + (1. - r_d) * ndlc));
-
-			double spec = c2 * (r_s + ndlc);
-			spec = r_s / (spec * spec) / M_PI;
-
-			++ind;
-			data_diff[ind] = piClamp(diff, 1.E-12, 1.E+36);
-			data_spec[ind] = piClamp(spec, 1.E-12, 1.E+36);
-		}
-	}
-	createCoeffTexture(tex_coeff[0], data_diff, size);
-	createCoeffTexture(tex_coeff[1], data_spec, size);*/
 }
 
 

renderer_base.h

@@ -62,7 +62,6 @@ protected:
 	GLuint tex_coeff[2];
 	QMap<int, int> lights_start;
 	QList<Light*> current_lights;
-
 };
 
 #endif // RENDERER_BASE_H

renderer_material.cpp

@@ -28,8 +28,8 @@
 using namespace QGLEngineShaders;
 
 
-RendererMaterial::RendererMaterial(Renderer * r_): r(r_),
+RendererMaterial::RendererMaterial(Renderer * r_)
-		fbo_mat_thumb(r->view, 6, true , GL_RGBA16F) {
+: r(r_), fbo_mat_thumb(r->view, 6, true , GL_RGBA16F) {
 	mat_sphere = Primitive::ellipsoid(16, 16);
 	mat_camera = new Camera();
 	mat_camera->setPos(QVector3D(2, 2, 2));
@@ -122,10 +122,10 @@ void RendererMaterial::recreateMaterialThumbnails(bool force_all) {
 	if (force_all) {
 		mat_thumb_queue.clear();
 		//qDebug() << "recreateMaterialThumbnails" << view->scene_->materials;
-		foreach (Material * m, r->view->scene_->materials)
+		foreach (Material * m, r->view->scene()->materials)
 			mat_thumb_queue.enqueue(m);
 	} else {
-		foreach (Material * m, r->view->scene_->changed_materials)
+		foreach (Material * m, r->view->scene()->changed_materials)
 			if (!mat_thumb_queue.contains(m))
 				mat_thumb_queue.enqueue(m);
 	}

renderer_material.h

@@ -25,7 +25,6 @@
 
 class RendererMaterial {
 	friend class QGLView;
-
 public:
 	RendererMaterial(Renderer * r_);
 	virtual ~RendererMaterial();
@@ -40,7 +39,6 @@ public:
 
 private:
 	Renderer * r;
-
 	Framebuffer fbo_mat_thumb;
 	Mesh * mat_sphere;
 	Camera * mat_camera;
@@ -48,7 +46,6 @@ private:
 	QMap<Material*, QImage> mat_thumbnails;
 	Material * last_thumb_material;
 	QQueue<Material*> mat_thumb_queue;
-
 };
 
 #endif // RENDERER_MATERIAL_H

renderer_selection.cpp

@@ -26,8 +26,8 @@
 using namespace QGLEngineShaders;
 
 
-RendererSelection::RendererSelection(Renderer * r_): r(r_),
+RendererSelection::RendererSelection(Renderer * r_)
-		fbo_selection(r->view, 6) {
+: r(r_), fbo_selection(r->view, 6) {
 	sel_frame = Primitive::plane(2., 2.);
 	id_hover = 0;
 	line_thick_ = 2.;
@@ -50,8 +50,6 @@ void RendererSelection::resize(int width, int height) {
 	scale_ = 0.5 / appScale();
 	fbo_selection.enablePixelBuffer();
 	fbo_selection.resize(width * scale_, height * scale_);
-	//fbo_selection.setColorTextureFiltering(sbrSrcHover , GL_LINEAR);
-	//fbo_selection.setColorTextureFiltering(sbrSrcSelect, GL_LINEAR);
 }
 
 
@@ -138,8 +136,6 @@ void RendererSelection::renderSelection(Scene & scene) {
 		rs.drawLights();
 		rs.drawCameras();
 		rs.drawCurrentHandleObjects();
-
-		//mouse_rect = fbo_selection.rect();
 		if (r->mouse_rect.isNull())
 			fbo_selection.queryPoint(0, r->mouse_pos * scale_);
 		else
@@ -150,14 +146,14 @@ void RendererSelection::renderSelection(Scene & scene) {
 		fbo_selection.bindColorTexture(sbrSrcHover , sbrSrcHover );
 		fbo_selection.bindColorTexture(sbrSrcSelect, sbrSrcSelect);
 		fbo_selection.setWriteBuffers(QVector<int>() << sbrHovered << sbrSelected);
-		if (!view->hoverHalo_ && !view->selectionHalo_)
+		if (!view->isHoverHaloEnabled() && !view->isSelectionHaloEnabled())
 			glClearFramebuffer(QColor(0,0,0,0), false);
 		else {
 			r->bindShader(Renderer::srSelectionHalo, &prog);
 			r->setUniformHalo(prog, "hover"    , view->hoverHaloColor()    , view->hoverHaloFillAlpha());
 			r->setUniformHalo(prog, "selection", view->selectionHaloColor(), view->selectionHaloFillAlpha());
-			prog->setUniformValue("has_hover"    , view->hoverHalo_ && (id_hover > 0) ? 1.f : 0.f);
+			prog->setUniformValue("has_hover"    , view->isHoverHaloEnabled() && (id_hover > 0) ? 1.f : 0.f);
-			prog->setUniformValue("has_selection", view->selectionHalo_ ? 1.f : 0.f);
+			prog->setUniformValue("has_selection", view->isSelectionHaloEnabled() ? 1.f : 0.f);
 			prog->setUniformValue("fb_hover"    , (int)sbrSrcHover);
 			prog->setUniformValue("fb_selection", (int)sbrSrcSelect);
 			prog->setUniformValue("hover_id", QVector4D(float( id_hover        & 0xFF) / 255.f,
@@ -177,7 +173,6 @@ void RendererSelection::renderSelection(Scene & scene) {
 			fbo_selection.setWriteBuffer(sbrSelectedFXAA);
 			r->renderQuad(prog, r->quad, 0, false);
 		}
-
 		fbo_selection.release();
 	}
 }

renderer_selection.h

@@ -53,16 +53,13 @@ protected:
 
 private:
 	Renderer * r;
-
 	Framebuffer fbo_selection;
 	Mesh * sel_frame;
 	float line_thick_, scale_;
-
 	QVector<uchar> cur_selections_;
 	QHash<uint, ObjectBase * > ids;
 	QHash<uint, ObjectBase * > aim_ids;
 	uint id_hover;
-
 };
 
 #endif // RENDERER_selection_H

renderer_service.cpp

@@ -198,7 +198,7 @@ void RendererService::fillOmniObjects() {
 	foreach (Light * l, ll) {
 		QMatrix4x4 m = invariantSizeMatrix(l->worldPos());
 		m.transposed().copyDataTo(o.modelmatrix);
-		o.object_id = l->id_;
+		o.object_id = l->id();
 		cur_objects << o;
 	}
 }
@@ -218,14 +218,14 @@ void RendererService::fillAimedObjects(const ObjectBaseList & objects, Mesh * li
 		QMatrix4x4 m;
 		m = invariantSizeMatrix(ao->worldPos()) * parentRotationMatrix(ao);
 		m.transposed().copyDataTo(o.modelmatrix);
-		o.object_id = ao->id_;
+		o.object_id = ao->id();
 		cur_objects << o;
 
 		lv << ao->worldPos() << ao->worldAim();
 
 		m = invariantSizeMatrix(ao->worldAim());
 		m.transposed().copyDataTo(o.modelmatrix);
-		o.object_id = ao->id_ + 1;
+		o.object_id = ao->id() + 1;
 		cur_aims << o;
 	}
 	ln.resize(lv.size());
@@ -269,7 +269,7 @@ bool RendererService::calculateCenter() {
 	axis_mat = QMatrix4x4();
 	if ((sol.size() == 1)) {
 		if (current_action == haMove) {
-			if (sol[0]->selected_aim)
+			if (sol[0]->isAimSelected())
 				selection_center = ((AimedObject*)sol[0])->worldAim();
 		} else {
 			axis_mat = parentRotationMatrix(sol[0]);
@@ -330,7 +330,7 @@ void RendererService::drawLights() {
 
 	fillOmniObjects();
 	omni_mesh->loadObjects(v, cur_objects);
-	r->fillSelectionsBuffer(rs.cur_selections_, lights2objectList(v->scene_->lights_used.value(Light::Omni)));
+	r->fillSelectionsBuffer(rs.cur_selections_, lights2objectList(v->scene()->lights_used.value(Light::Omni)));
 	omni_mesh->loadSelections(v, rs.cur_selections_);
 	omni_mesh->draw(v, cur_objects.size());
 
@@ -354,7 +354,7 @@ void RendererService::drawLightsFrame(QColor color) {
 	fillOmniObjects();
 	setObjectsColor(cur_objects, color);
 	omni_mesh_f->loadObjects(v, cur_objects);
-	r->fillSelectionsBuffer(rs.cur_selections_, lights2objectList(v->scene_->lights_used.value(Light::Omni)));
+	r->fillSelectionsBuffer(rs.cur_selections_, lights2objectList(v->scene()->lights_used.value(Light::Omni)));
 	omni_mesh_f->loadSelections(v, rs.cur_selections_);
 	omni_mesh_f->draw(v, cur_objects.size());
 
@@ -446,14 +446,12 @@ void RendererService::renderService() {
 
 	}
 	if (r->bindShader(Renderer::srServiceLine, &prog)) {
-		//glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
 		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);
 		line_spot_f  ->draw(f, 1);
 		line_camera_f->draw(f, 1);
-		//glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
 	}
 	glEnable(GL_CULL_FACE);
 	if (r->bindShader(Renderer::srServiceFill, &prog)) {

renderer_service.h

@@ -84,7 +84,6 @@ public:
 
 private:
 	Renderer * r;
-
 	Mesh * axis_mesh, * handle_move_mesh, * handle_rotate_mesh, * handle_scale_mesh;
 	Mesh * handle_ms_2_mesh, * handle_scale_3_mesh;
 	Mesh * box_mesh_f, * omni_mesh_f, * cone_mesh_f, * camera_mesh_f;
@@ -102,7 +101,6 @@ private:
 	QFlags<HandleMesh> current_handle;
 	int line_width;
 	double size_vp_scale, size_full_scale;
-
 };
 
 #endif // RENDERER_SERVICE_H

tonemapping_proc.cpp

@@ -98,7 +98,6 @@ void TonemappingProc::renderSum(Framebuffer & fbo_src, int index) {
 	int pcnt  = fbo_src.width() * fbo_src.height();
 	fbo_src.bindColorTexture(index);
 	fbo_1x1.bind();
-	//glClearFramebuffer(Qt::white, false);
 	glClearFramebuffer();
 	if (shader_sum) {
 		if (shader_sum->isLinked()) {
@@ -117,7 +116,6 @@ void TonemappingProc::renderSum(Framebuffer & fbo_src, int index) {
 		}
 	}
 	fbo_1x1.release();
-	//fbo_src.bind();
 }
 
 
@@ -175,7 +173,6 @@ bool TonemappingProc::process() {
 	}
 	fbomm.create();
 	fbo.queryPoints(0, fbo.rect(), GL_FLOAT);
-	//renderSum(fbomm.plane(fbomm.lastLevel()), 0);
 	return true;
 }
 

tonemapping_proc.h

@@ -49,18 +49,15 @@ private:
 	QMutex mutex;
 	QVector<QVector4D> last_data;
 	QVector<float> last_max;
-
 	float frame_max, cur_max;
 	bool need_render_sum, enabled;
 	std::atomic_bool exit_;
 	int timer_tone, timer_delim;
 	Framebuffer fbo_1x1;
 	FramebufferMipmap fbomm;
-
 	QOpenGLShaderProgram * shader_sum;
 	Buffer buffer_vbo;
 	GLenum vbo_vao;
-
 };
 
 #endif // RENDERER_H