Colisiones 2D

Funciones

bool_t	col2d_point_point (...)
bool_t	col2d_segment_point (...)
bool_t	col2d_segment_segment (...)
bool_t	col2d_circle_point (...)
bool_t	col2d_circle_segment (...)
bool_t	col2d_circle_circle (...)
bool_t	col2d_box_point (...)
bool_t	col2d_box_segment (...)
bool_t	col2d_box_circle (...)
bool_t	col2d_box_box (...)
bool_t	col2d_obb_point (...)
bool_t	col2d_obb_segment (...)
bool_t	col2d_obb_circle (...)
bool_t	col2d_obb_box (...)
bool_t	col2d_obb_obb (...)
bool_t	col2d_tri_point (...)
bool_t	col2d_tri_segment (...)
bool_t	col2d_tri_circle (...)
bool_t	col2d_tri_box (...)
bool_t	col2d_tri_obb (...)
bool_t	col2d_tri_tri (...)
bool_t	col2d_poly_point (...)
bool_t	col2d_poly_segment (...)
bool_t	col2d_poly_circle (...)
bool_t	col2d_poly_box (...)
bool_t	col2d_poly_obb (...)
bool_t	col2d_poly_tri (...)
bool_t	col2d_poly_poly (...)

La detección de colisiones se encarga de estudiar y desarrollar algoritmos que comprueben si dos objetos geométricos intersectan en algún punto. Como el caso general sería bastante complejo de implementar e ineficiente de evaluar, se definen una serie de volúmenes de colisión (Figura 1) que encerrarán los conjuntos originales y donde los tests se pueden simplificar notablemente. Al uso de estas formas más elementales normalmente se le conoce como broad phase collision detection (Figura 2), ya que persigue detectar la "no colisión" lo más rápido posible.

Utiliza col2d_poly_obbf para detectar la colisión entre una caja orientada y un polígono.
Utiliza col2d_tri_trif para detectar la colisión entre dos triángulos.
Utiliza col2d_circle_segmentf para detectar la colisión entre un círculo y un segmento.

Dibujo de varios volúmenes de colisión en el plano. — Figura 1: Volúmenes de colisión 2D: Punto, segmento, círculo, caja, caja orientada, triángulo y polígono.

Dibujo de varios volúmenes de colisión que intersectan en el plano. — Figura 2: Detección de colisiones broad phase.

Col2D proporciona funciones para chequear cada par de los volúmenes de colisión presentados con anterioridad. Gran parte de estos métodos utilizan el Teorema del Eje de Separación (Separating Axis Theorem) (Figura 3). Este teorema indica, en esencia, que si es posible encontrar una línea donde las proyecciones de los vértices no intersectan, entonces las figuras no intersectan. En el caso concreto de polígonos convexos, tan solo es necesario evaluar n líneas, donde n es el número de lados del polígono.

Dibujo de dos polígonos colisionando en el plano. — Figura 3: Teorema del eje de separación detectando una colisión.

col2d_point_point ()

Colisión punto-punto.

bool_t
col2d_point_pointf(const V2Df *pnt1,
                   const V2Df *pnt2,
                   const real32_t tol,
                   Col2Df *col);

bool_t
col2d_point_pointd(const V2Dd *pnt1,
                   const V2Dd *pnt2,
                   const real64_t tol,
                   Col2Dd *col);

bool_t
Col2D::point_point(const V2D *pnt1,
                   const V2D *pnt2,
                   const real tol,
                   Col2D *col);

pnt1	Primer punto.
pnt2	Segundo punto.
tol	Tolerancia. Distancia mínima para que se considere colisión.
col	Datos pormenorizados de la colisión. Puede ser `NULL` si no necesitamos información adicional.

Retorna

TRUE si los objectos intersectan, FALSE si no.

col2d_segment_point ()

Colisión segmento-punto.

bool_t
col2d_segment_pointf(const Seg2Df *seg,
                     const V2Df *pnt,
                     const real32_t tol,
                     Col2Df *col);

bool_t
col2d_segment_pointd(const Seg2Dd *seg,
                     const V2Dd *pnt,
                     const real64_t tol,
                     Col2Dd *col);

bool_t
Col2D::segment_point(const Seg2D *seg,
                     const V2D *pnt,
                     const real tol,
                     Col2D *col);

seg	Segmento.
pnt	Punto.
tol	Tolerancia. Distancia mínima para que se considere colisión.
col	Datos pormenorizados de la colisión. Puede ser `NULL` si no necesitamos información adicional.

