ldforge2: comparison src/gl/partrenderer.cpp

-:0f221121849b
+:4585d8d7a7ec
 	QWidget* parent) :
 	QOpenGLWidget{parent},
 	model{model},
 	documents{documents},
 	colorTable{colorTable},
-	compiler{new gl::Compiler{this->colorTable, this}},
+	compiler{new gl::Compiler{this->colorTable, this}}
-	gridProgram{this}
 {
 	this->setMouseTracking(true);
 }
 PartRenderer::~PartRenderer()
 {
 }
 static QVector3D vec3FromQColor(const QColor& color)
 {
-	return {(float)color.redF(), (float)color.greenF(), (float)color.blueF()};
+	return {
+		toFloat(color.redF()),
+		toFloat(color.greenF()),
+		toFloat(color.blueF()),
+	};
 }
 void PartRenderer::initializeGL()
 {
 	this->initializeOpenGLFunctions();
 	if (glGetError() != GL_NO_ERROR)
 	{
 		abort();
 	}
-	this->gridProgram.emplace(this);
-	this->gridProgram->initialize();
 	this->compiler->initialize();
 	this->compiler->build(this->model, this->documents, this->renderPreferences);
 	this->initialized = true;
 	this->modelQuaternion = glm::angleAxis(glm::radians(30.0f), glm::vec3{-1, 0, 0});
 	this->modelQuaternion *= glm::angleAxis(glm::radians(225.0f), glm::vec3{-0, 1, 0});
 		glm::radians(45.0f),
 		static_cast<float>(width) / static_cast<float>(height),
 		0.1f,
 		10000.f);
 	this->compiler->setUniformMatrix("projectionMatrix", this->projectionMatrix);
-	this->gridProgram->setProjectionMatrix(this->projectionMatrix);
+	emit projectionMatrixChanged();
 }
 static GLenum getGlTypeForArrayClass(const gl::ArrayClass vboClass)
 {
 	switch (vboClass)
 		glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
 		this->setFragmentStyle(gl::FragmentStyle::Normal);
 		this->renderAllArrays();
 		break;
 	}
-	glEnable(GL_BLEND);
-	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
-	this->gridProgram->draw();
-	glDisable(GL_BLEND);
 	glDisable(GL_POLYGON_OFFSET_FILL);
 }
 void PartRenderer::renderAllArrays()
 {
 {
 	// I'm not quite sure why using the exponent function on the zoom factor causes linear zoom behavior
 	const double z  = 2 * std::exp(this->zoom) * (1 + this->compiler->modelDistance());
 	this->viewMatrix = glm::lookAt(glm::vec3{0, 0, z}, {0, 0, 0}, {0, -1, 0});
 	this->compiler->setUniformMatrix("viewMatrix", this->viewMatrix);
-	this->gridProgram->setViewMatrix(this->viewMatrix);
+	emit this->viewMatrixChanged();
 }
 void PartRenderer::updateModelMatrix()
 {
-	const glm::mat4 modelMatrix = glm::mat4_cast(this->modelQuaternion);
+	this->modelMatrix = glm::mat4_cast(this->modelQuaternion);
 	this->compiler->setUniformMatrix("modelMatrix", modelMatrix);
-	this->gridProgram->setModelMatrix(modelMatrix);
+	emit this->modelMatrixChanged();
 	this->update();
 }
 void PartRenderer::setupBackgroundColor()
 {
-	if (this->gridProgram.has_value())
-	{
-		const bool isDark = luma(this->renderPreferences.backgroundColor) < 0.25;
-		this->gridProgram->setGridColor(isDark ? Qt::white : Qt::black);
-	}
 }
 void PartRenderer::renderVao(const gl::ArrayClass arrayClass)
 {
 	this->compiler->bindVertexArray(arrayClass);
 }
 void PartRenderer::mouseMoveEvent(QMouseEvent* event)
 {
 	const bool left = event->buttons() & Qt::LeftButton;
-	const QPointF move = pointToPointF(event->pos()) - this->lastMousePosition;
+	const QPoint move = event->pos() - this->lastMousePosition;
 	if (left and not move.isNull())
 	{
 		// q_x is the rotation of the brick along the vertical y-axis, because turning the
 		// vertical axis causes horizontal (=x) rotation. Likewise q_y is the rotation of the
 		// brick along the horizontal x-axis, which causes vertical rotation.
 		const glm::quat q_x = glm::angleAxis(scalar * move_x, glm::vec3{0, -1, 0});
 		const glm::quat q_y = glm::angleAxis(scalar * move_y, glm::vec3{-1, 0, 0});
 		this->modelQuaternion = q_x * q_y * this->modelQuaternion;
 		this->updateModelMatrix();
 	}
-	this->lastMousePosition = pointToPointF(event->pos());
+	this->lastMousePosition = event->pos();
 }
 void PartRenderer::wheelEvent(QWheelEvent* event)
 {
 	static constexpr double WHEEL_STEP = 1 / 1000.0;
 	const double move = (-event->angleDelta().y()) * WHEEL_STEP;
 	this->zoom = std::clamp(this->zoom + move, MIN_ZOOM, MAX_ZOOM);
 	this->updateViewMatrix();
 	this->update();
-}
-glm::vec3 PartRenderer::viewport(const glm::vec3& point)
-{
-	return viewport(point, this->width(), this->height());
 }
 /**
 * @brief Converts the specified on the screen into the 3D world. The point is unprojected twice into 3D and the
 * intersection of the resulting line with the specified plane is returned. If the intersection point lies behind
 * @param plane Plane to raycast against
 * @return world co-ordinates, or no value if the point is behind the camera.
 */
 std::optional<glm::vec3> PartRenderer::screenToModelCoordinates(const QPoint& point, const geom::Plane& plane)
 {
-	auto p1 = this->unproject({point.x(), point.y(), 0});
+	const glm::vec3 p1 = this->unproject({point.x(), point.y(), 0});
-	auto p2 = this->unproject({point.x(), point.y(), 1});
+	const glm::vec3 p2 = this->unproject({point.x(), point.y(), 1});
-	geom::Line line = geom::lineFromPoints(p1, p2);
+	const geom::Line line = geom::lineFromPoints(p1, p2);
 	std::optional<glm::vec3> result;
 	result = geom::linePlaneIntersection(line, plane, 0.01f);
 	// If the point lies behind the camera, do not return a result.
 	if (result.has_value() and glm::dot(line.direction, *result - p1) < 0)
 	{
 	if (mainColorChanged or backgroundColorChanged)
 	{
 		this->compiler->build(this->model, this->documents, this->renderPreferences);
 		this->setupBackgroundColor();
 	}
-	this->update();
+	emit this->renderPreferencesChanged();
-}
+	this->update();
+}
-glm::vec3 PartRenderer::viewport(const glm::vec3& point, float width, float height)
-{
-	return {
-		width * 0.5 * (point.x + 1),
-		height * 0.5 * (-point.y + 1),
-		0
-	};
-}

Mercurial > ldforge2 / file comparison

comparison: src/gl/partrenderer.cpp

src/gl/partrenderer.cpp