1
0
Fork 0
mirror of https://github.com/AquariaOSE/Aquaria.git synced 2024-12-24 21:55:42 +00:00
Aquaria/BBGE/Collision.cpp

443 lines
8.7 KiB
C++

/*
Copyright (C) 2007, 2010 - Bit-Blot
This file is part of Aquaria.
Aquaria is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#include "Collision.h"
CollisionShape::CollisionShape()
{
xw = yw = 0;
setType(CIRCLE);
active = true;
project = true;
radius = 32;
corners.resize(4);
layer = 0;
}
void CollisionShape::setType(Type type)
{
this->type = type;
}
CollisionShape::Type CollisionShape::getType()
{
return type;
}
/*
bool CollisionShape::compareMask(CollisionShape &c)
{
for (CollisionLayerMask::iterator i = c.colliderMask.begin(); i != c.colliderMask.end(); i++)
{
for (CollisionLayerMask::iterator j = c.collideeMask.begin(); j != c.collideeMask.end(); j++)
{
if ((*i)) && (*j))
{
return true;
}
}
}
return false;
}
*/
bool CollisionShape::compareLayer(CollisionShape &c)
{
return (this->layer <= c.layer);
}
void CollisionShape::updatePosition(const Vector &position)
{
this->position = position + offsetPosition;
/*
switch (getType())
{
case AABB:
{
corners[0] = position + Vector( - xw, - yw);
corners[1] = position + Vector(xw, - yw);
corners[2] = position + Vector(xw, yw);
corners[3] = position + Vector(-xw ,yw);
}
break;
}
*/
}
CollisionResult CollisionShape::findOverlap(CollisionShape &collisionShape)
{
CollisionResult c;
switch (getType())
{
case CIRCLE:
{
switch(collisionShape.getType())
{
case CIRCLE:
c = collideCircleWithCircle(collisionShape);
break;
case AABB:
{
float txw = collisionShape.xw;
float tyw = collisionShape.yw;
Vector d = position - collisionShape.position;//tile->obj delta
int px = (txw + radius) - fabsf(d.x);//penetration depth in x
if(0 < px)
{
int py = (tyw + radius) - fabsf(d.y);//pen depth in y
if(0 < py)
{
//object may be colliding with tile
//determine grid/voronoi region of circle center
float oH = 0;
float oV = 0;
if(d.x < -txw)
{
//circle is on left side of tile
oH = -1;
}
else if(txw < d.x)
{
//circle is on right side of tile
oH = 1;
}
if(d.y < -tyw)
{
//circle is on top side of tile
oV = -1;
}
else if(tyw < d.y)
{
//circle is on bottom side of tile
oV = 1;
}
c = collideCircleWithAABB(collisionShape, px, py, oH, oV);
//ResolveCircleTile(px,py,oH,oV,this,c);
}
}
//return collideCircleWithAABB(collisionShape);
}
break;
case TOP_HALF_CIRCLE:
c = collideCircleWithTopHalfCircle(collisionShape);
break;
}
}
break;
}
return c;
}
CollisionResult CollisionShape::collideCircleWithCircle(CollisionShape &collisionShape)
{
CollisionResult c;
Vector dist = position - collisionShape.position;// - position;
float fastLen = dist.getSquaredLength2D();
float totalDist = (radius + collisionShape.radius);
if (fastLen < (totalDist*totalDist))
{
/*
std::ostringstream os;
os << "len " << len << " totalDist " << totalDist;
msg(os.str());
*/
float len = dist.getLength2D();
c.collided = true;
dist.setLength2D(totalDist - len);
//dist |= totalDist;
c.overlap = dist;
}
else
{
c.collided = false;
}
return c;
}
float CollisionShape::getY1()
{
return position.y - yw;
}
float CollisionShape::getY2()
{
return position.y + yw;
}
float CollisionShape::getX1()
{
return position.x - xw;
}
float CollisionShape::getX2()
{
return position.x + xw;
}
void CollisionShape::render()
{
#ifdef BBGE_BUILD_OPENGL
glTranslatef(offsetPosition.x, offsetPosition.y,0);
switch(getType())
{
case CIRCLE:
drawCircle(radius);
break;
case AABB:
//case CIRCLE:
//glColor3f(1,1,1);
//glLineWidth(2);
glBegin(GL_QUADS);
{
glVertex2f(-xw,yw);
glVertex2f(xw,yw);
glVertex2f(xw,-yw);
glVertex2f(-xw,-yw);
/*
glColor4f(0.0f, 1.0f, 0.0f, 1.0f);
glVertex2f(topLeft.x, topLeft.y);
glVertex2f(bottomRight.x, topLeft.y);
glVertex2f(bottomRight.x, topLeft.y);
glVertex2f(bottomRight.x, bottomRight.y);
glVertex2f(bottomRight.x, bottomRight.y);
glVertex2f(topLeft.x, bottomRight.y);
glVertex2f(topLeft.x, bottomRight.y);
glVertex2f(topLeft.x, topLeft.y);
*/
}
glEnd();
break;
}
glTranslatef(-offsetPosition.x, -offsetPosition.y,0);
#endif
//glDisable(GL_BLEND);
}
/*
// FOR EDGES
if (position.y > collisionShape.getY1() - radius && position.y < collisionShape.getY2() + radius)
{
float dist = collisionShape.getX1() - position.x;
if (dist > 0 && dist < radius)
{
c.collided = true;
c.overlap = Vector(radius - dist,0);
}
else if (dist < 0 && -dist < radius)
{
c.collided = true;
c.overlap = -Vector(radius - (-dist),0);
}
}
if (!c.collided)
{
if (position.y > collisionShape.getY1() - radius && position.y < collisionShape.getY2() + radius)
{
float dist = collisionShape.getX2() - position.x;
if (dist > 0 && dist < radius)
{
c.collided = true;
c.overlap += Vector(radius - dist,0);
}
else if (dist < 0 && -dist < radius)
{
c.collided = true;
c.overlap += -Vector(radius - (-dist),0);
}
}
}
*/
CollisionResult CollisionShape::collideCircleWithAABB(CollisionShape &collisionShape, float x, float y, int oH, int oV)
{
CollisionResult c;
if(oH == 0)
{
if(oV == 0)
{
//collision with current cell
if(x < y)
{
//penetration in x is smaller; project in x
float dx = position.x - collisionShape.position.x;//get sign for projection along x-axis
// msg("oH==0, oV ==0, x <y");
//NOTE: should we handle the delta == 0 case?! and how? (project towards oldpos?)
if(dx < 0)
{
c.reportCollision(Vector(-x, 0));
return c;
}
else
{
c.reportCollision(Vector(x,0));
return c;
}
}
else
{
// msg("oH==0, oV ==0, x >= y");
//penetration in y is smaller; project in y
float dy = position.y - collisionShape.position.y;//get sign for projection along y-axis
//NOTE: should we handle the delta == 0 case?! and how? (project towards oldpos?)
if(dy < 0)
{
c.reportCollision(Vector(0, -y));
return c;
}
else
{
c.reportCollision(Vector(0, y));
return c;
}
}
}
else
{
// msg ("oH == 0, oV != 0");
c.reportCollision(Vector(0, y*oV));
return c;
}
}
else if(oV == 0)
{
// msg ("oV == 0");
c.reportCollision(Vector(x*oH,0));
return c;
}
else
{
//diagonal collision
//get diag vertex position
float vx = collisionShape.position.x + (oH*collisionShape.xw);
float vy = collisionShape.position.y + (oV*collisionShape.yw);
float dx = position.x - vx - 1;//calc vert->circle vector
float dy = position.y - vy - 1;
float len = sqrtf(dx*dx + dy*dy);
float pen = radius - len;
if(0 < pen)
{
//vertex is in the circle; project outward
if(len == 0)
{
//project out by 45deg
dx = oH / SQRT2;
dy = oV / SQRT2;
}
else
{
dx /= len;
dy /= len;
}
c.reportCollision(Vector(dx*pen, dy*pen));
//obj.ReportCollisionVsWorld(dx*pen, dy*pen, dx, dy, t);
return c;
}
}
return c;
}
bool CollisionShape::isPointWithin(Vector point)
{
switch (this->getType())
{
case CIRCLE:
{
Vector dist = point - this->position;
return (dist.getSquaredLength2D() < sqr(this->radius));
}
break;
case AABB:
{
if (point.x < position.x + xw && point.y < position.y + yw)
{
if (point.x > position.x - xw && point.y > position.y - yw)
{
return true;
}
}
}
break;
}
return false;
}
CollisionResult CollisionShape::collideCircleWithTopHalfCircle(CollisionShape &collisionShape)
{
CollisionResult c;
Vector dist = collisionShape.position - position;
float len = dist.getLength2D();
float totalDist = (radius + collisionShape.radius);
//which edge did we hit?
if (collisionShape.position.y > (position.y - (radius/2)))
{
if (len < collisionShape.radius)
{
c.collided = true;
c.overlap = Vector(0, position.y - (collisionShape.position.y - collisionShape.radius));
}
}
else if (len < totalDist && dist.y > 0)
{
c.collided = true;
dist.setLength2D(totalDist - len);
c.overlap = dist;
}
else
{
c.collided = false;
}
return c;
}