266 lines
7.3 KiB
C
266 lines
7.3 KiB
C
#include "lephisto.h"
|
|
#include "log.h"
|
|
#include "collision.h"
|
|
|
|
/**
|
|
*
|
|
* @fn CollideSprite(const glTexture* at, const int asx, const int asy,
|
|
* const Vec2* ap, const glTexture* bt,
|
|
* const int bsx, const int bsy, const Vec2* bp,
|
|
* Vec2* crash)
|
|
*
|
|
* @brief Check whether or not sprites collide.
|
|
*
|
|
* This function does pixel perfect checks. If the collision actually accurs,
|
|
* crash is set to store the real position of the collision.
|
|
*
|
|
* @param[in] at - Texture a.
|
|
* @param[in] asx - Position of x of sprite a.
|
|
* @param[in] asy - Position of y of sprite a.
|
|
* @param[in] ap - Position in space of sprite a.
|
|
* @param[in] bt - Texture b.
|
|
* @param[in] bsx - Position of x of sprite b.
|
|
* @param[in] bsy - Position of y of sprite b.
|
|
* @param[in] bp - Position in space of sprite b.
|
|
* @param[out] crash - Actual position of the collision (only on collision).
|
|
* @return 1 on collision, 0 else.
|
|
*/
|
|
int CollideSprite(const glTexture* at, const int asx, const int asy,
|
|
const Vec2* ap, const glTexture* bt,
|
|
const int bsx, const int bsy, const Vec2* bp,
|
|
Vec2* crash) {
|
|
|
|
int x,y;
|
|
int ax1, ax2, ay1, ay2;
|
|
int bx1, bx2, by1, by2;
|
|
int inter_x0, inter_x1, inter_y0, inter_y1;
|
|
int rasy, rbsy;
|
|
int abx, aby, bbx, bby;
|
|
|
|
/* a - cube coords. */
|
|
ax1 = (int)VX(*ap) - (int)(at->sw)/2;
|
|
ay1 = (int)VY(*ap) - (int)(at->sh)/2;
|
|
ax2 = ax1 + (int)(at->sw) - 1;
|
|
ay2 = ay1 + (int)(at->sh) - 1;
|
|
|
|
/* b - cube coords. */
|
|
bx1 = (int)VX(*bp) - (int)(bt->sw)/2;
|
|
by1 = (int)VY(*bp) - (int)(bt->sh)/2;
|
|
bx2 = bx1 + (int)(bt->sw) - 1;
|
|
by2 = by1 + (int)(bt->sh) - 1;
|
|
|
|
/* Check if bounding boxes intersect. */
|
|
if((bx2 < ax1) || (ax2 < bx1)) return 0;
|
|
if((by2 < ay1) || (ay2 < by1)) return 0;
|
|
|
|
/* Define the remaining binding box. */
|
|
inter_x0 = MAX(ax1, bx1);
|
|
inter_x1 = MIN(ax2, bx2);
|
|
inter_y0 = MAX(ay1, by1);
|
|
inter_y1 = MIN(ay2, by2);
|
|
|
|
/* Real vertical sprite value (flipped). */
|
|
rasy = at->sy - asy - 1;
|
|
rbsy = bt->sy - bsy - 1;
|
|
|
|
/* Set up the base points. */
|
|
abx = asx*(int)(at->sw) - ax1;
|
|
aby = rasy*(int)(at->sh) - ay1;
|
|
bbx = bsx*(int)(bt->sw) - bx1;
|
|
bby = rbsy*(int)(bt->sh) - by1;
|
|
|
|
for(y = inter_y0; y <= inter_y1; y++)
|
|
for(x = inter_x0; x <= inter_x1; x++)
|
|
/* Compute offsets for surface before passing to TransparentPixel test. */
|
|
if((!gl_isTrans(at, abx + x, aby + y)) &&
|
|
(!gl_isTrans(bt, bbx + x, bby + y))) {
|
|
|
|
/* Set the crash position. */
|
|
crash->x = x;
|
|
crash->y = y;
|
|
return 1;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* @fn int CollideLineLine(double s1x, double s1y, double e1x, double e1y,
|
|
* double s2x, double s2y, double e2x, double e2y) {
|
|
*
|
|
* @brief Check to see if two lines collide.
|
|
* @param[in] s1 .......
|
|
*/
|
|
int CollideLineLine(double s1x, double s1y, double e1x, double e1y,
|
|
double s2x, double s2y, double e2x, double e2y, Vec2* crash) {
|
|
|
|
double ua_t, ub_t, u_b;
|
|
double ua, ub;
|
|
|
|
ua_t = (e2x - s2x) * (s1y - s2y) - (e2y - s2y) * (s1x - s2x);
|
|
ub_t = (e1x - s1x) * (s1y - s2y) - (e1y - s1y) * (s1x - s2x);
|
|
u_b = (e2y - s2y) * (e1x - s1x) - (e2x - s2x) * (e1y - s1y);
|
|
|
|
if(u_b != 0.) {
|
|
ua = ua_t / u_b;
|
|
ub = ub_t / u_b;
|
|
|
|
/* Intersection at a point. */
|
|
if((0. <= ua) && (ua <= 1.) && (0. <= ub) && (ub <= 1.)) {
|
|
crash->x = s1x + ua * (e1x - s1x);
|
|
crash->y = s1y + ua * (e1y - s1y);
|
|
return 1;
|
|
} else
|
|
return 0;
|
|
} else {
|
|
/* Coincidence. */
|
|
if((ua_t == 0.) || (ub_t == 0.))
|
|
return 3;
|
|
/* Parallel. */
|
|
else
|
|
return 2;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @fn int CollideLineSprite(const Vec2* ap, double dir,
|
|
* const glTexture* bt, const int bsx, const int bsy,
|
|
* const Vec2& bp, Vec2* crash)
|
|
*
|
|
* @param[in] ap Origin of the line.
|
|
* @param[in] ad Direction of the line.
|
|
* @param[in] bt Texture b.
|
|
* @param[in] bsx Position of x of sprite b.
|
|
* @param[in] bsy Position of y of sprite b
|
|
* @param[in] bp Position in space of sprite b.
|
|
* @return 1 on Collision, else 0.
|
|
*
|
|
* @sa CollideSprite
|
|
*/
|
|
int CollideLineSprite(const Vec2* ap, double ad, double al,
|
|
const glTexture* bt, const int bsx, const int bsy, const Vec2* bp,
|
|
Vec2* crash) {
|
|
|
|
int x, y, rbsy, bbx, bby;
|
|
double ep[2], bl[2], tr[2], v[2], mod;
|
|
int hits, real_hits;
|
|
Vec2 tmp_crash, border[2];
|
|
|
|
/* Set up end point of line. */
|
|
ep[0] = ap->x + al*cos(ad);
|
|
ep[1] = ap->y + al*sin(ad);
|
|
|
|
/* Set up top right corner of the rectangle. */
|
|
tr[0] = bp->x + bt->sw/2.;
|
|
tr[1] = bp->y + bt->sh/2.;
|
|
|
|
/* Set up bottom left corner of the rectangle. */
|
|
bl[0] = bp->x - bt->sw/2.;
|
|
bl[1] = bp->y - bt->sh/2.;
|
|
|
|
/* Start check for rectangular collision. */
|
|
hits = 0;
|
|
|
|
/* Left border. */
|
|
if(CollideLineLine(ap->x, ap->y, ep[0], ep[1],
|
|
bl[0], bl[1], bl[0], tr[1], &tmp_crash) != 0) {
|
|
border[hits].x = tmp_crash.x;
|
|
border[hits].y = tmp_crash.y;
|
|
hits++;
|
|
}
|
|
/* Top border. */
|
|
if(CollideLineLine(ap->x, ap->y, ep[0], ep[1],
|
|
bl[0], tr[1], tr[0], tr[1], &tmp_crash) != 0) {
|
|
border[hits].x = tmp_crash.x;
|
|
border[hits].y = tmp_crash.y;
|
|
hits++;
|
|
}
|
|
/* Now we are going to have to make sure hits isn't 2. */
|
|
/* Right border. */
|
|
if((hits < 2) && CollideLineLine(ap->x, ap->y, ep[0], ep[1],
|
|
tr[0], tr[1], tr[0], bl[1], &tmp_crash) != 0) {
|
|
border[hits].x = tmp_crash.x;
|
|
border[hits].y = tmp_crash.y;
|
|
hits++;
|
|
}
|
|
/* Bottom border. */
|
|
if((hits < 2) && CollideLineLine(ap->x, ap->y, ep[0], ep[1],
|
|
tr[0], bl[1], bl[0], bl[1], &tmp_crash) != 0) {
|
|
border[hits].x = tmp_crash.x;
|
|
border[hits].y = tmp_crash.y;
|
|
hits++;
|
|
}
|
|
|
|
/* No hits - missed. */
|
|
if(hits == 2)
|
|
return 0;
|
|
|
|
/* Beam must die in the rectangle. */
|
|
if(hits == 1) {
|
|
border[1].x = ep[0];
|
|
border[1].y = ep[1];
|
|
}
|
|
|
|
/* Now we do a pixel perfect approach. */
|
|
real_hits = 0;
|
|
/* directional vector (normalised). */
|
|
v[0] = border[1].x - border[0].x;
|
|
v[1] = border[1].y - border[0].y;
|
|
/* Normalize. */
|
|
mod = MOD(v[0], v[1])/2.; /* Multiply by two to reduce check amount. */
|
|
v[0] /= mod;
|
|
v[1] /= mod;
|
|
|
|
/* Real vertical sprite value (flipped). */
|
|
rbsy = bt->sy - bsy - 1;
|
|
/* Set up the base points. */
|
|
bbx = bsx*(int)(bt->sw);
|
|
bby = rbsy*(int)(bt->sh);
|
|
|
|
|
|
/* We start checking first border until we find collision. */
|
|
x = border[0].x - bl[0] + v[0];
|
|
y = border[0].y - bl[1] + v[1];
|
|
while((x > 0.) && (x < bt->sw) && (y > 0.) && (y < bt->sh)) {
|
|
/* Is non-transparent. */
|
|
if(!gl_isTrans(bt, bbx+(int)x, bby+(int)y)) {
|
|
crash[real_hits].x = x + bl[0];
|
|
crash[real_hits].y = y + bl[1];
|
|
real_hits++;
|
|
break;
|
|
}
|
|
x += v[0];
|
|
y += v[1];
|
|
}
|
|
|
|
/* Now we check the second border. */
|
|
x = border[1].x - bl[0] - v[0];
|
|
y = border[1].y - bl[1] - v[1];
|
|
while((x > 0.) && (x < bt->sw) && (y > 0.) && (y < bt->sh)) {
|
|
/* Is non-transparent. */
|
|
if(!gl_isTrans(bt, bbx+(int)x, bby+(int)y)) {
|
|
crash[real_hits].x = x + bl[0];
|
|
crash[real_hits].y = y + bl[1];
|
|
real_hits++;
|
|
break;
|
|
}
|
|
x -= v[0];
|
|
y -= v[1];
|
|
}
|
|
|
|
/* Actually missed. */
|
|
if(real_hits == 0)
|
|
return 0;
|
|
|
|
/* Strange situation, should never happen, but just in case we duplicate
|
|
* the hits. */
|
|
if(real_hits == 1) {
|
|
crash[1].x = crash[0].x;
|
|
crash[1].y = crash[0].y;
|
|
}
|
|
|
|
/* We hit! */
|
|
return 1;
|
|
}
|
|
|