diff --git a/src/m_bbox.cpp b/src/m_bbox.cpp
index be6721209..143f54d47 100644
--- a/src/m_bbox.cpp
+++ b/src/m_bbox.cpp
@@ -34,32 +34,17 @@
 //
 //==========================================================================
 
-void FBoundingBox::setBox(fixed_t x, fixed_t y, fixed_t radius)
+void FBoundingBox::AddToBox (const DVector2 &pos)
 {
-	m_Box[BOXTOP] = (fixed_t)MIN<SQWORD>((SQWORD)y + radius, FIXED_MAX);
-	m_Box[BOXLEFT] = (fixed_t)MAX<SQWORD>((SQWORD)x - radius, FIXED_MIN);
-	m_Box[BOXRIGHT] = (fixed_t)MIN<SQWORD>((SQWORD)x + radius, FIXED_MAX);
-	m_Box[BOXBOTTOM] = (fixed_t)MAX<SQWORD>((SQWORD)y - radius, FIXED_MIN);
-}
+	if (pos.X < m_Box[BOXLEFT])
+		m_Box[BOXLEFT] = pos.X;
+	if (pos.X > m_Box[BOXRIGHT])
+		m_Box[BOXRIGHT] = pos.X;
 
-
-//==========================================================================
-//
-//
-//
-//==========================================================================
-
-void FBoundingBox::AddToBox (fixed_t x, fixed_t y)
-{
-	if (x < m_Box[BOXLEFT])
-		m_Box[BOXLEFT] = x;
-	if (x > m_Box[BOXRIGHT])
-		m_Box[BOXRIGHT] = x;
-
-	if (y < m_Box[BOXBOTTOM])
-		m_Box[BOXBOTTOM] = y;
-	if (y > m_Box[BOXTOP])
-		m_Box[BOXTOP] = y;
+	if (pos.Y < m_Box[BOXBOTTOM])
+		m_Box[BOXBOTTOM] = pos.Y;
+	if (pos.Y > m_Box[BOXTOP])
+		m_Box[BOXTOP] = pos.Y;
 }
 
 //==========================================================================