Retorna

TRUE si los objectos intersectan, FALSE si no.

col2d_segment_segment ()

Colisión segmento-segmento.

bool_t
col2d_segment_segmentf(const Seg2Df *seg1,
                       const Seg2Df *seg2,
                       Col2Df *col);

bool_t
col2d_segment_segmentd(const Seg2Dd *seg1,
                       const Seg2Dd *seg2,
                       Col2Dd *col);

bool_t
Col2D::segment_segment(const Seg2D *seg1,
                       const Seg2D *seg2,
                       Col2D *col);

seg1	Primer segmento.
seg2	Segundo segmento.
col	Datos pormenorizados de la colisión. Puede ser `NULL` si no necesitamos información adicional.

Retorna

TRUE si los objectos intersectan, FALSE si no.

col2d_circle_point ()

Colisión círculo-punto.

bool_t
col2d_circle_pointf(const Cir2Df *cir,
                    const V2Df *pnt,
                    Col2Df *col);

bool_t
col2d_circle_pointd(const Cir2Dd *cir,
                    const V2Dd *pnt,
                    Col2Dd *col);

bool_t
Col2D::circle_point(const Cir2D *cir,
                    const V2D *pnt,
                    Col2D *col);

cir	Círculo.
pnt	Punto.
col	Datos pormenorizados de la colisión. Puede ser `NULL` si no necesitamos información adicional.

Retorna

TRUE si los objectos intersectan, FALSE si no.

col2d_circle_segment ()

Colisión círculo-segmento.

bool_t
col2d_circle_segmentf(const Cir2Df *cir,
                      const Seg2Df *seg,
                      Col2Df *col);

bool_t
col2d_circle_segmentd(const Cir2Dd *cir,
                      const Seg2Dd *seg,
                      Col2Dd *col);

bool_t
Col2D::circle_segment(const Cir2D *cir,
                      const Seg2D *seg,
                      Col2D *col);

cir	Círculo.
seg	Segmento.
col	Datos pormenorizados de la colisión. Puede ser `NULL` si no necesitamos información adicional.

Retorna

TRUE si los objectos intersectan, FALSE si no.

col2d_circle_circle ()

Colisión círculo-círculo.

bool_t
col2d_circle_circlef(const Cir2Df *cir1,
                     const Cir2Df *cir2,
                     Col2Df *col);

bool_t
col2d_circle_circled(const Cir2Dd *cir1,
                     const Cir2Dd *cir2,
                     Col2Dd *col);

bool_t
Col2D::circle_circle(const Cir2D *cir1,
                     const Cir2D *cir2,
                     Col2D *col);

cir1	Primer círculo.
cir2	Segundo círculo.
col	Datos pormenorizados de la colisión. Puede ser `NULL` si no necesitamos información adicional.

Retorna

TRUE si los objectos intersectan, FALSE si no.

col2d_box_point ()

Colisión caja-punto.

bool_t
col2d_box_pointf(const Box2Df *box,
                 const V2Df *pnt,
                 Col2Df *col);

bool_t
col2d_box_pointd(const Box2Dd *box,
                 const V2Dd *pnt,
                 Col2Dd *col);

bool_t
Col2D::box_point(const Box2D *box,
                 const V2D *pnt,
                 Col2D *col);

box	Caja.
pnt	Punto.
col	Datos pormenorizados de la colisión. Puede ser `NULL` si no necesitamos información adicional.

Retorna

TRUE si los objectos intersectan, FALSE si no.

col2d_box_segment ()

Colisión caja-segmento.

bool_t
col2d_box_segmentf(const Box2Df *box,
                   const Seg2Df *seg,
                   Col2Df *col);

bool_t
col2d_box_segmentd(const Box2Dd *box,
                   const Seg2Dd *seg,
                   Col2Dd *col);

bool_t
Col2D::box_segment(const Box2D *box,
                   const Seg2D *seg,
                   Col2D *col);

box	Caja.
seg	Segmento.
col	Datos pormenorizados de la colisión. Puede ser `NULL` si no necesitamos información adicional.

Retorna

TRUE si los objectos intersectan, FALSE si no.

col2d_box_circle ()

Colisión caja-círculo.

bool_t
col2d_box_circlef(const Box2Df *box,
                  const Cir2Df *cir,
                  Col2Df *col);

