mirror of
https://github.com/AquariaOSE/Aquaria.git
synced 2024-11-29 03:33:48 +00:00
443 lines
8.7 KiB
C++
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;
|
|
}
|