Alvaro Cassinelli
/
skinGames_forktest
just a test
Fork of scoreLight_Advanced by
classPointMass.cpp@1:a4050fee11f7, 2012-03-31 (annotated)
- Committer:
- mbedalvaro
- Date:
- Sat Mar 31 08:19:31 2012 +0000
- Revision:
- 1:a4050fee11f7
- Parent:
- 0:345b3bc7a0ea
- Child:
- 2:34157ebbf56b
new scorelight methods added. VERY STRANGE problem with oldPos and pos in Verlet method, that have strange behaviour depending on the value of damp factor...
Who changed what in which revision?
User | Revision | Line number | New contents of line |
---|---|---|---|
mbedalvaro | 0:345b3bc7a0ea | 1 | /* |
mbedalvaro | 0:345b3bc7a0ea | 2 | * pointMass.cpp |
mbedalvaro | 0:345b3bc7a0ea | 3 | * laserBlob |
mbedalvaro | 0:345b3bc7a0ea | 4 | * |
mbedalvaro | 0:345b3bc7a0ea | 5 | * Created by CASSINELLI ALVARO on 5/19/11. |
mbedalvaro | 0:345b3bc7a0ea | 6 | * Copyright 2011 TOKYO UNIVERSITY. All rights reserved. |
mbedalvaro | 0:345b3bc7a0ea | 7 | * |
mbedalvaro | 0:345b3bc7a0ea | 8 | */ |
mbedalvaro | 0:345b3bc7a0ea | 9 | |
mbedalvaro | 0:345b3bc7a0ea | 10 | #include "classPointMass.h" |
mbedalvaro | 0:345b3bc7a0ea | 11 | |
mbedalvaro | 0:345b3bc7a0ea | 12 | //------------------------------------------------------------ |
mbedalvaro | 0:345b3bc7a0ea | 13 | pointMass::pointMass(){ |
mbedalvaro | 0:345b3bc7a0ea | 14 | setIntegrationStep(.01); // default in case we don't call integration step setting |
mbedalvaro | 0:345b3bc7a0ea | 15 | // NOTE: it is important to set dt before inital conditions in case of VERLET integration, because we need the integration |
mbedalvaro | 0:345b3bc7a0ea | 16 | // step for properly setting the initial speed. |
mbedalvaro | 0:345b3bc7a0ea | 17 | setInitialCondition(0,0,0,0);// default in case we don't call to initial conditions. |
mbedalvaro | 0:345b3bc7a0ea | 18 | setWallLimits(100,100,4000,4000); |
mbedalvaro | 0:345b3bc7a0ea | 19 | mass=1.0; |
mbedalvaro | 0:345b3bc7a0ea | 20 | dampMotion = 0.0175;//0.025 was good for bigger blobs;//2f;//0.07f; |
mbedalvaro | 0:345b3bc7a0ea | 21 | dampBorder = 0.013f; //0.07f |
mbedalvaro | 0:345b3bc7a0ea | 22 | bFixed = false; |
mbedalvaro | 0:345b3bc7a0ea | 23 | bWallCollision=false; |
mbedalvaro | 0:345b3bc7a0ea | 24 | } |
mbedalvaro | 0:345b3bc7a0ea | 25 | |
mbedalvaro | 0:345b3bc7a0ea | 26 | //------------------------------------------------------------ |
mbedalvaro | 0:345b3bc7a0ea | 27 | void pointMass::resetForce(){ |
mbedalvaro | 0:345b3bc7a0ea | 28 | totalForce.set(0,0); |
mbedalvaro | 0:345b3bc7a0ea | 29 | } |
mbedalvaro | 0:345b3bc7a0ea | 30 | |
mbedalvaro | 0:345b3bc7a0ea | 31 | //------------------------------------------------------------ |
mbedalvaro | 0:345b3bc7a0ea | 32 | void pointMass::addForce(float x, float y){ |
mbedalvaro | 0:345b3bc7a0ea | 33 | totalForce.x = totalForce.x + x; |
mbedalvaro | 0:345b3bc7a0ea | 34 | totalForce.y = totalForce.y + y; |
mbedalvaro | 0:345b3bc7a0ea | 35 | } |
mbedalvaro | 0:345b3bc7a0ea | 36 | |
mbedalvaro | 0:345b3bc7a0ea | 37 | //------------------------------------------------------------ |
mbedalvaro | 0:345b3bc7a0ea | 38 | void pointMass::addForce(vector2D forceToAdd){ |
mbedalvaro | 0:345b3bc7a0ea | 39 | totalForce+=forceToAdd; |
mbedalvaro | 0:345b3bc7a0ea | 40 | } |
mbedalvaro | 0:345b3bc7a0ea | 41 | |
mbedalvaro | 0:345b3bc7a0ea | 42 | //------------------------------------------------------------ |
mbedalvaro | 0:345b3bc7a0ea | 43 | void pointMass::addInvSquareForce(float x, float y, float radiusMin, float radiusMax, float scale){ |
mbedalvaro | 0:345b3bc7a0ea | 44 | |
mbedalvaro | 0:345b3bc7a0ea | 45 | vector2D posOfForce; |
mbedalvaro | 0:345b3bc7a0ea | 46 | posOfForce.set(x,y); |
mbedalvaro | 0:345b3bc7a0ea | 47 | |
mbedalvaro | 0:345b3bc7a0ea | 48 | vector2D diff = pos - posOfForce; // note: we use the position AT TIME T, so this force is at time t |
mbedalvaro | 0:345b3bc7a0ea | 49 | float length = diff.length(); |
mbedalvaro | 0:345b3bc7a0ea | 50 | |
mbedalvaro | 0:345b3bc7a0ea | 51 | // check close enough and far enough (to avoid singularities for example): |
mbedalvaro | 0:345b3bc7a0ea | 52 | if ((length>radiusMin)&&(length<radiusMax)) { |
mbedalvaro | 0:345b3bc7a0ea | 53 | diff.normalize(); |
mbedalvaro | 0:345b3bc7a0ea | 54 | totalForce += diff * scale * 1.0/(length*length+1); |
mbedalvaro | 0:345b3bc7a0ea | 55 | } |
mbedalvaro | 0:345b3bc7a0ea | 56 | } |
mbedalvaro | 0:345b3bc7a0ea | 57 | |
mbedalvaro | 0:345b3bc7a0ea | 58 | void pointMass::addInterInvSquareForce(pointMass &theOtherParticle, float radiusMin, float radiusMax, float scale){ |
mbedalvaro | 0:345b3bc7a0ea | 59 | |
mbedalvaro | 0:345b3bc7a0ea | 60 | vector2D posOfForce; |
mbedalvaro | 0:345b3bc7a0ea | 61 | posOfForce.set(theOtherParticle.pos); |
mbedalvaro | 0:345b3bc7a0ea | 62 | |
mbedalvaro | 0:345b3bc7a0ea | 63 | vector2D diff = pos - posOfForce; // note: we use the position AT TIME T, so this force is at time t |
mbedalvaro | 0:345b3bc7a0ea | 64 | float length = diff.length(); |
mbedalvaro | 0:345b3bc7a0ea | 65 | |
mbedalvaro | 0:345b3bc7a0ea | 66 | // check close enough and far enough (to avoid singularities for example): |
mbedalvaro | 0:345b3bc7a0ea | 67 | if ((length>radiusMin)&&(length<radiusMax)) { |
mbedalvaro | 0:345b3bc7a0ea | 68 | diff.normalize(); |
mbedalvaro | 0:345b3bc7a0ea | 69 | totalForce += diff * scale * 1.0/(length*length+1); |
mbedalvaro | 0:345b3bc7a0ea | 70 | theOtherParticle.totalForce -= diff * scale * 1.0/(length*length+1); |
mbedalvaro | 0:345b3bc7a0ea | 71 | } |
mbedalvaro | 0:345b3bc7a0ea | 72 | } |
mbedalvaro | 0:345b3bc7a0ea | 73 | |
mbedalvaro | 0:345b3bc7a0ea | 74 | |
mbedalvaro | 0:345b3bc7a0ea | 75 | //------------------------------------------------------------ |
mbedalvaro | 0:345b3bc7a0ea | 76 | void pointMass::addSpringForce(float centerx, float centery, float radius, float scale){ |
mbedalvaro | 0:345b3bc7a0ea | 77 | |
mbedalvaro | 0:345b3bc7a0ea | 78 | // ----------- (1) make a vector of where this particle p is: |
mbedalvaro | 0:345b3bc7a0ea | 79 | vector2D posOfForce; |
mbedalvaro | 0:345b3bc7a0ea | 80 | posOfForce.set(centerx, centery); |
mbedalvaro | 0:345b3bc7a0ea | 81 | |
mbedalvaro | 0:345b3bc7a0ea | 82 | // ----------- (2) calculate the difference & length |
mbedalvaro | 0:345b3bc7a0ea | 83 | |
mbedalvaro | 0:345b3bc7a0ea | 84 | vector2D diff = pos - posOfForce; |
mbedalvaro | 0:345b3bc7a0ea | 85 | float length = diff.length(); |
mbedalvaro | 0:345b3bc7a0ea | 86 | |
mbedalvaro | 0:345b3bc7a0ea | 87 | // ----------- (3) check close enough |
mbedalvaro | 0:345b3bc7a0ea | 88 | |
mbedalvaro | 0:345b3bc7a0ea | 89 | bool bAmCloseEnough = true; |
mbedalvaro | 0:345b3bc7a0ea | 90 | if (radius > 0){ |
mbedalvaro | 0:345b3bc7a0ea | 91 | if (length > radius){ |
mbedalvaro | 0:345b3bc7a0ea | 92 | bAmCloseEnough = false; |
mbedalvaro | 0:345b3bc7a0ea | 93 | } |
mbedalvaro | 0:345b3bc7a0ea | 94 | } |
mbedalvaro | 0:345b3bc7a0ea | 95 | |
mbedalvaro | 0:345b3bc7a0ea | 96 | // ----------- (4) if so, update force |
mbedalvaro | 0:345b3bc7a0ea | 97 | |
mbedalvaro | 0:345b3bc7a0ea | 98 | if (bAmCloseEnough == true){ |
mbedalvaro | 0:345b3bc7a0ea | 99 | float pct = 1 - (length / radius); // stronger on the inside |
mbedalvaro | 0:345b3bc7a0ea | 100 | diff.normalize(); |
mbedalvaro | 0:345b3bc7a0ea | 101 | totalForce += diff * scale * pct; |
mbedalvaro | 0:345b3bc7a0ea | 102 | } |
mbedalvaro | 0:345b3bc7a0ea | 103 | } |
mbedalvaro | 0:345b3bc7a0ea | 104 | |
mbedalvaro | 0:345b3bc7a0ea | 105 | void pointMass::addInterSpringForce(pointMass &theOtherParticle, float radius, float scale){ |
mbedalvaro | 0:345b3bc7a0ea | 106 | |
mbedalvaro | 0:345b3bc7a0ea | 107 | // ----------- (1) make a vector of where this particle p is: |
mbedalvaro | 0:345b3bc7a0ea | 108 | vector2D posOfForce; |
mbedalvaro | 0:345b3bc7a0ea | 109 | posOfForce.set(theOtherParticle.pos); |
mbedalvaro | 0:345b3bc7a0ea | 110 | |
mbedalvaro | 0:345b3bc7a0ea | 111 | // ----------- (2) calculate the difference & length |
mbedalvaro | 0:345b3bc7a0ea | 112 | |
mbedalvaro | 0:345b3bc7a0ea | 113 | vector2D diff = pos - posOfForce; |
mbedalvaro | 0:345b3bc7a0ea | 114 | float length = diff.length(); |
mbedalvaro | 0:345b3bc7a0ea | 115 | |
mbedalvaro | 0:345b3bc7a0ea | 116 | // ----------- (3) check close enough |
mbedalvaro | 0:345b3bc7a0ea | 117 | |
mbedalvaro | 0:345b3bc7a0ea | 118 | bool bAmCloseEnough = true; |
mbedalvaro | 0:345b3bc7a0ea | 119 | if (radius > 0){ |
mbedalvaro | 0:345b3bc7a0ea | 120 | if (length > radius){ |
mbedalvaro | 0:345b3bc7a0ea | 121 | bAmCloseEnough = false; |
mbedalvaro | 0:345b3bc7a0ea | 122 | } |
mbedalvaro | 0:345b3bc7a0ea | 123 | } |
mbedalvaro | 0:345b3bc7a0ea | 124 | |
mbedalvaro | 0:345b3bc7a0ea | 125 | // ----------- (4) if so, update REPULSIVE force |
mbedalvaro | 0:345b3bc7a0ea | 126 | |
mbedalvaro | 0:345b3bc7a0ea | 127 | if (bAmCloseEnough == true){ |
mbedalvaro | 0:345b3bc7a0ea | 128 | float pct = 1 - (length / radius); |
mbedalvaro | 0:345b3bc7a0ea | 129 | diff.normalize(); |
mbedalvaro | 0:345b3bc7a0ea | 130 | totalForce += diff * scale * pct; |
mbedalvaro | 0:345b3bc7a0ea | 131 | theOtherParticle.totalForce -= diff * scale * pct; |
mbedalvaro | 0:345b3bc7a0ea | 132 | //theOtherParticle.frc.x = p.frc.x - diff.x * scale * pct; |
mbedalvaro | 0:345b3bc7a0ea | 133 | //theOtherParticle.frc.y = p.frc.y - diff.y * scale * pct; |
mbedalvaro | 0:345b3bc7a0ea | 134 | } |
mbedalvaro | 0:345b3bc7a0ea | 135 | } |
mbedalvaro | 0:345b3bc7a0ea | 136 | |
mbedalvaro | 0:345b3bc7a0ea | 137 | |
mbedalvaro | 0:345b3bc7a0ea | 138 | |
mbedalvaro | 0:345b3bc7a0ea | 139 | //------------------------------------------------------------ |
mbedalvaro | 0:345b3bc7a0ea | 140 | void pointMass::addDampingForce(){ // NOTE: use only in case of EULER intgration! |
mbedalvaro | 0:345b3bc7a0ea | 141 | totalForce-= speed* dampMotion; |
mbedalvaro | 0:345b3bc7a0ea | 142 | } |
mbedalvaro | 0:345b3bc7a0ea | 143 | |
mbedalvaro | 0:345b3bc7a0ea | 144 | //------------------------------------------------------------ |
mbedalvaro | 0:345b3bc7a0ea | 145 | void pointMass::setIntegrationStep(float _dt){ |
mbedalvaro | 0:345b3bc7a0ea | 146 | dt=_dt; |
mbedalvaro | 0:345b3bc7a0ea | 147 | } |
mbedalvaro | 0:345b3bc7a0ea | 148 | |
mbedalvaro | 0:345b3bc7a0ea | 149 | //------------------------------------------------------------ |
mbedalvaro | 0:345b3bc7a0ea | 150 | void pointMass::setInitialCondition(float px, float py, float vx, float vy){ |
mbedalvaro | 0:345b3bc7a0ea | 151 | #ifndef VERLET_METHOD |
mbedalvaro | 0:345b3bc7a0ea | 152 | pos.set(px,py); |
mbedalvaro | 0:345b3bc7a0ea | 153 | speed.set(vx,vy); |
mbedalvaro | 0:345b3bc7a0ea | 154 | #else |
mbedalvaro | 0:345b3bc7a0ea | 155 | // In case of Verlet method, setting the speed is a little more complicated. It involves in particular the integration step |
mbedalvaro | 0:345b3bc7a0ea | 156 | // through the approximation formula: |
mbedalvaro | 0:345b3bc7a0ea | 157 | // speed = (posNew-posOld)/(2*dt), or speed=(pos-posOld)/dt. Hence: |
mbedalvaro | 0:345b3bc7a0ea | 158 | posOld.set(px, py); |
mbedalvaro | 0:345b3bc7a0ea | 159 | setSpeed(vx, vy); // this assumes posOld known |
mbedalvaro | 0:345b3bc7a0ea | 160 | #endif |
mbedalvaro | 0:345b3bc7a0ea | 161 | } |
mbedalvaro | 0:345b3bc7a0ea | 162 | |
mbedalvaro | 0:345b3bc7a0ea | 163 | //------------------------------------------------------- |
mbedalvaro | 0:345b3bc7a0ea | 164 | vector2D pointMass::getSpeed() { |
mbedalvaro | 0:345b3bc7a0ea | 165 | // this will give an estimate of the speed (not computed explicitly using the Verlet integration): |
mbedalvaro | 0:345b3bc7a0ea | 166 | //speed=(posNew-posOld)/(2*dt); // the variable speed is also updated (note: it is private) |
mbedalvaro | 1:a4050fee11f7 | 167 | speed=(pos-posOld)/dt; // less approximate than the above, but we avoid having a global posNew variable (remember we will have many particles...) |
mbedalvaro | 0:345b3bc7a0ea | 168 | return(speed); |
mbedalvaro | 0:345b3bc7a0ea | 169 | } |
mbedalvaro | 0:345b3bc7a0ea | 170 | |
mbedalvaro | 1:a4050fee11f7 | 171 | void pointMass::setSpeed(const vector2D& vel) { // VERY IMPORTANT! in the case of verlet integration, we need to set dt BEFORE setting the initial speed. |
mbedalvaro | 0:345b3bc7a0ea | 172 | speed.set(vel); // enough for EULER METHOD |
mbedalvaro | 0:345b3bc7a0ea | 173 | pos=speed*dt+posOld; // NECESSARY for VERLET METHOD (we assume posOld known). |
mbedalvaro | 0:345b3bc7a0ea | 174 | // no need to compute newPos |
mbedalvaro | 0:345b3bc7a0ea | 175 | } |
mbedalvaro | 0:345b3bc7a0ea | 176 | |
mbedalvaro | 1:a4050fee11f7 | 177 | void pointMass::setSpeed(float vx, float vy) { // VERY IMPORTANT! in the case of verlet integration, we need to set dt BEFORE setting the initial speed. |
mbedalvaro | 0:345b3bc7a0ea | 178 | speed.set(vx, vy); // enough for EULER METHOD |
mbedalvaro | 0:345b3bc7a0ea | 179 | pos=speed*dt+posOld; // NECESSARY for VERLET METHOD (we assume posOld known). |
mbedalvaro | 0:345b3bc7a0ea | 180 | // no need to compute newPos |
mbedalvaro | 0:345b3bc7a0ea | 181 | } |
mbedalvaro | 0:345b3bc7a0ea | 182 | |
mbedalvaro | 0:345b3bc7a0ea | 183 | void pointMass::setPos(float px, float py) { // assuming the speed is unchanged (must do some tweaking in case of Verlet integration) |
mbedalvaro | 0:345b3bc7a0ea | 184 | pos.set(px, py); |
mbedalvaro | 0:345b3bc7a0ea | 185 | posOld=pos-speed*dt; |
mbedalvaro | 0:345b3bc7a0ea | 186 | } |
mbedalvaro | 0:345b3bc7a0ea | 187 | |
mbedalvaro | 0:345b3bc7a0ea | 188 | //------------------------------------------------------------ |
mbedalvaro | 0:345b3bc7a0ea | 189 | void pointMass::update(){ |
mbedalvaro | 0:345b3bc7a0ea | 190 | if (bFixed == false){ |
mbedalvaro | 0:345b3bc7a0ea | 191 | acc=totalForce/mass; // this is the acceleration at time t |
mbedalvaro | 1:a4050fee11f7 | 192 | |
mbedalvaro | 0:345b3bc7a0ea | 193 | #ifndef VERLET_METHOD |
mbedalvaro | 0:345b3bc7a0ea | 194 | // The following equations (Euler integration) assume acceleration constant during time dt: |
mbedalvaro | 0:345b3bc7a0ea | 195 | speed = speed + acc*dt; |
mbedalvaro | 0:345b3bc7a0ea | 196 | pos = pos + speed*dt ;//+acc*dt*dt*0.5; |
mbedalvaro | 0:345b3bc7a0ea | 197 | #else |
mbedalvaro | 1:a4050fee11f7 | 198 | |
mbedalvaro | 0:345b3bc7a0ea | 199 | // The following equations are for VERLET integration with pseudo-damping: |
mbedalvaro | 1:a4050fee11f7 | 200 | vector2D posNew=(pos*(2.0-dampMotion)-posOld*(1.0-dampMotion)+acc*dt*dt); |
mbedalvaro | 0:345b3bc7a0ea | 201 | // Without damping this is just: posNew=2*posOld-1*pos+acc*dt*dt; // i.e., dampMotion=0; |
mbedalvaro | 0:345b3bc7a0ea | 202 | |
mbedalvaro | 0:345b3bc7a0ea | 203 | posOld=pos; |
mbedalvaro | 0:345b3bc7a0ea | 204 | pos=posNew; |
mbedalvaro | 0:345b3bc7a0ea | 205 | |
mbedalvaro | 0:345b3bc7a0ea | 206 | // NOTE: we can also estimate the speed if we want. But this may be unnecessary (call getSpeed() for that). |
mbedalvaro | 0:345b3bc7a0ea | 207 | |
mbedalvaro | 0:345b3bc7a0ea | 208 | #endif |
mbedalvaro | 0:345b3bc7a0ea | 209 | |
mbedalvaro | 0:345b3bc7a0ea | 210 | } |
mbedalvaro | 0:345b3bc7a0ea | 211 | } |
mbedalvaro | 0:345b3bc7a0ea | 212 | |
mbedalvaro | 0:345b3bc7a0ea | 213 | void pointMass::setWallLimits(float Minx, float Miny, float Maxx, float Maxy) { |
mbedalvaro | 0:345b3bc7a0ea | 214 | maxWall.set(Maxx, Maxy); |
mbedalvaro | 0:345b3bc7a0ea | 215 | minWall.set(Minx, Miny); |
mbedalvaro | 0:345b3bc7a0ea | 216 | } |
mbedalvaro | 0:345b3bc7a0ea | 217 | |
mbedalvaro | 0:345b3bc7a0ea | 218 | //------------------------------------------------------------ |
mbedalvaro | 0:345b3bc7a0ea | 219 | void pointMass::bounceOffWalls(){ |
mbedalvaro | 0:345b3bc7a0ea | 220 | // NOTE: bounce is easy in case of EULER method; in case of VERLET, we need to do some hack on the positions. |
mbedalvaro | 0:345b3bc7a0ea | 221 | //Note: the walls are in (vector2D) horizontalLimits and verticalLimits |
mbedalvaro | 0:345b3bc7a0ea | 222 | |
mbedalvaro | 0:345b3bc7a0ea | 223 | bWallCollision=false; |
mbedalvaro | 0:345b3bc7a0ea | 224 | innerCollitionDirection.set(0,0); |
mbedalvaro | 0:345b3bc7a0ea | 225 | #ifndef VERLET_METHOD // EULER METHOD!! |
mbedalvaro | 0:345b3bc7a0ea | 226 | |
mbedalvaro | 0:345b3bc7a0ea | 227 | if (pos.x > maxWall.x){ |
mbedalvaro | 0:345b3bc7a0ea | 228 | pos.x = maxWall.x; |
mbedalvaro | 0:345b3bc7a0ea | 229 | speed.x *= -1; |
mbedalvaro | 0:345b3bc7a0ea | 230 | bWallCollision = true; |
mbedalvaro | 0:345b3bc7a0ea | 231 | innerCollitionDirection.x=-1; |
mbedalvaro | 0:345b3bc7a0ea | 232 | } else if (pos.x < minWall.x){ |
mbedalvaro | 0:345b3bc7a0ea | 233 | pos.x = minWall.x; |
mbedalvaro | 0:345b3bc7a0ea | 234 | speed.x *= -1; |
mbedalvaro | 0:345b3bc7a0ea | 235 | bWallCollision = true; |
mbedalvaro | 0:345b3bc7a0ea | 236 | innerCollitionDirection.x=1; |
mbedalvaro | 0:345b3bc7a0ea | 237 | } |
mbedalvaro | 0:345b3bc7a0ea | 238 | |
mbedalvaro | 0:345b3bc7a0ea | 239 | if (pos.y > maxWall.y){ |
mbedalvaro | 0:345b3bc7a0ea | 240 | pos.y = maxWall.y; |
mbedalvaro | 0:345b3bc7a0ea | 241 | speed.y *= -1; |
mbedalvaro | 0:345b3bc7a0ea | 242 | bWallCollision = true; |
mbedalvaro | 0:345b3bc7a0ea | 243 | innerCollitionDirection.y=-1; |
mbedalvaro | 0:345b3bc7a0ea | 244 | } else if (pos.y < minWall.y){ |
mbedalvaro | 0:345b3bc7a0ea | 245 | pos.y = minWall.y; |
mbedalvaro | 0:345b3bc7a0ea | 246 | speed.y *= -1; |
mbedalvaro | 0:345b3bc7a0ea | 247 | bWallCollision = true; |
mbedalvaro | 0:345b3bc7a0ea | 248 | innerCollitionDirection.y=1; |
mbedalvaro | 0:345b3bc7a0ea | 249 | } |
mbedalvaro | 0:345b3bc7a0ea | 250 | |
mbedalvaro | 0:345b3bc7a0ea | 251 | if (bWallCollision) { |
mbedalvaro | 0:345b3bc7a0ea | 252 | // damping: |
mbedalvaro | 0:345b3bc7a0ea | 253 | speed *=(1-dampBorder); |
mbedalvaro | 0:345b3bc7a0ea | 254 | // normalization of collision direction: |
mbedalvaro | 0:345b3bc7a0ea | 255 | innerCollitionDirection.normalize(); |
mbedalvaro | 0:345b3bc7a0ea | 256 | } |
mbedalvaro | 0:345b3bc7a0ea | 257 | |
mbedalvaro | 0:345b3bc7a0ea | 258 | #else // THIS IS FOR VERLET METHOD: |
mbedalvaro | 0:345b3bc7a0ea | 259 | // we need to estimate the inverted, damped vector for bumping:: |
mbedalvaro | 1:a4050fee11f7 | 260 | vector2D bumpVector=getSpeed()*dt*(dampBorder-1.0); // assuming dampBorder<1 of course |
mbedalvaro | 0:345b3bc7a0ea | 261 | if (pos.x > maxWall.x){ |
mbedalvaro | 0:345b3bc7a0ea | 262 | //posOld.x=pos.x; |
mbedalvaro | 0:345b3bc7a0ea | 263 | //pos.x=pos.x+bumpVector.x; |
mbedalvaro | 0:345b3bc7a0ea | 264 | posOld.x=maxWall.x; |
mbedalvaro | 0:345b3bc7a0ea | 265 | pos.x=maxWall.x+bumpVector.x; |
mbedalvaro | 0:345b3bc7a0ea | 266 | bWallCollision = true; // this is just computed here to detect bumps |
mbedalvaro | 0:345b3bc7a0ea | 267 | innerCollitionDirection.x=-1; |
mbedalvaro | 0:345b3bc7a0ea | 268 | } else if (pos.x < minWall.x){ |
mbedalvaro | 0:345b3bc7a0ea | 269 | posOld.x=minWall.x; |
mbedalvaro | 0:345b3bc7a0ea | 270 | pos.x=minWall.x+bumpVector.x; |
mbedalvaro | 0:345b3bc7a0ea | 271 | innerCollitionDirection.x=1; |
mbedalvaro | 0:345b3bc7a0ea | 272 | bWallCollision = true; |
mbedalvaro | 0:345b3bc7a0ea | 273 | } |
mbedalvaro | 0:345b3bc7a0ea | 274 | |
mbedalvaro | 0:345b3bc7a0ea | 275 | if (pos.y > maxWall.y){ |
mbedalvaro | 0:345b3bc7a0ea | 276 | posOld.y=maxWall.y; |
mbedalvaro | 0:345b3bc7a0ea | 277 | pos.y=maxWall.y+bumpVector.y; |
mbedalvaro | 0:345b3bc7a0ea | 278 | innerCollitionDirection.y=-1; |
mbedalvaro | 0:345b3bc7a0ea | 279 | bWallCollision = true; |
mbedalvaro | 0:345b3bc7a0ea | 280 | } else if (pos.y < minWall.y){ |
mbedalvaro | 0:345b3bc7a0ea | 281 | posOld.y=minWall.y; |
mbedalvaro | 0:345b3bc7a0ea | 282 | pos.y=minWall.y+bumpVector.y; |
mbedalvaro | 0:345b3bc7a0ea | 283 | innerCollitionDirection.y=1; |
mbedalvaro | 0:345b3bc7a0ea | 284 | bWallCollision = true; |
mbedalvaro | 0:345b3bc7a0ea | 285 | } |
mbedalvaro | 0:345b3bc7a0ea | 286 | #endif |
mbedalvaro | 0:345b3bc7a0ea | 287 | |
mbedalvaro | 0:345b3bc7a0ea | 288 | } |