Source: Physics/RigidShape_Collision.js

  1. /* 
  2.  * File: RigidShape_Collision.js
  3.  * Detects RigidPoint collisions
  4.  */
  6. /*jslint node: true, vars:true , white: true*/
  7. /*global RigidShape, vec2, LineRenderable, gEngine, gEngine.Particle */
  8. /* find out more about jslint: http://www.jslint.com/help.html */
  9. "use strict";
  11. /**
  12.  * Clamp value to min and max
  13.  * @param {Number} value to clamp
  14.  * @param {Number} min Minimum value to clamp too
  15.  * @param {Number} max Maximum value to clamp too
  16.  * @returns {Number} clamped number of value
  17.  * @memberOf RigidShape
  18.  */
  19. RigidShape.prototype.clamp = function (value, min, max) {
  20.     return Math.min(Math.max(value, min), max);
  21. };
  23. /**
  24.  * Check for collision between RigidRectangle and RigidCircle
  25.  * @param {RigidRectangle} rect1Shape Rectangle object to check for collision status
  26.  * @param {RigidCircle} circ2Shape Circle object to check for collision status against
  27.  * @param {CollisionInfo} collisionInfo Collision info of collision
  28.  * @returns {Boolean} true if collision occurs
  29.  * @memberOf RigidShape
  30.  */
  31. RigidShape.prototype.collidedRectCirc = function(rect1Shape, circ2Shape, collisionInfo) {
  32.     var rect1Pos = rect1Shape.getXform().getPosition();
  33.     var circ2Pos = circ2Shape.getXform().getPosition();
  34.     var vFrom1to2 = [0, 0];
  35.     vec2.subtract(vFrom1to2, circ2Pos, rect1Pos);
  37.     var vec = vec2.clone(vFrom1to2);
  39.     var alongX = rect1Shape.getWidth() / 2;
  40.     var alongY = rect1Shape.getHeight() / 2;
  42.     vec[0] = this.clamp(vec[0], -alongX, alongX);
  43.     vec[1] = this.clamp(vec[1], -alongY, alongY);
  45.     var isInside = false;
  46.     if (rect1Shape.containsPos(circ2Pos))  {
  47.         isInside = true;
  48.         // Find closest axis
  49.         if (Math.abs(vFrom1to2[0] - alongX) < Math.abs(vFrom1to2[1] - alongY)) {
  50.             // Clamp to closest side
  51.             if (vec[0] > 0) {
  52.                 vec[0] = alongX;
  53.             } else {
  54.                 vec[0] = -alongX;
  55.             }
  56.         } else { // y axis is shorter
  57.             // Clamp to closest side
  58.             if (vec[1] > 0) {
  59.                 vec[1] = alongY;
  60.             } else {
  61.                 vec[1] = -alongY;
  62.             }
  63.         }
  64.     }
  66.     var normal = [0, 0];
  67.     vec2.subtract(normal, vFrom1to2, vec);
  69.     var distSqr = vec2.squaredLength(normal);
  70.     var rSqr = circ2Shape.getRadius() * circ2Shape.getRadius();
  72.     if (distSqr > rSqr && !isInside) {
  73.         return false; //no collision exit before costly square root
  74.     }
  76.     var len = Math.sqrt(distSqr);
  77.     var depth;        
  78.         
  79.     vec2.scale(normal, normal, 1/len); // normalize normal
  80.     if (isInside) { //flip normal if inside the rect
  81.         vec2.scale(normal, normal, -1);
  82.         depth = circ2Shape.getRadius() + len;
  83.     } else {
  84.         depth = circ2Shape.getRadius() - len;
  85.     }
  86.     
  87.     collisionInfo.setNormal(normal);
  88.     collisionInfo.setDepth(depth);
  89.     return true;
  90. };
  92. /**
  93.  * pushes a Particle out of a RigidCircle or a RigidRectangle.
  94.  * @param {Particle} aParticle
  95.  * @returns {Boolean}
  96.  * @memberOf RigidShape
  97.  */
  98. RigidShape.prototype.resolveParticleCollision = function(aParticle) {
  99.     var status = false;
  100.     switch (this.rigidType()) {
  101.         case RigidShape.eRigidType.eRigidCircle:
  102.             status = gEngine.Particle.resolveCirclePos(this, aParticle);
  103.             break;
  104.         case RigidShape.eRigidType.eRigidRectangle:
  105.             status = gEngine.Particle.resolveRectPos(this, aParticle);
  106.             break;
  107.     }
  108.     return status;
  109. };