git-svn-id: svn://db.shs.com.ru/libs@627 a8b55f48-bf90-11e4-a774-851b48703e85

qglengine/renderer_selection.cpp

@@ -0,0 +1,184 @@
+/*
+    QGLView
+    Copyright (C) 2019  Ivan Pelipenko peri4ko@yandex.ru
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU 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 General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#define GL_GLEXT_PROTOTYPES
+#include <QOpenGLExtraFunctions>
+#include "renderer_selection.h"
+#include "qglview.h"
+#include "glmesh.h"
+#include <qad_types.h>
+
+using namespace QGLEngineShaders;
+
+
+RendererSelection::RendererSelection(Renderer * r_): r(r_),
+		fbo_selection(r->view, 4) {
+	sel_frame = Primitive::plane(2., 2.);
+	id_hover = 0;
+	line_thick_ = 2.;
+}
+
+
+RendererSelection::~RendererSelection() {
+	delete sel_frame;
+}
+
+
+void RendererSelection::init(int width, int height) {
+	resize(width, height);
+}
+
+
+void RendererSelection::resize(int width, int height) {
+	fbo_selection.enablePixelBuffer();
+	fbo_selection.resize(width, height);
+	line_thick_ = lineThickness() + 1.;
+}
+
+
+void RendererSelection::generateObjectsID(Scene & scene) {
+	ids.clear();
+	QMapIterator<Mesh*, QList<ObjectBase*> > it(scene.geometries_used);
+	while (it.hasNext()) {
+		it.next();
+		foreach (ObjectBase * o, it.value()) {
+			uint id = qHash(o);
+			ids[id] = o;
+			o->id_ = id;
+		}
+	}
+	foreach (ObjectBase * o, scene.lights_used) {
+		uint id = qHash(o);
+		ids[id] = o;
+		o->id_ = id;
+	}
+}
+
+
+void RendererSelection::fillSelectionsBuffer(const QList<ObjectBase *> & ol) {
+	cur_selections_.resize(ol.size());
+	for (int i = 0; i < ol.size(); ++i) {
+		cur_selections_[i] = (ol[i]->isSelected(true) ? 1 : 0);
+	}
+}
+
+
+void RendererSelection::renderSelection(Scene & scene) {
+	QOpenGLShaderProgram * prog = 0;
+	QGLView * view = r->view;
+	if (r->bindShader(Renderer::srSelectionFill, &prog)) {
+		view->hov_objects.clear();
+		id_hover = 0;
+		if (fbo_selection.queriedPoints() > 0) {
+			if (fbo_selection.queriedPoints() == 1) {
+				id_hover = fbo_selection.getPoint();
+				view->hov_objects.resize(1);
+				view->hov_objects[0] = ids.value(id_hover);
+				//qDebug() << id_hover;
+			} else {
+				QVector<uint> points = fbo_selection.getPoints();
+				QSet<uint> ids_hover;
+				foreach (uint i, points)
+					ids_hover << i;
+				view->hov_objects.clear();
+				foreach (uint i, ids_hover)
+					view->hov_objects << ids.value(i);
+				//qDebug() << ids_hover;
+			}
+		}
+
+		fbo_selection.bind();
+
+		fbo_selection.setWriteBuffers();
+		glEnableDepth();
+		glClearFramebuffer(QColor(0,0,0,0));
+		r->setUniformCamera(prog, view->camera());
+		r->renderObjects(scene, Renderer::rpSelection);
+		view->glClear(GL_DEPTH_BUFFER_BIT);
+
+		RendererService & rs(r->rend_service);
+		rs.fillOmniObjects();
+		rs.omni_mesh->loadObjects(view, rs.cur_objects);
+		fillSelectionsBuffer(light2objectList(scene.lights_used));
+		rs.omni_mesh->loadSelections(view, cur_selections_);
+		rs.omni_mesh->draw(view, rs.cur_objects.size());
+
+		//mouse_rect = fbo_selection.rect();
+		if (r->mouse_rect.isNull())
+			fbo_selection.queryPoint(0, r->mouse_pos);
+		else
+			fbo_selection.queryPoints(0, r->mouse_rect);
+
+		//qDebug() << id_hover;
+		fbo_selection.bindColorTextures();
+		fbo_selection.setWriteBuffers();
+		if (!view->hoverHalo_ && !view->selectionHalo_)
+			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_selection", view->selectionHalo_ ? 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,
+														float((id_hover >> 8 ) & 0xFF) / 255.f,
+														float((id_hover >> 16) & 0xFF) / 255.f,
+														float((id_hover >> 24) & 0xFF) / 255.f));
+			r->renderQuad(prog, r->quad, view->camera());
+		}
+
+		fbo_selection.release();
+	}
+}
+
+
+void RendererSelection::renderSelectionFrame() {
+	QOpenGLShaderProgram * prog = 0;
+	if (r->bindShader(Renderer::srSelectionFrame, &prog)) {
+		QMatrix4x4 mat;
+		double mrx = r->mouse_rect.x(), mrw = r->mouse_rect.width() , vw = r->view->width();
+		double mry = r->mouse_rect.y(), mrh = r->mouse_rect.height(), vh = r->view->height();
+		mat.translate(-1. + (mrw + mrx*2) / vw, 1. - (mrh + mry*2) / vh, 0.);
+		mat.scale(mrw / vw, mrh / vh, 0.);
+		r->initQuad(sel_frame, mat);
+		prog->setUniformValue("size", QVector2D(mrw / vw, mrh / vh));
+		prog->setUniformValue("thickness", line_thick_);
+		glEnable(GL_BLEND);
+		glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+		r->renderQuad(prog, sel_frame);
+		glDisable(GL_BLEND);
+	}
+}
+
+
+void RendererSelection::drawSelection(Framebuffer & fbo_out, int index_out) {
+	QOpenGLShaderProgram * prog = 0;
+	if (r->bindShader(Renderer::srSelectionApply, &prog)) {
+		fbo_selection.bindColorTextures();
+		fbo_out.bindColorTexture(index_out);
+		prog->setUniformValue("fb_out"   , 0);
+		prog->setUniformValue("fb_hover" , (int)sbrHovered );
+		prog->setUniformValue("fb_select", (int)sbrSelected);
+		r->renderQuad(prog, r->quad, r->view->camera());
+		if (!r->mouse_rect.isNull()) {
+			renderSelectionFrame();
+		}
+	}
+}