SAT分离轴--判断两个形状是否相交给出MTV

02

// loop over the axes

03

for (int i = 0; i < axes.length; i++) {

04

  Axis axis = axes[i];

05

  // project both shapes onto the axis

06

  Projection p1 = shape1.project(axis);

07

  Projection p2 = shape2.project(axis);

08

  // do the projections overlap?

09

  if (!p1.overlap(p2)) {

10

    // then we can guarantee that the shapes do not overlap

11

    return false;

12

  }

13

}

01

Axis[] axes = // get the axes to test;

02

// loop over the axes

03

for (int i = 0; i < axes.length; i++) {

04

  Axis axis = axes[i];

05

  // project both shapes onto the axis

06

  Projection p1 = shape1.project(axis);

07

  Projection p2 = shape2.project(axis);

08

  // do the projections overlap?

09

  if (!p1.overlap(p2)) {

10

    // then we can guarantee that the shapes do not overlap

11

    return false;

12

  }

13

}

14

// if we get here then we know that every axis had overlap on it

15

// so we can guarantee an intersection

16

return true;

01

Vector[] axes = new Vector[shape.vertices.length];

02

// loop over the vertices

03

for (int i = 0; i < shape.vertices.length; i++) {

04

  // get the current vertex

05

  Vector p1 = shape.vertices[i];

06

  // get the next vertex

07

  Vector p2 = shape.vertices[i + 1 == shape.vertices.length ? 0 : i + 1];

08

  // subtract the two to get the edge vector

09

  Vector edge = p1.subtract(p2);

10

  // get either perpendicular vector

11

  Vector normal = edge.perp();

12

  // the perp method is just (x, y) => (-y, x) or (y, -x)

13

  axes[i] = normal;

14

}

01

Axis[] axes1 = shape1.getAxes();

02

Axis[] axes2 = shape2.getAxes();

03

// loop over the axes1

04

for (int i = 0; i < axes1.length; i++) {

05

  Axis axis = axes1[i];

06

  // project both shapes onto the axis

07

  Projection p1 = shape1.project(axis);

08

  Projection p2 = shape2.project(axis);

09

  // do the projections overlap?

10

  if (!p1.overlap(p2)) {

11

    // then we can guarantee that the shapes do not overlap

12

    return false;

13

  }

14

}

15

// loop over the axes2

16

for (int i = 0; i < axes2.length; i++) {

17

  Axis axis = axes2[i];

18

  // project both shapes onto the axis

19

  Projection p1 = shape1.project(axis);

20

  Projection p2 = shape2.project(axis);

21

  // do the projections overlap?

22

  if (!p1.overlap(p2)) {

23

    // then we can guarantee that the shapes do not overlap

24

    return false;

25

  }

26

}

27

// if we get here then we know that every axis had overlap on it

28

// so we can guarantee an intersection

29

return true;

01

double min = axis.dot(shape.vertices[0]);

02

double max = min;

03

for (int i = 1; i < shape.vertices.length; i++) {

04

  // NOTE: the axis must be normalized to get accurate projections

05

  double p = axis.dot(shape.vertices[i]);

06

  if (p < min) {

07

    min = p;

08

  } else if (p > max) {

09

    max = p;

10

  }

11

}

12

Projection proj = new Projection(min, max);

13

return proj;

01

double overlap = // really large value;

02

Axis smallest = null;

03

Axis[] axes1 = shape1.getAxes();

04

Axis[] axes2 = shape2.getAxes();

05

// loop over the axes1

06

for (int i = 0; i < axes1.length; i++) {

07

  Axis axis = axes1[i];

08

  // project both shapes onto the axis

09

  Projection p1 = shape1.project(axis);

10

  Projection p2 = shape2.project(axis);

11

  // do the projections overlap?

12

  if (!p1.overlap(p2)) {

13

    // then we can guarantee that the shapes do not overlap

14

    return false;

15

  } else {

16

    // get the overlap

17

    double o = p1.getOverlap(p2);

18

    // check for minimum

19

    if (o < overlap) {

20

      // then set this one as the smallest

21

      overlap = o;

22

      smallest = axis;

23

    }

24

  }

25

}

26

// loop over the axes2

27

for (int i = 0; i < axes2.length; i++) {

28

  Axis axis = axes2[i];

29

  // project both shapes onto the axis

30

  Projection p1 = shape1.project(axis);

31

  Projection p2 = shape2.project(axis);

32

  // do the projections overlap?

33

  if (!p1.overlap(p2)) {

34

    // then we can guarantee that the shapes do not overlap

35

    return false;

36

  } else {

37

    // get the overlap

38

    double o = p1.getOverlap(p2);

39

    // check for minimum

40

    if (o < overlap) {

41

      // then set this one as the smallest

42

      overlap = o;

43

      smallest = axis;

44

    }

45

  }

46

}

47

MTV mtv = new MTV(smallest, overlap);

48

// if we get here then we know that every axis had overlap on it

49

// so we can guarantee an intersection

50

return mtv;

Vector c1 = circle1.getCenter();

2

Vector c2 = circle2.getCenter();

3

Vector v = c1.subtract(c2);

4

if (v.getMagnitude() < circle1.getRadius() + circle2.getRadius()) {

5

  // then there is an intersection

6

}

7

// else there isnt

1

Vector[] axes = new Vector[1];

2

if (shape1.isCircle() && shape2.isCircle()) {

3

  // for two circles there is only one axis test

4

  axes[0] = shape1.getCenter().subtract(shape2.getCenter);

5

}

6

// then all the SAT code from above

01

if (!p1.overlap(p2)) {

02

  // then we can guarantee that the shapes do not overlap

03

  return false;

04

} else {

05

  // get the overlap

06

  double o = p1.getOverlap(p2);

07

  // check for containment

08

  if (p1.contains(p2) || p2.contains(p1)) {

09

    // get the overlap plus the distance from the minimum end points

10

    double mins = abs(p1.min - p2.min);

11

    double maxs = abs(p1.max - p2.max);

12

    // NOTE: depending on which is smaller you may need to

13

    // negate the separating axis!!

14

    if (mins < maxs) {

15

      o += mins;

16

    } else {

17

      o += maxs;

18

    }

19

  }

20

  // check for minimum

21

  if (o < overlap) {

22

    // then set this one as the smallest

23

    overlap = o;

24

    smallest = axis;

25

  }