Processing Speed of Rectangle Intersect Function

[HellfireXP]

I'm trying to find the fastest method to find whether or not two rectangles intersect in an effort to streamline my code. I've built this function into a rectangle class I created below.

	struct rectangle{
	rectangle() :X1(0), Y1(0), X2(0), Y2(0) {};
	rectangle(int X1, int Y1, int X2, int Y2)
		:X1(X1), Y1(Y1), X2(X2), Y2(Y2) {};
	int X1;
	int Y1;
	int X2;
	int Y2;
	int GetWidth() { return (X2-X1+1); }
	int GetHeight() { return (Y2-Y1+1); }
	bool CollidesWith(rectangle rec);
	rectangle OverlapRegion(rectangle rec);
	void Draw(ALLEGRO_BITMAP *Surface, ALLEGRO_COLOR Color, int Thickness = 1, bool Filled = false)
	{
		if (currentSurface != Surface) { currentSurface = Surface; al_set_target_bitmap(currentSurface); }
		if (Filled == false) al_draw_rectangle(X1, Y1, X2, Y2, Color, Thickness);
		if (Filled == true) al_draw_filled_rectangle(X1, Y1, X2, Y2, Color);
	}
};
	bool rectangle::CollidesWith(rectangle rec)
	{
	if (Y1 > rec.Y2) return false;
	if (Y2 < rec.Y1) return false;
	if (X1 > rec.X2) return false;
	if (X2 < rec.X1) return false;
	return true;
	}
	rectangle rectangle::OverlapRegion(rectangle rec)
	{
		rectangle regionRec(-1,-1,-1,-1);
		if (CollidesWith(rec) == false) return regionRec;
		regionRec.X1 = GetMin(X1, rec.X1) + abs(X1 - rec.X1);
		regionRec.Y1 = GetMin(Y1, rec.Y1) + abs(Y1 - rec.Y1);
		regionRec.X2 = GetMax(X2, rec.X2) - abs(X2 - rec.X2);
		regionRec.Y2 = GetMax(Y2, rec.Y2) - abs(Y2 - rec.Y2);
		return regionRec;
	}

So my question is which method of determining collision between two rectangles process faster...

This one...

bool rectangle::CollidesWith(rectangle rec)
	{
	if (Y1 > rec.Y2) return false;
	if (Y2 < rec.Y1) return false;
	if (X1 > rec.X2) return false;
	if (X2 < rec.X1) return false;
	return true;
	}

or this one...

bool rectangle::CollidesWith(rectangle rec)
	{
	if ((Y1 > rec.Y2) || (Y2 < rec.Y1) ||
	   (X1 > rec.X2) || (X2 < rec.X1)) return false;
	return true;
	}

...or do they execute at the same speed?

[coder777]

the first one might be possibly faster because it doesn't always need to check all conditions.

But if that has any measurable effect is another question...

[LB]

@coder777 I think you forgot that short-circuit evaluation exists. Both code segments should be the same as:

bool rectangle::CollidesWith(rectangle rec)
{
    return !(Y1 > rec.Y2 || Y2 < rec.Y1 || X1 > rec.X2 || X2 < rec.X1);
}

[coder777]

L B wrote:

I think you forgot that short-circuit evaluation exists.

It doesn't matter for the execution speed. In the worst case (all condition are false) the second example adds the or operators. And you add another operator.

Not considering possible optimization of the compiler the first example should have at least the same or in worst case better performance (speed wise)