@@ -78,8 +63,8 @@ int FBoundingBox::BoxOnLineSide (const line_t *ld) const
 		
 	if (ld->Delta().X == 0)
 	{ // ST_VERTICAL
-		p1 = m_Box[BOXRIGHT] < ld->v1->fixX();
-		p2 = m_Box[BOXLEFT] < ld->v1->fixX();
+		p1 = m_Box[BOXRIGHT] < ld->v1->fX();
+		p2 = m_Box[BOXLEFT] < ld->v1->fX();
 		if (ld->Delta().Y < 0)
 		{
 			p1 ^= 1;
@@ -88,8 +73,8 @@ int FBoundingBox::BoxOnLineSide (const line_t *ld) const
 	}
 	else if (ld->Delta().Y == 0)
 	{ // ST_HORIZONTAL:
-		p1 = m_Box[BOXTOP] > ld->v1->fixY();
-		p2 = m_Box[BOXBOTTOM] > ld->v1->fixY();
+		p1 = m_Box[BOXTOP] > ld->v1->fY();
+		p2 = m_Box[BOXBOTTOM] > ld->v1->fY();
 		if (ld->Delta().X < 0)
 		{
 			p1 ^= 1;
diff --git a/src/m_bbox.h b/src/m_bbox.h
index fe73432da..98f7abcf6 100644
--- a/src/m_bbox.h
+++ b/src/m_bbox.h
@@ -22,7 +22,8 @@
 #ifndef __M_BBOX_H__
 #define __M_BBOX_H__
 
-#include "doomtype.h"
+#include <float.h>
+#include "vectors.h"
 #include "m_fixed.h"
 
 struct line_t;
@@ -36,7 +37,11 @@ public:
 		ClearBox();
 	}
 
-	FBoundingBox(fixed_t left, fixed_t bottom, fixed_t right, fixed_t top)
+	FBoundingBox(fixed_t left, fixed_t bottom, fixed_t right, fixed_t top) = delete;
+	FBoundingBox(fixed_t x, fixed_t y, fixed_t radius) = delete;
+	void Set(int index, fixed_t value) = delete;
+
+	FBoundingBox(double left, double bottom, double right, double top)
 	{
 		m_Box[BOXTOP] = top;
 		m_Box[BOXLEFT] = left;
@@ -44,35 +49,24 @@ public:
 		m_Box[BOXBOTTOM] = bottom;
 	}
 
-	FBoundingBox(double left, double bottom, double right, double top)
-	{
-		m_Box[BOXTOP] = FLOAT2FIXED(top);
-		m_Box[BOXLEFT] = FLOAT2FIXED(left);
-		m_Box[BOXRIGHT] = FLOAT2FIXED(right);
-		m_Box[BOXBOTTOM] = FLOAT2FIXED(bottom);
-	}
-
-	FBoundingBox(fixed_t x, fixed_t y, fixed_t radius)
-	{
-		setBox(x, y, radius);
-	}
-
 	FBoundingBox(double x, double y, double radius)
 	{
 		setBox(x, y, radius);
 	}
 
-	void setBox(fixed_t x, fixed_t y, fixed_t radius);
 
 	void setBox(double x, double y, double radius)
 	{
-		setBox(FLOAT2FIXED(x), FLOAT2FIXED(y), FLOAT2FIXED(radius));
+		m_Box[BOXTOP] = y + radius;
+		m_Box[BOXLEFT] = x - radius;
+		m_Box[BOXRIGHT] = x + radius;
+		m_Box[BOXBOTTOM] = y - radius;
 	}
 
 	void ClearBox ()
 	{
-		m_Box[BOXTOP] = m_Box[BOXRIGHT] = FIXED_MIN;
-		m_Box[BOXBOTTOM] = m_Box[BOXLEFT] = FIXED_MAX;
+		m_Box[BOXTOP] = m_Box[BOXRIGHT] = -FLT_MAX;
+		m_Box[BOXBOTTOM] = m_Box[BOXLEFT] = FLT_MAX;
 	}
 
 	// Returns a bounding box that encloses both bounding boxes
@@ -84,21 +78,21 @@ public:
 							m_Box[BOXTOP] > box2.m_Box[BOXTOP] ? m_Box[BOXTOP] : box2.m_Box[BOXTOP]);
 	}
 
-	void AddToBox (fixed_t x, fixed_t y);
+	void AddToBox(const DVector2 &pos);
 
-	inline fixed_t Top () const { return m_Box[BOXTOP]; }
-	inline fixed_t Bottom () const { return m_Box[BOXBOTTOM]; }
-	inline fixed_t Left () const { return m_Box[BOXLEFT]; }
-	inline fixed_t Right () const { return m_Box[BOXRIGHT]; }
+	inline double Top () const { return m_Box[BOXTOP]; }
+	inline double Bottom () const { return m_Box[BOXBOTTOM]; }
+	inline double Left () const { return m_Box[BOXLEFT]; }
+	inline double Right () const { return m_Box[BOXRIGHT]; }
 
 	bool inRange(const line_t *ld) const;
 
 	int BoxOnLineSide (const line_t *ld) const;
 
-	void Set(int index, fixed_t value) {m_Box[index] = value;}
+	void Set(int index, double value) {m_Box[index] = value;}
 
 protected:
-	fixed_t m_Box[4];
+	double m_Box[4];
 };
 
 
