ldforge: comparison src/gldraw.cpp

-:7d1b5ecd76c0
+:e964085e6913
 	{{ -1,  0, 0 }, X, Z, false,  true },
 	{{  0,  0, 0 }, X, Y,  true,  true },
 	{{  0, -1, 0 }, Z, Y, false,  true },
 };
+static const matrix g_circleDrawTransforms[3] = {
+	{ 2, 0, 0, 0, 1, 0, 0, 0, 2 },
+	{ 2, 0, 0, 0, 0, 2, 0, 1, 0 },
+	{ 0, 1, 0, 2, 0, 0, 0, 0, 2 },
+};
 cfg (String, gl_bgcolor, "#CCCCD9");
 cfg (String, gl_maincolor, "#707078");
 cfg (Float, gl_maincolor_alpha, 1.0);
 cfg (Int, gl_linethickness, 2);
 cfg (Bool, gl_colorbfc, false);
 		paint.drawText (m_width - textSize.width(), m_height - 16, textSize.width(),
 			textSize.height(), Qt::AlignCenter, text);
 		// If we're drawing, draw the vertices onto the screen.
 		if (editMode() == Draw) {
-			const short blipsize = 8;
 			int numverts = 4;
 			if (!m_rectdraw)
 				numverts = m_drawedVerts.size() + 1;
 				paint.setPen (pen);
 				paint.setBrush (QColor (64, 192, 0, 128));
 				paint.drawPolygon (poly, numverts);
 				// Draw vertex blips
-				pen = m_thinBorderPen;
+				for (int i = 0; i < numverts; ++i) {
-				pen.setWidth (1);
-				paint.setPen (pen);
-				paint.setBrush (QColor (64, 192, 0));
-				for (ushort i = 0; i < numverts; ++i) {
 					QPoint& blip = poly[i];
-					paint.drawEllipse (blip.x() - blipsize / 2, blip.y() - blipsize / 2,
+					drawBlip (paint, blip);
-						blipsize, blipsize);
 					// Draw their coordinates
 					paint.drawText (blip.x(), blip.y() - 8, polyverts[i].stringRep (true));
 				}
+			}
+		}
+		elif (editMode() == CircleMode)
+		{	// If we have not specified the center point of the circle yet, preview it on the screen.
+			if (m_drawedVerts.size() == 0)
+				drawBlip (paint, coordconv3_2 (m_hoverpos));
+			else
+			{	QVector<vertex> verts;
+				const double dist = circleDrawDist();
+				const int segs = lores;
+				const double angleUnit = (2 * pi) / segs;
+				Axis relX, relY;
+				getRelativeAxes (relX, relY);
+				for (int i = 0; i < segs; ++i)
+				{	vertex v = g_origin;
+					v[relX] = m_drawedVerts[0][relX] + (cos (i * angleUnit) * dist);
+					v[relY] = m_drawedVerts[0][relY] + (sin (i * angleUnit) * dist);
+					verts << v;
+				}
+				QVector<QPoint> points;
+				for (const vertex& v : verts)
+				{	QPoint point = coordconv3_2 (v);
+					drawBlip (paint, point);
+					points << point;
+				}
+				QPen pen = m_thinBorderPen;
+				pen.setWidth (2);
+				pen.setColor (luma (m_bgcolor) < 40 ? Qt::white : Qt::black);
+				paint.setPen (pen);
+				paint.setBrush (Qt::NoBrush);
+				paint.drawPolygon (QPolygon (points));
 			}
 		}
 	}
 	// Camera icons
 		paint.setPen (m_thickBorderPen);
 		paint.setBrush (QBrush (fillColor));
 		paint.drawRect (rect);
 	}
+}
+// =============================================================================
+// -----------------------------------------------------------------------------
+void GLRenderer::drawBlip (QPainter& paint, QPoint pos) const
+{	QPen pen = m_thinBorderPen;
+	const int blipsize = 8;
+	pen.setWidth (1);
+	paint.setPen (pen);
+	paint.setBrush (QColor (64, 192, 0));
+	paint.drawEllipse (pos.x() - blipsize / 2, pos.y() - blipsize / 2, blipsize, blipsize);
 }
 // =============================================================================
 // -----------------------------------------------------------------------------
 QColor GLRenderer::getTextPen () const {
 				}
 			}
 			addDrawnVertex (m_hoverpos);
 			break;
+		case CircleMode:
+			if (m_drawedVerts.size() == 2)
+			{	endDraw (true);
+				return;
+			}
+			addDrawnVertex (m_hoverpos);
+			break;
 		case Select:
 			if (!drawOnly()) {
 				if (m_totalmove < 10)
 					m_rangepick = false;
 			if (distsq < mindist) {
 				mindist = distsq;
 				closest = pos3d;
 				valid = true;
-				/* If it's only 4 pixels away, I think we found our vertex now. */
+				// If it's only 4 pixels away, I think we found our vertex now.
 				if (distsq <= 16.0f) // 4.0f ** 2
 					break;
 			}
 		}
 		unsetCursor();
 		setContextMenuPolicy (Qt::DefaultContextMenu);
 		break;
 	case Draw:
