ldforge: comparison src/gldraw.cpp

-:fae3bc9ce319
+:6fea53f1ffc2
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 // =============================================================================
 void GLRenderer::initializeGL () {
 	setBackground ();
-	glEnable (GL_POLYGON_OFFSET_FILL);
-	glPolygonOffset (1.0f, 1.0f);
-	glEnable (GL_DEPTH_TEST);
-	glShadeModel (GL_SMOOTH);
-	glEnable (GL_MULTISAMPLE);
-	glEnable (GL_BLEND);
-	glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
-	glEnable (GL_LINE_SMOOTH);
-	glHint (GL_LINE_SMOOTH_HINT, GL_NICEST);
 	glLineWidth (gl_linethickness);
 	setAutoFillBackground (false);
 	setMouseTracking (true);
 	setFocusPolicy (Qt::WheelFocus);
 // =============================================================================
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 // =============================================================================
 static vector<short> g_daWarnedColors;
-void GLRenderer::setObjectColor (LDObject* obj) {
+void GLRenderer::setObjectColor (LDObject* obj, const ListType list) {
 	QColor qcol;
-	if (!obj->isColored())
+	if (!obj->isColored ())
 		return;
-	if (m_picking) {
+	if (list == GL::PickList) {
 		// Make the color by the object's index color if we're picking, so we can
 		// make the index from the color we get from the picking results.
 		long i = obj->getIndex (g_curfile);
 		// If we couldn't find the index, this object must not be from this file,
 	long r = qcol.red (),
 		g = qcol.green (),
 		b = qcol.blue (),
 		a = qcol.alpha ();
-	// If it's selected, brighten it up, also pulse flash it if desired.
+	// Brighten it up for the select list.
-	if (g_win->isSelected (obj)) {
+	if (list == GL::SelectList) {
-		short tick, numTicks;
+		const uchar add = 51;
-		if (gl_selflash) {
-			tick = (g_pulseTick < (g_numPulseTicks / 2)) ? g_pulseTick : (g_numPulseTicks - g_pulseTick);
-			numTicks = g_numPulseTicks;
-		} else {
-			tick = 2;
-			numTicks = 5;
-		}
-		const long add = ((tick * 128) / numTicks);
 		r = min (r + add, 255l);
 		g = min (g + add, 255l);
 		b = min (b + add, 255l);
-		// a = 255;
 	}
 	glColor4f (
 		((double) r) / 255.0f,
 		((double) g) / 255.0f,
 	for (LDObject* obj : g_curfile->m_objs) {
 		if (obj->hidden ())
 			continue; // Don't draw hidden objects
-		glCallList (m_picking == false ? obj->uGLList : obj->uGLPickList);
+		glCallList (obj->glLists[(m_picking) ? PickList : (obj->selected ()) ? SelectList : NormalList]);
 	}
 	if (gl_axes && !m_picking)
 		glCallList (m_axeslist);
 // =============================================================================
 void GLRenderer::paintEvent (QPaintEvent* ev) {
 	Q_UNUSED (ev)
 	m_virtWidth = m_zoom;
 	m_virtHeight = (m_height * m_virtWidth) / m_width;
+	glEnable (GL_BLEND);
+	glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+	glEnable (GL_POLYGON_OFFSET_FILL);
+	glPolygonOffset (1.0f, 1.0f);
+	glEnable (GL_DEPTH_TEST);
+	glShadeModel (GL_SMOOTH);
+	glEnable (GL_MULTISAMPLE);
+	glEnable (GL_LINE_SMOOTH);
+	glHint (GL_LINE_SMOOTH_HINT, GL_NICEST);
 	drawGLScene ();
 	QPainter paint (this);
 	QFontMetrics metrics = QFontMetrics (QFont ());
 	paint.setRenderHint (QPainter::Antialiasing);
 	if (!g_curfile) {
 		printf ("renderer: no files loaded, cannot compile anything\n");
 		return;
 	}
-	for (LDObject* obj : g_curfile->m_objs) {
+	for (LDObject* obj : g_curfile->m_objs)
-		GLuint* upaLists[2] = {
+		compileObject (obj);
-			&obj->uGLList,
-			&obj->uGLPickList
-		};
-		for (GLuint* upMemberList : upaLists) {
-			GLuint uList = glGenLists (1);
-			glNewList (uList, GL_COMPILE);
-			m_picking = (upMemberList == &obj->uGLPickList);
-			compileOneObject (obj);
-			m_picking = false;
-			glEndList ();
-			*upMemberList = uList;
-		}
-	}
 	// Compile axes
 	m_axeslist = glGenLists (1);
 	glNewList (m_axeslist, GL_COMPILE);
 	glBegin (GL_LINES);
 }
 // =============================================================================
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 // =============================================================================
-void GLRenderer::compileOneObject (LDObject* obj) {
+void GLRenderer::compileList (LDObject* obj, const GLRenderer::ListType list) {
-	setObjectColor (obj);
+	setObjectColor (obj, list);
 	switch (obj->getType ()) {
 	case LDObject::Line:
 		compileSubObject (obj, GL_LINES);
 		break;
 	case LDObject::CondLine:
-		glLineStipple (1, 0x6666);
+		if (list != GL::PickList) {
-		glEnable (GL_LINE_STIPPLE);
+			glLineStipple (1, 0x6666);
+			glEnable (GL_LINE_STIPPLE);
+		}
 		compileSubObject (obj, GL_LINES);
 		glDisable (GL_LINE_STIPPLE);
 		break;
 		{
 			LDSubfile* ref = static_cast<LDSubfile*> (obj);
 			vector<LDObject*> objs = ref->inlineContents (true, true);
 			for (LDObject* obj : objs) {
-				compileOneObject (obj);
+				compileList (obj, list);
 				delete obj;
 			}
 		}
 		break;
 		{
 			LDRadial* pRadial = static_cast<LDRadial*> (obj);
 			std::vector<LDObject*> objs = pRadial->decompose (true);
 			for (LDObject* obj : objs) {
-				compileOneObject (obj);
+				compileList (obj, list);
 				delete obj;
 			}
 		}
 		break;
 					vPos->y,
 					vPos->z + BIPYRAMID_COORD (2)
 				};
 				pPoly->dColor = pVert->dColor;
-				compileOneObject (pPoly);
+				compileOneObject (pPoly, list);
 				delete pPoly;
 			}
 		}
 		break;
 #endif // 0
 	const bool wasLeft = (m_lastButtons & Qt::LeftButton) && !(ev->buttons() & Qt::LeftButton);
 	const bool wasRight = (m_lastButtons & Qt::RightButton) && !(ev->buttons() & Qt::RightButton);
 	if (wasLeft) {
 		if (m_planeDraw) {
+			// If we have 4 verts, stop drawing.
+			if (m_planeDrawVerts.size () >= 4) {
+				endPlaneDraw (true);
+				return;
+			}
 			// If we picked an already-existing vertex, stop drawing
 			for (vertex& vert : m_planeDrawVerts) {
 				if (vert == m_hoverpos) {
 					endPlaneDraw (true);
 					return;
 				}
 			}
-			// Also, if have 4 verts, also stop drawing.
-			if (m_planeDrawVerts.size () >= 4)
-				endPlaneDraw (true);
 			m_planeDrawVerts.push_back (m_hoverpos);
 			update ();
 			return;
 		} else {
 			}
 		}
 	}
 	GLint viewport[4];
-	LDObject* removedObject = null;
 	// Clear the selection if we do not wish to add to it.
 	if (!m_addpick) {
 		std::vector<LDObject*> oldsel = g_win->sel ();
 		g_win->sel ().clear ();
-		// Recompile the prior selection to remove the highlight color
 		for (LDObject* obj : oldsel)
-			recompileObject (obj);
+			compileObject (obj);
 	}
 	m_picking = true;
 	// Paint the picking scene
 	assert (viewport[3] == m_height);
 	// Read pixels from the color buffer.
 	glReadPixels (x0, viewport[3] - y1, areawidth, areaheight, GL_RGBA, GL_UNSIGNED_BYTE, pixeldata);
+	LDObject* removedObj = null;
 	// Go through each pixel read and add them to the selection.
 	for (long i = 0; i < numpixels; ++i) {
 		uint32 idx =
 			(*(pixelptr) * 0x10000) +
 			(*(pixelptr + 1) * 0x00100) +
 			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);
-					removedObject = obj;
 					removed = true;
+					removedObj = obj;
 				}
 			}
 			if (removed)
 				break;
 	std::sort (sel.begin(), sel.end ());
 	std::vector<LDObject*>::iterator pos = std::unique (sel.begin (), sel.end ());
 	sel.resize (std::distance (sel.begin (), pos));
 	// Update everything now.
-	g_win->buildObjList ();
+	g_win->updateSelection ();
+	// Recompile the objects now to update their color
+	for (LDObject* obj : sel)
+		compileObject (obj);
 	m_picking = false;
 	m_rangepick = false;
 	glEnable (GL_DITHER);
 	setBackground ();
 	updateSelFlash ();
-	for (LDObject* obj : g_win->sel ())
-		recompileObject (obj);
-	if (removedObject != null)
-		recompileObject (removedObject);
 	drawGLScene ();
 	swapBuffers ();
 	update ();
 }
 			break;
 		}
 		if (obj) {
 			g_curfile->addObject (obj);
-			recompileObject (obj);
+			compileObject (obj);
 			g_win->refresh ();
 			History::addEntry (new AddHistory ({(ulong) obj->getIndex (g_curfile)}, {obj->clone ()}));
 		}
 	}
 }
 // =============================================================================
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 // =============================================================================
-void GLRenderer::recompileObject (LDObject* obj) {
+void GLRenderer::compileObject (LDObject* obj) {
-	// Replace the old list with the new one.
+	for (const GL::ListType listType : g_glListTypes) {
-	GLuint uList = glGenLists (1);
+		GLuint list = glGenLists (1);
-	glNewList (uList, GL_COMPILE);
+		glNewList (list, GL_COMPILE);
-	compileOneObject (obj);
+		obj->glLists[listType] = list;
+		compileList (obj, listType);
-	glEndList ();
-	obj->uGLList = uList;
+		glEndList ();
+	}
 }
 // =============================================================================
 uchar* GLRenderer::screencap (ushort& w, ushort& h) {
 	w = m_width;
 // =============================================================================
 void GLRenderer::slot_timerUpdate () {
 	++g_pulseTick %= g_numPulseTicks;
 	for (LDObject* obj : g_win->sel ())
-		recompileObject (obj);
+		compileObject (obj);
 	update ();
 }
 // =============================================================================

Mercurial > ldforge / file comparison

comparison: src/gldraw.cpp

src/gldraw.cpp