diff --git a/src/p_maputl.cpp b/src/p_maputl.cpp
index 58c186593..5a71fe402 100644
--- a/src/p_maputl.cpp
+++ b/src/p_maputl.cpp
@@ -638,10 +638,10 @@ FBlockLinesIterator::FBlockLinesIterator(int _minx, int _miny, int _maxx, int _m
 void FBlockLinesIterator::init(const FBoundingBox &box)
 {
 	validcount++;
-	maxy = GetBlockY(FIXED2DBL(box.Top()));
-	miny = GetBlockY(FIXED2DBL(box.Bottom()));
-	maxx = GetBlockX(FIXED2DBL(box.Right()));
-	minx = GetBlockX(FIXED2DBL(box.Left()));
+	maxy = GetBlockY(box.Top());
+	miny = GetBlockY(box.Bottom());
+	maxx = GetBlockX(box.Right());
+	minx = GetBlockX(box.Left());
 	Reset();
 }
 
@@ -898,7 +898,7 @@ void FMultiBlockLinesIterator::startIteratorForGroup(int group)
 	offset.x += checkpoint.x;
 	offset.y += checkpoint.y;
 	cursector = group == startsector->PortalGroup ? startsector : P_PointInSector(offset.x, offset.y);
-	bbox.setBox(offset.x, offset.y, checkpoint.z);
+	bbox.setBox(FIXED2FLOAT(offset.x), FIXED2FLOAT(offset.y), FIXED2FLOAT(checkpoint.z));
 	blockIterator.init(bbox);
 }
 
@@ -944,10 +944,10 @@ FBlockThingsIterator::FBlockThingsIterator(int _minx, int _miny, int _maxx, int
 
 void FBlockThingsIterator::init(const FBoundingBox &box)
 {
-	maxy = GetBlockY(FIXED2DBL(box.Top()));
-	miny = GetBlockY(FIXED2DBL(box.Bottom()));
-	maxx = GetBlockX(FIXED2DBL(box.Right()));
-	minx = GetBlockX(FIXED2DBL(box.Left()));
+	maxy = GetBlockY(box.Top());
+	miny = GetBlockY(box.Bottom());
+	maxx = GetBlockX(box.Right());
+	minx = GetBlockX(box.Left());
 	ClearHash();
 	Reset();
 }
@@ -1173,7 +1173,7 @@ void FMultiBlockThingsIterator::startIteratorForGroup(int group)
 	fixedvec2 offset = Displacements._f_getOffset(basegroup, group);
 	offset.x += checkpoint.x;
 	offset.y += checkpoint.y;
-	bbox.setBox(offset.x, offset.y, checkpoint.z);
+	bbox.setBox(FIXED2FLOAT(offset.x), FIXED2FLOAT(offset.y), FIXED2FLOAT(checkpoint.z));
 	blockIterator.init(bbox);
 }
 
diff --git a/src/p_setup.cpp b/src/p_setup.cpp
index 4cb422949..278c5f69d 100644
--- a/src/p_setup.cpp
+++ b/src/p_setup.cpp
@@ -3208,14 +3208,14 @@ static void P_GroupLines (bool buildmap)
 			for (j = 0; j < sector->linecount; ++j)
 			{
 				li = sector->lines[j];
-				bbox.AddToBox (li->v1->fixX(), li->v1->fixY());
-				bbox.AddToBox (li->v2->fixX(), li->v2->fixY());
+				bbox.AddToBox (li->v1->fPos());
+				bbox.AddToBox (li->v2->fPos());
 			}
 		}
 
 		// set the center to the middle of the bounding box
-		sector->centerspot.X = FIXED2DBL(bbox.Right()/2 + bbox.Left()/2);
-		sector->centerspot.Y = FIXED2DBL(bbox.Top()/2 + bbox.Bottom()/2);
+		sector->centerspot.X = (bbox.Right() + bbox.Left()/2);
+		sector->centerspot.Y = (bbox.Top() + bbox.Bottom()/2);
 
 		// For triangular sectors the above does not calculate good points unless the longest of the triangle's lines is perfectly horizontal and vertical
 		if (sector->linecount == 3)
