ldforge2: comparison src/layers/edittools.cpp

-:c24d87f64bed
+:4642ba1218e8
 }
 void EditTools::mouseMoved(const QMouseEvent* event)
 {
 	this->worldPosition = this->renderer->screenToModelCoordinates(event->pos(), this->gridPlane);
+	this->localPosition = event->localPos();
 	if (this->worldPosition.has_value())
 	{
 		// Snap the position to grid. This procedure is basically the "change of basis" and almost follows the
 		// A⁻¹ × M × A formula which is used to perform a transformation in some other coordinate system, except
 		// we actually use the inverted matrix first and the regular one last to perform the transformation of
 		this->worldPosition = glm::round(*this->worldPosition);
 		// And finally transform it back to grid coordinates by transforming it with the
 		// grid matrix.
 		this->worldPosition = this->gridMatrix * glm::vec4{*this->worldPosition, 1};
 		this->polygon.back() = *this->worldPosition;
-	}
+		this->numpoints = this->calcNumPoints();
-	this->numpoints = this->polygon.size();
-	if (this->isCloseToExistingPoints()) {
-		this->numpoints -= 1;
 	}
 }
 static QVector<QPointF> convertWorldPointsToScreenPoints(
 	const std::vector<glm::vec3> &worldPoints,
 	case CircleMode:
 		return circleModeActions();
 	}
 }
+constexpr QPointF vecToQPoint(const glm::vec2& a)
+{
+	return {a.x, a.y};
+}
 void EditTools::renderPreview(QPainter* painter, const void* pensptr)
 {
 	const Pens& pens = *reinterpret_cast<const Pens*>(pensptr);
 	painter->setPen(pens.polygonPen);
 	for (const ModelAction& action : this->modelActions()) {
 	painter->setBrush(pens.pointBrush);
 	painter->setPen(pens.pointPen);
 	for (const glm::vec3& point : this->polygon) {
 		drawWorldPoint(painter, point, this->renderer);
 	}
+	if (this->mode == CircleMode and this->polygon.size() >= 2) {
+		const glm::vec3 circleOrigin = this->polygon[0];
+		const QPointF originScreen = this->renderer->modelToScreenCoordinates(circleOrigin);
+		const auto extremity = [this, &originScreen](const glm::vec3& p){
+			const QPointF s2 = this->renderer->modelToScreenCoordinates(p);
+			const auto intersection = rayRectangleIntersection(
+				rayFromPoints(toVec2(originScreen), toVec2(s2)),
+				this->renderer->rect());
+			if (intersection.has_value()) {
+				return intersection->position;
+			}
+			else {
+				return glm::vec2{s2.x(), s2.y()};
+			}
+		};
+		const glm::vec3 zvec = this->gridMatrix[2];
+		const glm::vec2 p1 = extremity(this->polygon[0] + zvec);
+		const glm::vec2 p2 = extremity(this->polygon[0] - zvec);
+		const glm::vec2 lateral = glm::normalize(glm::mat2{{0, 1}, {-1, 0}} * (p2 - p1));
+		painter->setPen(QPen{Qt::white, 3});
+		painter->drawLine(vecToQPoint(p1), vecToQPoint(p2));
+		constexpr float notchsize = 40.0f;
+		for (int a = -30; a <= 30; ++a) {
+			const glm::vec3 notch = this->polygon[0] + static_cast<float>(a) * zvec;
+			const QPointF s_notchcenter = this->renderer->modelToScreenCoordinates(notch);
+			const QPointF notch_s1 = s_notchcenter + notchsize * 0.5f * vecToQPoint(lateral);
+			const QPointF notch_s2 = s_notchcenter - notchsize * 0.5f * vecToQPoint(lateral);
+			painter->drawLine(notch_s1, notch_s2);
+		}
+	}
 }
 void EditTools::removeLastPoint()
 {
 	if (this->polygon.size() > 1) {
 		this->polygon.erase(this->polygon.end() - 2);
+		this->numpoints = this->calcNumPoints();
 	}
 }
 bool EditTools::isCloseToExistingPoints() const
 {
 	else {
 		return false;
 	}
 }
+std::size_t EditTools::calcNumPoints() const
+{
+	std::size_t result = this->polygon.size();
+	if (this->isCloseToExistingPoints()) {
+		result -= 1;
+	}
+	return result;
+}
 EditingMode EditTools::currentEditingMode() const
 {
 	return this->mode;
 }
 			}
 		}
 		break;
 	case CircleMode:
 		if (event->button() == Qt::LeftButton and this->worldPosition.has_value()) {
-			if (this->polygon.size() == 2) {
+			if (this->polygon.size() == 3) {
 				this->closeShape();
 			}
 			else {
 				this->polygon.push_back(*this->worldPosition);
 			}
 const std::vector<ModelAction> EditTools::circleModeActions() const
 {
 	std::vector<ModelAction> result;
-	if (this->numpoints == 2) {
+	if (this->numpoints == 3) {
 		const glm::vec3 x = polygon[1] - polygon[0];
-		glm::mat4 transform{
+		const opt<float> cyliheight = [&]() -> opt<float> {
-			glm::vec4{x, 0},
+			const Plane plane{
-			this->gridMatrix[2],
+				.normal = glm::normalize(this->renderer->cameraVector(this->localPosition)),
-			glm::vec4{glm::cross(glm::vec3{-this->gridMatrix[2]}, x), 0},
+				.anchor = this->polygon[0],
-			glm::vec4{this->polygon[0], 1},
+			};
-		};
+			const opt<glm::vec3> p = this->renderer->screenToModelCoordinates(this->localPosition, plane);
-		Colored<CircularPrimitive> circ{
+			if (p.has_value()) {
-			CircularPrimitive{
+				const glm::vec3 heightvec = glm::normalize(glm::vec3{gridMatrix[2]});
-				.type = this->circleToolOptions.type,
+				return std::round(glm::dot(*p - polygon[0], heightvec));
-				.fraction = this->circleToolOptions.fraction,
+			}
-				.transformation = transform,
+			else {
-			},
+				return {};
-			MAIN_COLOR
+			}
-		};
+		}();
-		result.push_back(AppendToModel{.newElement = circ});
+		if (cyliheight.has_value()) {
+			glm::mat4 transform{
+				glm::vec4{x, 0},
+				*cyliheight * this->gridMatrix[2],
+				glm::vec4{glm::cross(glm::vec3{-this->gridMatrix[2]}, x), 0},
+				glm::vec4{this->polygon[0], 1},
+			};
+			Colored<CircularPrimitive> circ{
+				CircularPrimitive{
+					.type = this->circleToolOptions.type,
+					.fraction = this->circleToolOptions.fraction,
+					.transformation = transform,
+				},
+				MAIN_COLOR
+			};
+			result.push_back(AppendToModel{.newElement = circ});
+		}
 	}
 	return result;
 }
 const std::vector<ModelAction> EditTools::drawModeActions() const

Mercurial > ldforge2 / file comparison

comparison: src/layers/edittools.cpp

src/layers/edittools.cpp