+	case CircleMode:
 		// Cannot draw into the free camera - use top instead.
 		if (m_camera == Free)
 			setCamera (Top);
 		// Disable the context menu - we need the right mouse button
 	(void) accept;
 	// Clean the selection and create the object
 	List<vertex>& verts = m_drawedVerts;
 	LDObject* obj = null;
-	if (m_rectdraw) {
+	switch (editMode())
-		LDQuad* quad = new LDQuad;
+	{	case Draw:
+		if (m_rectdraw) {
-		// Copy the vertices from m_rectverts
+			LDQuad* quad = new LDQuad;
-		updateRectVerts();
+			// Copy the vertices from m_rectverts
-		for (int i = 0; i < quad->vertices(); ++i)
+			updateRectVerts();
-			quad->setVertex (i, m_rectverts[i]);
+			for (int i = 0; i < quad->vertices(); ++i)
-		quad->setColor (maincolor);
+				quad->setVertex (i, m_rectverts[i]);
-		obj = quad;
-	} else {
+			quad->setColor (maincolor);
-		switch (verts.size()) {
+			obj = quad;
-		case 1:
+		} else {
-			// 1 vertex - add a vertex object
+			switch (verts.size()) {
-			obj = new LDVertex;
+			case 1:
-			static_cast<LDVertex*> (obj)->pos = verts[0];
+				// 1 vertex - add a vertex object
-			obj->setColor (maincolor);
+				obj = new LDVertex;
-			break;
+				static_cast<LDVertex*> (obj)->pos = verts[0];
+				obj->setColor (maincolor);
-		case 2:
+				break;
-			// 2 verts - make a line
-			obj = new LDLine (verts[0], verts[1]);
+			case 2:
-			obj->setColor (edgecolor);
+				// 2 verts - make a line
-			break;
+				obj = new LDLine (verts[0], verts[1]);
+				obj->setColor (edgecolor);
-		case 3:
+				break;
-		case 4:
-			obj = (verts.size() == 3) ?
+			case 3:
-				static_cast<LDObject*> (new LDTriangle) :
+			case 4:
-				static_cast<LDObject*> (new LDQuad);
+				obj = (verts.size() == 3) ?
+					static_cast<LDObject*> (new LDTriangle) :
-			obj->setColor (maincolor);
+					static_cast<LDObject*> (new LDQuad);
-			for (ushort i = 0; i < obj->vertices(); ++i)
-				obj->setVertex (i, verts[i]);
+				obj->setColor (maincolor);
-			break;
+				for (ushort i = 0; i < obj->vertices(); ++i)
-		}
+					obj->setVertex (i, verts[i]);
-	}
+				break;
+			}
+		}
+		break;
+		case CircleMode:
+		{	const staticCameraMeta* cam = &g_staticCameras[m_camera];
+			const double dist = circleDrawDist();
+			matrix transform = g_circleDrawTransforms[camera() % 3];
+			for (int i = 0; i < 9; ++i)
+			{	if (transform[i] == 2)
+					transform[i] = dist;
+				elif (transform[i] == 1 && camera() >= 3)
+					transform[i] = -1;
+			}
+			LDSubfile* ref = new LDSubfile;
+			ref->setFileInfo (findLoadedFile ("4-4edge.dat"));
+			ref->setTransform (transform);
+			ref->setPosition (m_drawedVerts[0]);
+			ref->setColor (maincolor);
+			obj = ref;
+		}
+		break;
+		case Select:
+		assert (false);
+		return;
+	}
 	if (obj) {
 		g_win->beginAction (null);
 		file()->addObject (obj);
 		compileObject (obj);
 		g_win->fullRefresh();
 		g_win->endAction();
 	}
 	m_drawedVerts.clear();
 	m_rectdraw = false;
+}
+// =============================================================================
+// -----------------------------------------------------------------------------
+double GLRenderer::circleDrawDist() const
+{	assert (m_drawedVerts.size() >= 1);
+	const vertex& v1 = (m_drawedVerts.size() == 2) ? m_drawedVerts[1] : m_hoverpos;
+	Axis relX, relY;
+	getRelativeAxes (relX, relY);
+	const double dx = m_drawedVerts[0][relX] - v1[relX];
+	const double dy = m_drawedVerts[0][relY] - v1[relY];
+	return sqrt ((dx * dx) + (dy * dy));
+}
+// =============================================================================
+// -----------------------------------------------------------------------------
+void GLRenderer::getRelativeAxes (Axis& relX, Axis& relY) const
+{	const staticCameraMeta* cam = &g_staticCameras[m_camera];
+	relX = cam->axisX;
+	relY = cam->axisY;
 }
 // =============================================================================
 // -----------------------------------------------------------------------------
 static List<vertex> getVertices (LDObject* obj) {

Mercurial > ldforge / file comparison

comparison: src/gldraw.cpp

src/gldraw.cpp