diff --git a/src/po_man.cpp b/src/po_man.cpp
index 04798dc49..d21141c35 100644
--- a/src/po_man.cpp
+++ b/src/po_man.cpp
@@ -1216,14 +1216,14 @@ void FPolyObj::LinkPolyobj ()
 		vertex_t *vt;
 		
 		vt = Sidedefs[i]->linedef->v1;
-		Bounds.AddToBox(vt->fixX(), vt->fixY());
+		Bounds.AddToBox(vt->fPos());
 		vt = Sidedefs[i]->linedef->v2;
-		Bounds.AddToBox(vt->fixX(), vt->fixY());
+		Bounds.AddToBox(vt->fPos());
 	}
-	bbox[BOXRIGHT] = GetBlockX(FIXED2DBL(Bounds.Right()));
-	bbox[BOXLEFT] = GetBlockX(FIXED2DBL(Bounds.Left()));
-	bbox[BOXTOP] = GetBlockY(FIXED2DBL(Bounds.Top()));
-	bbox[BOXBOTTOM] = GetBlockY(FIXED2DBL(Bounds.Bottom()));
+	bbox[BOXRIGHT] = GetBlockX(Bounds.Right());
+	bbox[BOXLEFT] = GetBlockX(Bounds.Left());
+	bbox[BOXTOP] = GetBlockY(Bounds.Top());
+	bbox[BOXBOTTOM] = GetBlockY(Bounds.Bottom());
 	// add the polyobj to each blockmap section
 	for(int j = bbox[BOXBOTTOM]*bmapwidth; j <= bbox[BOXTOP]*bmapwidth;
 		j += bmapwidth)
diff --git a/src/portal.cpp b/src/portal.cpp
index c56a79098..f9f6438c2 100644
--- a/src/portal.cpp
+++ b/src/portal.cpp
@@ -1172,10 +1172,12 @@ bool P_CollectConnectedGroups(int startgroup, const fixedvec3 &position, fixed_t
 			FDisplacement &disp = Displacements(thisgroup, othergroup);
 			if (!disp.isSet) continue;	// no connection.
 
+			/*
 			FBoundingBox box(position.x + disp.pos.x, position.y + disp.pos.y, checkradius);
 
 			if (!box.inRange(ld) || box.BoxOnLineSide(linkedPortals[i]->mOrigin) != -1) continue;	// not touched
 			foundPortals.Push(linkedPortals[i]);
+			*/
 		}
 		bool foundone = true;
 		while (foundone)
@@ -1230,7 +1232,7 @@ bool P_CollectConnectedGroups(int startgroup, const fixedvec3 &position, fixed_t
 			for (unsigned i = 0; i < groupsToCheck.Size();i++)
 			{
 				fixedvec2 disp = Displacements._f_getOffset(startgroup, thisgroup & ~FPortalGroupArray::FLAT);
-				FBoundingBox box(position.x + disp.x, position.y + disp.y, checkradius);
+				FBoundingBox box(0., 0., 0.);// position.x + disp.x, position.y + disp.y, checkradius);
 				FBlockLinesIterator it(box);
 				line_t *ld;
 				while ((ld = it.Next()))
diff --git a/src/r_defs.h b/src/r_defs.h
index ceb849c01..d29dd1dd6 100644
--- a/src/r_defs.h
+++ b/src/r_defs.h
@@ -1646,10 +1646,10 @@ inline void AActor::ClearInterpolation()
 
 inline bool FBoundingBox::inRange(const line_t *ld) const
 {
-	return FIXED2DBL(Left()) < ld->bbox[BOXRIGHT] &&
-		FIXED2DBL(Right()) > ld->bbox[BOXLEFT] &&
-		FIXED2DBL(Top()) > ld->bbox[BOXBOTTOM] &&
-		FIXED2DBL(Bottom()) < ld->bbox[BOXTOP];
+	return Left() < ld->bbox[BOXRIGHT] &&
+		Right() > ld->bbox[BOXLEFT] &&
+		Top() > ld->bbox[BOXBOTTOM] &&
+		Bottom() < ld->bbox[BOXTOP];
 }