bool_t
col2d_box_circled(const Box2Dd *box,
                  const Cir2Dd *cir,
                  Col2Dd *col);

bool_t
Col2D::box_circle(const Box2D *box,
                  const Cir2D *cir,
                  Col2D *col);

box	Caja.
cir	Círculo.
col	Datos pormenorizados de la colisión. Puede ser `NULL` si no necesitamos información adicional.

Retorna

TRUE si los objectos intersectan, FALSE si no.

col2d_box_box ()

Colisión caja-caja.

bool_t
col2d_box_boxf(const Box2Df *box1,
               const Box2Df *box2,
               Col2Df *col);

bool_t
col2d_box_boxd(const Box2Dd *box1,
               const Box2Dd *box2,
               Col2Dd *col);

bool_t
Col2D::box_box(const Box2D *box1,
               const Box2D *box2,
               Col2D *col);

box1	Primera caja.
box2	Segunda caja.
col	Datos pormenorizados de la colisión. Puede ser `NULL` si no necesitamos información adicional.

Retorna

TRUE si los objectos intersectan, FALSE si no.

col2d_obb_point ()

Colisión caja orientada-punto.

bool_t
col2d_obb_pointf(const OBB2Df *obb,
                 const V2Df *pnt,
                 Col2Df *col);

bool_t
col2d_obb_pointd(const OBB2Dd *obb,
                 const V2Dd *pnt,
                 Col2Dd *col);

bool_t
Col2D::obb_point(const OBB2D *obb,
                 const V2D *pnt,
                 Col2D *col);

obb	Caja orientada.
pnt	Punto.
col	Datos pormenorizados de la colisión. Puede ser `NULL` si no necesitamos información adicional.

Retorna

TRUE si los objectos intersectan, FALSE si no.

col2d_obb_segment ()

Colisión caja orientada-segmento.

bool_t
col2d_obb_segmentf(const OBB2Df *obb,
                   const Seg2Df *seg,
                   Col2Df *col);

bool_t
col2d_obb_segmentd(const OBB2Dd *obb,
                   const Seg2Dd *seg,
                   Col2Dd *col);

bool_t
Col2D::obb_segment(const OBB2D *obb,
                   const Seg2D *seg,
                   Col2D *col);

obb	Caja orientada.
seg	Segmento.
col	Datos pormenorizados de la colisión. Puede ser `NULL` si no necesitamos información adicional.

Retorna

TRUE si los objectos intersectan, FALSE si no.

col2d_obb_circle ()

Colisión caja orientada-circle.

bool_t
col2d_obb_circlef(const OBB2Df *obb,
                  const Cir2Df *cir,
                  Col2Df *col);

bool_t
col2d_obb_circled(const OBB2Dd *obb,
                  const Cir2Dd *cir,
                  Col2Dd *col);

bool_t
Col2D::obb_circle(const OBB2D *obb,
                  const Cir2D *cir,
                  Col2D *col);

obb	Caja orientada.
cir	Círculo.
col	Datos pormenorizados de la colisión. Puede ser `NULL` si no necesitamos información adicional.

Retorna

TRUE si los objectos intersectan, FALSE si no.

col2d_obb_box ()

Colisión caja orientada-caja.

bool_t
col2d_obb_boxf(const OBB2Df *obb,
               const Box2Df *box,
               Col2Df *col);

bool_t
col2d_obb_boxd(const OBB2Dd *obb,
               const Box2Dd *box,
               Col2Dd *col);

bool_t
Col2D::obb_box(const OBB2D *obb,
               const Box2D *box,
               Col2D *col);

obb	Caja orientada.
box	Caja alineada.
col	Datos pormenorizados de la colisión. Puede ser `NULL` si no necesitamos información adicional.

Retorna

TRUE si los objectos intersectan, FALSE si no.

col2d_obb_obb ()

Colisión caja orientada-caja orientada.

bool_t
col2d_obb_obbf(const OBB2Df *obb1,
               const OBB2Df *obb2,
               Col2Df *col);

bool_t
col2d_obb_obbd(const OBB2Dd *obb1,
               const OBB2Dd *obb2,
               Col2Dd *col);

bool_t
Col2D::obb_obb(const OBB2D *obb1,
               const OBB2D *obb2,
               Col2D *col);

obb1	Primera caja orientada.
obb2	Segunda caja orientada.
col	Datos pormenorizados de la colisión. Puede ser `NULL` si no necesitamos información adicional.

