ldforge: comparison src/gldraw.cpp

-:1add0ee96fb3
+:2f85d4d286e5
 	{ QColor (80,  192,   0), vertex (0, 10000, 0) },
 	{ QColor (0,   160, 192), vertex (0, 0, 10000) },
 };
 static bool g_glInvert = false;
-static QList<short> g_warnedColors;
+static QList<int> g_warnedColors;
 // =============================================================================
 // -----------------------------------------------------------------------------
 GLRenderer::GLRenderer (QWidget* parent) : QGLWidget (parent)
 {	m_picking = m_rangepick = false;
 			// not appear pitch-black.
 			if (obj->color() != edgecolor)
 				qcol = getMainColor();
 			// Warn about the unknown colors, but only once.
-			for (short i : g_warnedColors)
+			for (int i : g_warnedColors)
 				if (obj->color() == i)
 					return;
 			log ("%1: Unknown color %2!\n", __func__, obj->color());
 			g_warnedColors << obj->color();
 	vertex pos3d;
 	const LDFixedCameraInfo* cam = &g_FixedCameras[m_camera];
 	const Axis axisX = cam->axisX;
 	const Axis axisY = cam->axisY;
-	const short negXFac = cam->negX ? -1 : 1,
+	const int negXFac = cam->negX ? -1 : 1,
 				negYFac = cam->negY ? -1 : 1;
 	// Calculate cx and cy - these are the LDraw unit coords the cursor is at.
 	double cx = (-m_virtWidth + ((2 * pos2d.x() * m_virtWidth) / m_width) - pan (X));
 	double cy = (m_virtHeight - ((2 * pos2d.y() * m_virtHeight) / m_height) - pan (Y));
 	str tmp;
 	// Create the vertex from the coordinates
 	pos3d[axisX] = tmp.sprintf ("%.3f", cx).toDouble();
 	pos3d[axisY] = tmp.sprintf ("%.3f", cy).toDouble();
-	pos3d[3 - axisX - axisY] = depthValue();
+	pos3d[3 - axisX - axisY] = getDepthValue();
 	return pos3d;
 }
 // =============================================================================
 // -----------------------------------------------------------------------------
 QPoint GLRenderer::coordconv3_2 (const vertex& pos3d) const
 {	GLfloat m[16];
 	const LDFixedCameraInfo* cam = &g_FixedCameras[m_camera];
 	const Axis axisX = cam->axisX;
 	const Axis axisY = cam->axisY;
-	const short negXFac = cam->negX ? -1 : 1,
+	const int negXFac = cam->negX ? -1 : 1,
 				negYFac = cam->negY ? -1 : 1;
 	glGetFloatv (GL_MODELVIEW_MATRIX, m);
 	const double x = pos3d.x();
 		{	// 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;
-				const double dist0 = circleDrawDist (0),
+				const double dist0 = getCircleDrawDist (0),
-					dist1 = (m_drawedVerts.size() >= 2) ? circleDrawDist (1) : -1;
+					dist1 = (m_drawedVerts.size() >= 2) ? getCircleDrawDist (1) : -1;
 				const int segs = lores;
 				const double angleUnit = (2 * pi) / segs;
 				Axis relX, relY;
 				QVector<QPoint> ringpoints, circlepoints, circle2points;
 					   LDSubfile::DeepInline |
 					   LDSubfile::CacheInline |
 					   LDSubfile::RendererInline);
 			bool oldinvert = g_glInvert;
-			if (ref->transform().determinant() < 0)
+			if (ref->transform().getDeterminant() < 0)
 				g_glInvert = !g_glInvert;
 			LDObject* prev = ref->prev();
 			if (prev && prev->getType() == LDObject::BFC && static_cast<LDBFC*> (prev)->type == LDBFC::InvertNext)
 	drawGLScene();
 	glGetIntegerv (GL_VIEWPORT, viewport);
-	short x0 = mouseX,
+	int x0 = mouseX,
 		  y0 = mouseY;
-	short x1, y1;
+	int x1, y1;
 	// Determine how big an area to read - with range picking, we pick by
 	// the area given, with single pixel picking, we use an 1 x 1 area.
 	if (m_rangepick)
 	{	x1 = m_rangeStart.x();
 	if (y0 > y1)
 		dataswap (y0, y1);
 	// Clamp the values to ensure they're within bounds
-	x0 = max<short> (0, x0);
+	x0 = max (0, x0);
-	y0 = max<short> (0, y0);
+	y0 = max (0, y0);
-	x1 = min<short> (x1, m_width);
+	x1 = min (x1, m_width);
-	y1 = min<short> (y1, m_height);
+	y1 = min (y1, m_height);
-	const short areawidth = (x1 - x0);
+	const int areawidth = (x1 - x0);
-	const short areaheight = (y1 - y0);
+	const int areaheight = (y1 - y0);
-	const long numpixels = areawidth * areaheight;
+	const qint32 numpixels = areawidth * areaheight;
 	// Allocate space for the pixel data.
 	uchar* const pixeldata = new uchar[4 * numpixels];
 	uchar* pixelptr = &pixeldata[0];
 	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)
+	for (qint32 i = 0; i < numpixels; ++i)
-	{	long idx =
+	{	qint32 idx =
-			(* (pixelptr + 0) * 0x10000) +
+			(*(pixelptr + 0) * 0x10000) +
-			(* (pixelptr + 1) * 0x00100) +
+			(*(pixelptr + 1) * 0x00100) +
-			(* (pixelptr + 2) * 0x00001);
+			(*(pixelptr + 2) * 0x00001);
 		pixelptr += 4;
 		if (idx == 0xFFFFFF)
 			continue; // White is background; skip
 // -----------------------------------------------------------------------------
 SET_ACCESSOR (LDFile*, GLRenderer::setFile)
 {	m_file = val;
 	if (val != null)
-		overlaysFromObjects();
+		initOverlaysFromObjects();
 }
 // =============================================================================
 // -----------------------------------------------------------------------------
 matrix GLRenderer::getCircleDrawMatrix (double scale)
 			}
 		} break;
 		case CircleMode:
 		{	const int segs = lores, divs = lores; // TODO: make customizable
-			double dist0 = circleDrawDist (0),
+			double dist0 = getCircleDrawDist (0),
-				dist1 = circleDrawDist (1);
+				dist1 = getCircleDrawDist (1);
 			LDFile* refFile = null;
 			matrix transform;
 			bool circleOrDisc = false;
 			if (dist1 < dist0)
 				transform = getCircleDrawMatrix ((dist0 != 0) ? dist0 : dist1);
 				circleOrDisc = true;
 			}
 			elif (g_RingFinder (dist0, dist1))
 			{	// The ring finder found a solution, use that. Add the component rings to the file.
-				for (const RingFinder::Component& cmp : g_RingFinder.bestSolution()->components())
+				for (const RingFinder::Component& cmp : g_RingFinder.bestSolution()->getComponents())
 				{	if ((refFile = getFile (radialFileName (::Ring, lores, lores, cmp.num))) == null)
 					{	refFile = generatePrimitive (::Ring, lores, lores, cmp.num);
 						refFile->setImplicit (false);
 					}
 					y0 = m_drawedVerts[0][relY];
 				vertex templ;
 				templ[relX] = x0;
 				templ[relY] = y0;
-				templ[relZ] = depthValue();
+				templ[relZ] = getDepthValue();
 				// Calculate circle coords
 				makeCircle (segs, divs, dist0, c0);
 				makeCircle (segs, divs, dist1, c1);
 	m_rectdraw = false;
 }
 // =============================================================================
 // -----------------------------------------------------------------------------
-double GLRenderer::circleDrawDist (int pos) const
+double GLRenderer::getCircleDrawDist (int pos) const
 {	assert (m_drawedVerts.size() >= pos + 1);
 	const vertex& v1 = (m_drawedVerts.size() >= pos + 2) ? m_drawedVerts[pos + 1] : m_hoverpos;
 	Axis relX, relY;
 	getRelativeAxes (relX, relY);
 	obj->m_glinit = true;
 }
 // =============================================================================
 // -----------------------------------------------------------------------------
-uchar* GLRenderer::screencap (int& w, int& h)
+uchar* GLRenderer::getScreencap (int& w, int& h)
 {	w = m_width;
 	h = m_height;
 	uchar* cap = new uchar[4 * w * h];
 	m_screencap = true;
 	obj->m_glinit = false;
 }
 // =============================================================================
 // -----------------------------------------------------------------------------
-Axis GLRenderer::cameraAxis (bool y, GL::Camera camid)
+Axis GLRenderer::getCameraAxis (bool y, GL::Camera camid)
 {	if (camid == (GL::Camera) - 1)
 		camid = m_camera;
 	const LDFixedCameraInfo* cam = &g_FixedCameras[camid];
 	return (y) ? cam->axisY : cam->axisX;
 	if (info.lw == 0)
 		info.lw = (info.lh * img->width()) / img->height();
 	elif (info.lh == 0)
 		info.lh = (info.lw * img->height()) / img->width();
-	const Axis x2d = cameraAxis (false, cam),
+	const Axis x2d = getCameraAxis (false, cam),
-		y2d = cameraAxis (true, cam);
+		y2d = getCameraAxis (true, cam);
 	const double negXFac = g_FixedCameras[cam].negX ? -1 : 1,
 		negYFac = g_FixedCameras[cam].negY ? -1 : 1;
 	info.v0 = info.v1 = g_origin;
 	info.v0[x2d] = - (info.ox * info.lw * negXFac) / img->width();
 	m_depthValues[camera()] = depth;
 }
 // =============================================================================
 // -----------------------------------------------------------------------------
-double GLRenderer::depthValue() const
+double GLRenderer::getDepthValue() const
 {	assert (camera() < Free);
 	return m_depthValues[camera()];
 }
 // =============================================================================
 // -----------------------------------------------------------------------------
-const char* GLRenderer::cameraName() const
+const char* GLRenderer::getCameraName() const
 {	return g_CameraNames[camera()];
 }
 // =============================================================================
 // -----------------------------------------------------------------------------
 	}
 	vertex v0 = m_drawedVerts[0],
 		   v1 = (m_drawedVerts.size() >= 2) ? m_drawedVerts[1] : m_hoverpos;
-	const Axis ax = cameraAxis (false),
+	const Axis ax = getCameraAxis (false),
-			   ay = cameraAxis (true),
+			   ay = getCameraAxis (true),
 			   az = (Axis) (3 - ax - ay);
 	for (int i = 0; i < 4; ++i)
-		m_rectverts[i][az] = depthValue();
+		m_rectverts[i][az] = getDepthValue();
 	m_rectverts[0][ax] = v0[ax];
 	m_rectverts[0][ay] = v0[ay];
 	m_rectverts[1][ax] = v1[ax];
 	m_rectverts[1][ay] = v0[ay];
 // =============================================================================
 // -----------------------------------------------------------------------------
 // Read in overlays from the current file and update overlay info accordingly.
 // -----------------------------------------------------------------------------
-void GLRenderer::overlaysFromObjects()
+void GLRenderer::initOverlaysFromObjects()
 {	for (Camera cam : g_Cameras)
 	{	if (cam == Free)
 			continue;
 		LDGLOverlay& meta = m_overlays[cam];
 			// object and put an empty object after it (though don't do this if
 			// there was no schemantic elements at all)
 			int i, lastOverlay = -1;
 			bool found = false;
-			for (i = 0; i < file()->numObjs(); ++i)
+			for (i = 0; i < file()->getObjectCount(); ++i)
-			{	LDObject* obj = file()->obj (i);
+			{	LDObject* obj = file()->getObject (i);
 				if (obj->isScemantic())
 				{	found = true;
 					break;
 				}

Mercurial > ldforge / file comparison

comparison: src/gldraw.cpp

src/gldraw.cpp