ldforge: comparison src/gldraw.cpp

-:715d9a7f6598
+:d97594e3fc54
 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);
-cfg (Int, gl_camera, GLRenderer::Free);
+cfg (Int, gl_camera, GLRenderer::EFreeCamera);
 cfg (Bool, gl_blackedges, false);
 cfg (Bool, gl_axes, false);
 cfg (Bool, gl_wireframe, false);
 cfg (Bool, gl_logostuds, false);
 cfg (Bool, gl_aa, true);
 	QT_TRANSLATE_NOOP ("GLRenderer",  "Back"),
 	QT_TRANSLATE_NOOP ("GLRenderer",  "Right"),
 	QT_TRANSLATE_NOOP ("GLRenderer",  "Free")
 };
-const GL::Camera g_Cameras[7] =
+const GL::EFixedCamera g_Cameras[7] =
-{	GL::Top,
+{	GL::ETopCamera,
-	GL::Front,
+	GL::EFrontCamera,
-	GL::Left,
+	GL::ELeftCamera,
-	GL::Bottom,
+	GL::EBottomCamera,
-	GL::Back,
+	GL::EBackCamera,
-	GL::Right,
+	GL::ERightCamera,
-	GL::Free
+	GL::EFreeCamera
 };
 const struct LDGLAxis
 {	const QColor col;
 	const vertex vert;
 // =============================================================================
 // -----------------------------------------------------------------------------
 GLRenderer::GLRenderer (QWidget* parent) : QGLWidget (parent)
 {	m_Picking = m_rangepick = false;
-	m_camera = (GL::Camera) gl_camera.value;
+	m_camera = (GL::EFixedCamera) gl_camera.value;
 	m_drawToolTip = false;
-	m_EditMode = Select;
+	m_EditMode = ESelectMode;
 	m_rectdraw = false;
 	m_panning = false;
 	setFile (null);
 	setDrawOnly (false);
 	setMessageLog (null);
 	m_thickBorderPen = QPen (QColor (0, 0, 0, 208), 2, Qt::SolidLine, Qt::RoundCap, Qt::RoundJoin);
 	m_thinBorderPen = m_thickBorderPen;
 	m_thinBorderPen.setWidth (1);
 	// Init camera icons
-	for (const GL::Camera cam : g_Cameras)
+	for (const GL::EFixedCamera cam : g_Cameras)
 	{	str iconname = fmt ("camera-%1", tr (g_CameraNames[cam]).toLower());
 		CameraIcon* info = &m_cameraIcons[cam];
 		info->img = new QPixmap (getIcon (iconname));
 		info->cam = cam;
 void GLRenderer::calcCameraIcons()
 {	int i = 0;
 	for (CameraIcon& info : m_cameraIcons)
 	{	// MATH
-		const long x1 = (m_width - (info.cam != Free ? 48 : 16)) + ((i % 3) * 16) - 1,
+		const long x1 = (m_width - (info.cam != EFreeCamera ? 48 : 16)) + ((i % 3) * 16) - 1,
 			y1 = ((i / 3) * 16) + 1;
 		info.srcRect = QRect (0, 0, 16, 16);
 		info.destRect = QRect (x1, y1, 16, 16);
 		info.selRect = QRect (
 }
 // =============================================================================
 // -----------------------------------------------------------------------------
 void GLRenderer::resetAllAngles()
-{	Camera oldcam = camera();
+{	EFixedCamera oldcam = camera();
 	for (int i = 0; i < 7; ++i)
-	{	setCamera ((Camera) i);
+	{	setCamera ((EFixedCamera) i);
 		resetAngles();
 	}
 	setCamera (oldcam);
 }
 		glPolygonMode (GL_FRONT_AND_BACK, GL_LINE);
 	glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 	glEnable (GL_DEPTH_TEST);
-	if (m_camera != Free)
+	if (m_camera != EFreeCamera)
 	{	glMatrixMode (GL_PROJECTION);
 		glPushMatrix();
 		glLoadIdentity();
 		glOrtho (-m_virtWidth, m_virtWidth, -m_virtHeight, m_virtHeight, -100.0f, 100.0f);
 		glTranslatef (pan (X), pan (Y), 0.0f);
-		if (m_camera != Front && m_camera != Back)
+		if (m_camera != EFrontCamera && m_camera != EBackCamera)
 		{	glRotatef (90.0f, g_FixedCameras[camera()].glrotate[0],
 				g_FixedCameras[camera()].glrotate[1],
 				g_FixedCameras[camera()].glrotate[2]);
 		}
 		// Back camera needs to be handled differently
-		if (m_camera == GLRenderer::Back)
+		if (m_camera == GLRenderer::EBackCamera)
 		{	glRotatef (180.0f, 1.0f, 0.0f, 0.0f);
 			glRotatef (180.0f, 0.0f, 0.0f, 1.0f);
 		}
 	}
 	else
 // -----------------------------------------------------------------------------
 // This converts a 2D point on the screen to a 3D point in the model. If 'snap'
 // is true, the 3D point will snap to the current grid.
 // -----------------------------------------------------------------------------
 vertex GLRenderer::coordconv2_3 (const QPoint& pos2d, bool snap) const
-{	assert (camera() != Free);
+{	assert (camera() != EFreeCamera);
 	vertex pos3d;
 	const LDFixedCameraInfo* cam = &g_FixedCameras[m_camera];
 	const Axis axisX = cam->axisX;
 	const Axis axisY = cam->axisY;
 	// If we wish to only draw the brick, stop here
 	if (isDrawOnly())
 		return;
-	if (m_camera != Free && !isPicking())
+	if (m_camera != EFreeCamera && !isPicking())
 	{	// Paint the overlay image if we have one
 		const LDGLOverlay& overlay = m_overlays[m_camera];
 		if (overlay.img != null)
 		{	QPoint v0 = coordconv3_2 (m_overlays[m_camera].v0),
 		QPen linepen = m_thinBorderPen;
 		linepen.setWidth (2);
 		linepen.setColor (luma (m_bgcolor) < 40 ? Qt::white : Qt::black);
 		// If we're drawing, draw the vertices onto the screen.
-		if (getEditMode() == Draw)
+		if (getEditMode() == EDrawMode)
 		{	int numverts = 4;
 			if (!m_rectdraw)
 				numverts = m_drawedVerts.size() + 1;
 					// Draw their coordinates
 					paint.drawText (blip.x(), blip.y() - 8, polyverts[i].stringRep (true));
 				}
 			}
 		}
-		elif (getEditMode() == CircleMode)
+		elif (getEditMode() == ECircleMode)
 		{	// If we have not specified the center point of the circle yet, preview it on the screen.
 			if (m_drawedVerts.isEmpty())
 				drawBlip (paint, coordconv3_2 (m_hoverpos));
 			else
 			{	QVector<vertex> verts, verts2;
 		paint.drawRect (m_cameraIcons[camera()].selRect);
 		// Draw the actual icons
 		for (CameraIcon& info : m_cameraIcons)
 		{	// Don't draw the free camera icon when in draw mode
-			if (&info == &m_cameraIcons[GL::Free] && getEditMode() != Select)
+			if (&info == &m_cameraIcons[GL::EFreeCamera] && getEditMode() != ESelectMode)
 				continue;
 			paint.drawPixmap (info.destRect, *info.img, info.srcRect);
 		}
 // =============================================================================
 // -----------------------------------------------------------------------------
 void GLRenderer::addDrawnVertex (vertex pos)
 {	// If we picked an already-existing vertex, stop drawing
-	if (getEditMode() != CircleMode)
+	if (getEditMode() != ECircleMode)
 	{	for (vertex& vert : m_drawedVerts)
 		{	if (vert == pos)
 			{	endDraw (true);
 				return;
 			}
 				}
 			}
 		}
 		switch (getEditMode())
-		{	case Draw:
+		{	case EDrawMode:
 			{	if (m_rectdraw)
 				{	if (m_drawedVerts.size() == 2)
 					{	endDraw (true);
 						return;
 					}
 				}
 				addDrawnVertex (m_hoverpos);
 			} break;
-			case CircleMode:
+			case ECircleMode:
 			{	if (m_drawedVerts.size() == 3)
 				{	endDraw (true);
 					return;
 				}
 				addDrawnVertex (m_hoverpos);
 			} break;
-			case Select:
+			case ESelectMode:
 			{	if (!isDrawOnly())
 				{	if (m_totalmove < 10)
 						m_rangepick = false;
 					if (!m_rangepick)
 		}
 		m_rangepick = false;
 	}
-	if (wasMid && getEditMode() != Select && m_drawedVerts.size() < 4 && m_totalmove < 10)
+	if (wasMid && getEditMode() != ESelectMode && m_drawedVerts.size() < 4 && m_totalmove < 10)
 	{	// Find the closest vertex to our cursor
 		double mindist = 1024.0f;
 		vertex closest;
 		bool valid = false;
 	if (mid || (left && shift))
 	{	pan (X) += 0.03f * dx * (zoom() / 7.5f);
 		pan (Y) -= 0.03f * dy * (zoom() / 7.5f);
 		m_panning = true;
-	} elif (left && !m_rangepick && camera() == Free)
+	} elif (left && !m_rangepick && camera() == EFreeCamera)
 	{	rot (X) = rot (X) + dy;
 		rot (Y) = rot (Y) + dx;
 		clampAngle (rot (X));
 		clampAngle (rot (Y));
 	// Update 2d position
 	m_pos = ev->pos();
 	m_globalpos = ev->globalPos();
 	// Calculate 3d position of the cursor
-	m_hoverpos = (camera() != Free) ? coordconv2_3 (m_pos, true) : g_origin;
+	m_hoverpos = (camera() != EFreeCamera) ? coordconv2_3 (m_pos, true) : g_origin;
 	// Update rect vertices since m_hoverpos may have changed
 	updateRectVerts();
 	update();
 {	g_win->spawnContextMenu (ev->globalPos());
 }
 // =============================================================================
 // -----------------------------------------------------------------------------
-void GLRenderer::setCamera (const GL::Camera cam)
+void GLRenderer::setCamera (const GLRenderer::EFixedCamera cam)
 {	m_camera = cam;
 	gl_camera = (int) cam;
 	g_win->updateEditModeActions();
 }
 // -----------------------------------------------------------------------------
 void GLRenderer::setEditMode (EditMode const& a)
 {	m_EditMode = a;
 	switch (a)
-	{	case Select:
+	{	case ESelectMode:
 		{	unsetCursor();
 			setContextMenuPolicy (Qt::DefaultContextMenu);
 		} break;
-		case Draw:
+		case EDrawMode:
-		case CircleMode:
+		case ECircleMode:
 		{	// Cannot draw into the free camera - use top instead.
-			if (m_camera == Free)
+			if (m_camera == EFreeCamera)
-				setCamera (Top);
+				setCamera (ETopCamera);
 			// Disable the context menu - we need the right mouse button
 			// for removing vertices.
 			setContextMenuPolicy (Qt::NoContextMenu);
 	// Clean the selection and create the object
 	QList<vertex>& verts = m_drawedVerts;
 	QList<LDObject*> objs;
 	switch (getEditMode())
-	{	case Draw:
+	{	case EDrawMode:
 		{	if (m_rectdraw)
 			{	LDQuad* quad = new LDQuad;
 				// Copy the vertices from m_rectverts
 				updateRectVerts();
 					} break;
 				}
 			}
 		} break;
-		case CircleMode:
+		case ECircleMode:
 		{	const int segs = lores, divs = lores; // TODO: make customizable
 			double dist0 = getCircleDrawDist (0),
 				dist1 = getCircleDrawDist (1);
 			LDFile* refFile = null;
 			matrix transform;
 				ref->setColor (maincolor);
 				objs << ref;
 			}
 		} break;
-		case Select:
+		case ESelectMode:
 		{	// this shouldn't happen
 			assert (false);
 			return;
 		} break;
 	}
 	obj->m_glinit = false;
 }
 // =============================================================================
 // -----------------------------------------------------------------------------
-Axis GLRenderer::getCameraAxis (bool y, GL::Camera camid)
+Axis GLRenderer::getCameraAxis (bool y, GLRenderer::EFixedCamera camid)
-{	if (camid == (GL::Camera) - 1)
+{	if (camid == (GL::EFixedCamera) - 1)
 		camid = m_camera;
 	const LDFixedCameraInfo* cam = &g_FixedCameras[camid];
 	return (y) ? cam->axisY : cam->axisX;
 }
 // =============================================================================
 // -----------------------------------------------------------------------------
-bool GLRenderer::setupOverlay (GL::Camera cam, str file, int x, int y, int w, int h)
+bool GLRenderer::setupOverlay (EFixedCamera cam, str file, int x, int y, int w, int h)
 {	QImage* img = new QImage (file);
 	LDGLOverlay& info = getOverlay (cam);
 	if (img->isNull())
 	{	critical (tr ("Failed to load overlay image!"));
 }
 // =============================================================================
 // -----------------------------------------------------------------------------
 void GLRenderer::clearOverlay()
-{	if (camera() == Free)
+{	if (camera() == EFreeCamera)
 		return;
 	LDGLOverlay& info = m_overlays[camera()];
 	delete info.img;
 	info.img = null;
 }
 // =============================================================================
 // -----------------------------------------------------------------------------
 void GLRenderer::setDepthValue (double depth)
-{	assert (camera() < Free);
+{	assert (camera() < EFreeCamera);
 	m_depthValues[camera()] = depth;
 }
 // =============================================================================
 // -----------------------------------------------------------------------------
 double GLRenderer::getDepthValue() const
-{	assert (camera() < Free);
+{	assert (camera() < EFreeCamera);
 	return m_depthValues[camera()];
 }
 // =============================================================================
 // -----------------------------------------------------------------------------
 }
 // =============================================================================
 // -----------------------------------------------------------------------------
 void GLRenderer::zoomAllToFit()
-{	Camera oldcam = camera();
+{	EFixedCamera oldcam = camera();
 	for (int i = 0; i < 7; ++i)
-	{	setCamera ((Camera) i);
+	{	setCamera ((EFixedCamera) i);
 		zoomToFit();
 	}
 	setCamera (oldcam);
 }
 }
 // =============================================================================
 // -----------------------------------------------------------------------------
 void GLRenderer::mouseDoubleClickEvent (QMouseEvent* ev)
-{	if (!(ev->buttons() & Qt::LeftButton) || getEditMode() != Select)
+{	if (!(ev->buttons() & Qt::LeftButton) || getEditMode() != ESelectMode)
 		return;
 	pick (ev->x(), ev->y());
 	if (selection().isEmpty())
 	ev->accept();
 }
 // =============================================================================
 // -----------------------------------------------------------------------------
-LDOverlay* GLRenderer::findOverlayObject (GLRenderer::Camera cam)
+LDOverlay* GLRenderer::findOverlayObject (EFixedCamera cam)
 {	LDOverlay* ovlobj = null;
 	for (LDObject * obj : getFile()->getObjects())
 	{	if (obj->getType() == LDObject::Overlay && static_cast<LDOverlay*> (obj)->getCamera() == cam)
 		{	ovlobj = static_cast<LDOverlay*> (obj);
 // =============================================================================
 // -----------------------------------------------------------------------------
 // Read in overlays from the current file and update overlay info accordingly.
 // -----------------------------------------------------------------------------
 void GLRenderer::initOverlaysFromObjects()
-{	for (Camera cam : g_Cameras)
+{	for (EFixedCamera cam : g_Cameras)
-	{	if (cam == Free)
+	{	if (cam == EFreeCamera)
 			continue;
 		LDGLOverlay& meta = m_overlays[cam];
 		LDOverlay* ovlobj = findOverlayObject (cam);
 }
 // =============================================================================
 // -----------------------------------------------------------------------------
 void GLRenderer::updateOverlayObjects()
-{	for (Camera cam : g_Cameras)
+{	for (EFixedCamera cam : g_Cameras)
-	{	if (cam == Free)
+	{	if (cam == EFreeCamera)
 			continue;
 		LDGLOverlay& meta = m_overlays[cam];
 		LDOverlay* ovlobj = findOverlayObject (cam);

Mercurial > ldforge / file comparison

comparison: src/gldraw.cpp

src/gldraw.cpp