Retorna

TRUE si los objectos intersectan, FALSE si no.

col2d_tri_point ()

Colisión triángulo-punto.

bool_t
col2d_tri_pointf(const Tri2Df *tri,
                 const V2Df *pnt,
                 Col2Df *col);

bool_t
col2d_tri_pointd(const Tri2Dd *tri,
                 const V2Dd *pnt,
                 Col2Dd *col);

bool_t
Col2D::tri_point(const Tri2D *tri,
                 const V2D *pnt,
                 Col2D *col);

tri	Triángulo.
pnt	Punto.
col	Datos pormenorizados de la colisión. Puede ser `NULL` si no necesitamos información adicional.

Retorna

TRUE si los objectos intersectan, FALSE si no.

col2d_tri_segment ()

Colisión triángulo-segmento.

bool_t
col2d_tri_segmentf(const Tri2Df *tri,
                   const Seg2Df *seg,
                   Col2Df *col);

bool_t
col2d_tri_segmentd(const Tri2Dd *tri,
                   const Seg2Dd *seg,
                   Col2Dd *col);

bool_t
Col2D::tri_segment(const Tri2D *tri,
                   const Seg2D *seg,
                   Col2D *col);

tri	Triángulo.
seg	Segmento.
col	Datos pormenorizados de la colisión. Puede ser `NULL` si no necesitamos información adicional.

Retorna

TRUE si los objectos intersectan, FALSE si no.

col2d_tri_circle ()

Colisión triángulo-círculo.

bool_t
col2d_tri_circlef(const Tri2Df *tri,
                  const Cir2Df *cir,
                  Col2Df *col);

bool_t
col2d_tri_circled(const Tri2Dd *tri,
                  const Cir2Dd *cir,
                  Col2Dd *col);

bool_t
Col2D::tri_circle(const Tri2D *tri,
                  const Cir2D *cir,
                  Col2D *col);

tri	Triángulo.
cir	Círculo.
col	Datos pormenorizados de la colisión. Puede ser `NULL` si no necesitamos información adicional.

Retorna

TRUE si los objectos intersectan, FALSE si no.

col2d_tri_box ()

Colisión triángulo-caja.

bool_t
col2d_tri_boxf(const Tri2Df *tri,
               const Box2Df *box,
               Col2Df *col);

bool_t
col2d_tri_boxd(const Tri2Dd *tri,
               const Box2Dd *box,
               Col2Dd *col);

bool_t
Col2D::tri_box(const Tri2D *tri,
               const Box2D *box,
               Col2D *col);

tri	Triángulo.
box	Caja alineada.
col	Datos pormenorizados de la colisión. Puede ser `NULL` si no necesitamos información adicional.

Retorna

TRUE si los objectos intersectan, FALSE si no.

col2d_tri_obb ()

Colisión triángulo-caja orientada.

bool_t
col2d_tri_obbf(const Tri2Df *tri,
               const OBB2Df *obb,
               Col2Df *col);

bool_t
col2d_tri_obbd(const Tri2Dd *tri,
               const OBB2Dd *obb,
               Col2Dd *col);

bool_t
Col2D::tri_obb(const Tri2D *tri,
               const OBB2D *obb,
               Col2D *col);

tri	Triángulo.
obb	Caja orientada.
col	Datos pormenorizados de la colisión. Puede ser `NULL` si no necesitamos información adicional.

Retorna

TRUE si los objectos intersectan, FALSE si no.

col2d_tri_tri ()

Colisión triángulo-triángulo.

bool_t
col2d_tri_trif(const Tri2Df *tri1,
               const Tri2Df *tri2,
               Col2Df *col);

bool_t
col2d_tri_trid(const Tri2Dd *tri1,
               const Tri2Dd *tri2,
               Col2Dd *col);

bool_t
Col2D::tri_tri(const Tri2D *tri1,
               const Tri2D *tri2,
               Col2D *col);

tri1	Primer triángulo.
tri2	Segundo triángulo.
col	Datos pormenorizados de la colisión. Puede ser `NULL` si no necesitamos información adicional.

Retorna

TRUE si los objectos intersectan, FALSE si no.

col2d_poly_point ()

Colisión polígono-punto.

bool_t
col2d_poly_pointf(const Pol2Df *pol,
                  const V2Df *pnt,
                  Col2Df *col);

bool_t
col2d_poly_pointd(const Pol2Dd *pol,
                  const V2Dd *pnt,
                  Col2Dd *col);

