ldforge: comparison src/gldraw.cpp

-:6e80f038e8df
+:c4b96bc41298
 	{ { -1, 0, 0 }, X, Z, false, true },
 	{ { 0, 0, 0 }, X, Y, true, true },
 	{ { 0, -1, 0 }, Z, Y, false, true },
 };
-overlayMeta g_overlays[6];
-double g_depthValues[6];
 cfg (str, gl_bgcolor, "#CCCCD9");
 cfg (str, gl_maincolor, "#707078");
 cfg (float, gl_maincolor_alpha, 1.0);
 cfg (int, gl_linethickness, 2);
 cfg (bool, gl_colorbfc, true);
 		info->img = new QPixmap (getIcon (iconname));
 		info->cam = cam;
 	}
 	for (int i = 0; i < 6; ++i) {
-		g_overlays[i].img = null;
+		m_overlays[i].img = null;
-		g_depthValues[i] = 0.0f;
+		m_depthValues[i] = 0.0f;
 	}
 	calcCameraIcons ();
 }
 GLRenderer::~GLRenderer () {
 	for (CameraIcon& info : g_CameraIcons)
 		delete info.img;
 	for (int i = 0; i < 6; ++i)
-		delete g_overlays[i].img;
+		delete m_overlays[i].img;
 }
 // =============================================================================
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 // =============================================================================
 	QFontMetrics metrics = QFontMetrics (QFont ());
 	paint.setRenderHint (QPainter::HighQualityAntialiasing);
 	if (m_camera != Free) {
 		// Paint the overlay image if we have one
-		const overlayMeta& overlay = g_overlays[m_camera];
+		const overlayMeta& overlay = m_overlays[m_camera];
 		if (overlay.img != null) {
-			QPoint v0 = coordconv3_2 (g_overlays[m_camera].v0),
+			QPoint v0 = coordconv3_2 (m_overlays[m_camera].v0),
-				v1 = coordconv3_2 (g_overlays[m_camera].v1);
+				v1 = coordconv3_2 (m_overlays[m_camera].v1);
 			QRect targRect (v0.x (), v0.y (), abs (v1.x () - v0.x ()), abs (v1.y () - v0.y ())),
 				srcRect (0, 0, overlay.img->width (), overlay.img->height ());
 			paint.drawImage (targRect, *overlay.img, srcRect);
 		}
 		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 (m_editMode == Draw) {
+		if (editMode () == Draw) {
 			ushort numverts;
 			if (!m_rectdraw)
 				numverts = m_drawedVerts.size () + 1;
 			else
 		break;
 	case LDObject::Radial:
 		{
 			LDRadial* rad = static_cast<LDRadial*> (obj);
-			std::vector<LDObject*> objs = rad->decompose (true);
+			vector<LDObject*> objs = rad->decompose (true);
 			bool oldinvert = g_glInvert;
 			if (rad->transform.determinant () < 0)
 				g_glInvert = !g_glInvert;
 		return;
 	}
 	if (wasRight && m_drawedVerts.size () > 0) {
 		// Remove the last vertex
-		m_drawedVerts.erase (m_drawedVerts.end () - 1);
+		m_drawedVerts.erase (m_drawedVerts.size () - 1);
 		if (m_drawedVerts.size () == 0)
 			m_rectdraw = false;
 		update ();
 	// Use particularly thick lines while picking ease up selecting lines.
 	glLineWidth (max<double> (gl_linethickness, 6.5f));
 	// Clear the selection if we do not wish to add to it.
 	if (!m_addpick) {
-		std::vector<LDObject*> oldsel = g_win->sel ();
+		vector<LDObject*> oldsel = g_win->sel ();
 		g_win->sel ().clear ();
 		for (LDObject* obj : oldsel) {
 			obj->setSelected (false);
 			compileObject (obj);
 		if (!m_rangepick && m_addpick) {
 			bool removed = false;
 			for (ulong i = 0; i < g_win->sel ().size(); ++i) {
 				if (g_win->sel ()[i] == obj) {
-					g_win->sel ().erase (g_win->sel ().begin () + i);
+					g_win->sel ().erase (i);
 					obj->setSelected (false);
 					removed = true;
 					removedObj = obj;
 				}
 			}
 	delete[] pixeldata;
 	// Remove duplicate entries. For this to be effective, the vector must be
 	// sorted first.
-	std::vector<LDObject*>& sel = g_win->sel ();
+	vector<LDObject*>& sel = g_win->sel ();
-	std::sort (sel.begin(), sel.end ());
+	std::sort (sel.begin (), sel.end ());
-	std::vector<LDObject*>::iterator pos = std::unique (sel.begin (), sel.end ());
+	vector<LDObject*>::it pos = std::unique (sel.begin (), sel.end ());
 	sel.resize (std::distance (sel.begin (), pos));
 	// Update everything now.
 	g_win->updateSelection ();
 	// Recompile the objects now to update their color
 	for (LDObject* obj : sel)
 	setBackground ();
 	update ();
 }
 // =============================================================================
-void GLRenderer::setEditMode (EditMode mode) {
+void GLRenderer::callback_setEditMode () {
-	switch (mode) {
+	switch (editMode ()) {
 	case Select:
 		unsetCursor ();
 		setContextMenuPolicy (Qt::DefaultContextMenu);
 		break;
 		g_win->sel ().clear ();
 		g_win->updateSelection ();
 		m_drawedVerts.clear ();
 		break;
 	}
-	m_editMode = mode;
 	g_win->updateEditModeActions ();
 	update ();
 }
 	if (!dlg.exec ())
 		return;
 	QImage* img = new QImage (dlg.fpath ().chars ());
-	overlayMeta& info = g_overlays[camera ()];
+	overlayMeta& info = getOverlay (camera ());
 	if (img->isNull ()) {
 		critical ("Failed to load overlay image!");
 		delete img;
 		return;
 	}
 	delete info.img; // delete the old image
 	info.fname = dlg.fpath ();
 	info.lw = dlg.lwidth ();
 	info.lh = dlg.lheight ();
 	info.ox = dlg.ofsx ();
 	info.oy = dlg.ofsy ();
 void GLRenderer::clearOverlay () {
 	if (camera () == Free)
 		return;
-	overlayMeta& info = g_overlays[camera ()];
+	overlayMeta& info = m_overlays[camera ()];
 	delete info.img;
 	info.img = null;
 }
 void GLRenderer::setDepthValue (double depth) {
 	assert (camera () < Free);
-	g_depthValues[camera ()] = depth;
+	m_depthValues[camera ()] = depth;
 }
 double GLRenderer::depthValue () const {
 	assert (camera () < Free);
-	return g_depthValues[camera ()];
+	return m_depthValues[camera ()];
 }
 const char* GLRenderer::cameraName () const {
 	return g_CameraNames[camera ()];
 }
+overlayMeta& GLRenderer::getOverlay (int newcam) {
+	 return m_overlays[newcam];
+}

Mercurial > ldforge / file comparison

comparison: src/gldraw.cpp

src/gldraw.cpp