bool_t
Col2D::poly_point(const Pol2D *pol,
                  const V2D *pnt,
                  Col2D *col);

pol	Polígono.
pnt	Punto.
col	Datos pormenorizados de la colisión. Puede ser `NULL` si no necesitamos información adicional.

Retorna

TRUE si los objectos intersectan, FALSE si no.

col2d_poly_segment ()

Colisión polígono-segmento.

bool_t
col2d_poly_segmentf(const Pol2Df *pol,
                    const Seg2Df *seg,
                    Col2Df *col);

bool_t
col2d_poly_segmentd(const Pol2Dd *pol,
                    const Seg2Dd *seg,
                    Col2Dd *col);

bool_t
Col2D::poly_segment(const Pol2D *pol,
                    const Seg2D *seg,
                    Col2D *col);

pol	Polígono.
seg	Segmento.
col	Datos pormenorizados de la colisión. Puede ser `NULL` si no necesitamos información adicional.

Retorna

TRUE si los objectos intersectan, FALSE si no.

col2d_poly_circle ()

Colisión polígono-círculo.

bool_t
col2d_poly_circlef(const Pol2Df *pol,
                   const Cir2Df *cir,
                   Col2Df *col);

bool_t
col2d_poly_circled(const Pol2Dd *pol,
                   const Cir2Dd *cir,
                   Col2Dd *col);

bool_t
Col2D::poly_circle(const Pol2D *pol,
                   const Cir2D *cir,
                   Col2D *col);

pol	Polígono.
cir	Círculo.
col	Datos pormenorizados de la colisión. Puede ser `NULL` si no necesitamos información adicional.

Retorna

TRUE si los objectos intersectan, FALSE si no.

col2d_poly_box ()

Colisión polígono-caja.

bool_t
col2d_poly_boxf(const Pol2Df *pol,
                const Box2Df *cir,
                Col2Df *col);

bool_t
col2d_poly_boxd(const Pol2Dd *pol,
                const Box2Dd *cir,
                Col2Dd *col);

bool_t
Col2D::poly_box(const Pol2D *pol,
                const Box2D *cir,
                Col2D *col);

pol	Polígono.
cir	Caja.
col	Datos pormenorizados de la colisión. Puede ser `NULL` si no necesitamos información adicional.

Retorna

TRUE si los objectos intersectan, FALSE si no.

col2d_poly_obb ()

Colisión polígono-caja.

bool_t
col2d_poly_obbf(const Pol2Df *pol,
                const OBB2Df *cir,
                Col2Df *col);

bool_t
col2d_poly_obbd(const Pol2Dd *pol,
                const OBB2Dd *cir,
                Col2Dd *col);

bool_t
Col2D::poly_obb(const Pol2D *pol,
                const OBB2D *cir,
                Col2D *col);

pol	Polígono.
cir	Caja orientada.
col	Datos pormenorizados de la colisión. Puede ser `NULL` si no necesitamos información adicional.

Retorna

TRUE si los objectos intersectan, FALSE si no.

col2d_poly_tri ()

Colisión polígono-triángulo.

bool_t
col2d_poly_trif(const Pol2Df *pol,
                const Tri2Df *tri,
                Col2Df *col);

bool_t
col2d_poly_trid(const Pol2Dd *pol,
                const Tri2Dd *tri,
                Col2Dd *col);

bool_t
Col2D::poly_tri(const Pol2D *pol,
                const Tri2D *tri,
                Col2D *col);

pol	Polígono.
tri	Triángulo.
col	Datos pormenorizados de la colisión. Puede ser `NULL` si no necesitamos información adicional.

Retorna

TRUE si los objectos intersectan, FALSE si no.

col2d_poly_poly ()

Colisión polígono-polígono.

bool_t
col2d_poly_polyf(const Pol2Df *pol1,
                 const Pol2Df *pol2,
                 Col2Df *col);

bool_t
col2d_poly_polyd(const Pol2Dd *pol1,
                 const Pol2Dd *pol2,
                 Col2Dd *col);

bool_t
Col2D::poly_poly(const Pol2D *pol1,
                 const Pol2D *pol2,
                 Col2D *col);

pol1	Primer polígono.
pol2	Segundo polígono.
col	Datos pormenorizados de la colisión. Puede ser `NULL` si no necesitamos información adicional.

Retorna

TRUE si los objectos intersectan, FALSE si no.