src/core/PhysicsObject.cpp

   1 // Copyright 2008 Brian Caine
   2
   3 // This file is part of Potpourri.
   4
   5 // Potpourri is free software: you can redistribute it and/or modify
   6 // it under the terms of the GNU General Public License as published by
   7 // the Free Software Foundation, either version 3 of the License, or
   8 // (at your option) any later version.
   9
  10 // Potpourri is distributed in the hope that it will be useful,
  11 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 // MERCHANTIBILITY of FITNESS FOR A PARTICULAR PURPOSE. See the
  13 // GNU General Public License for more details.
  14
  15 // You should have received a copy of the GNU General Public License
  16 // along with Potpourri. If not, see <http://www.gnu.org/licenses/>.
  17
  18
  19 // NOTES:
  20 // the sauce
  21
  22 #include "../../include/core/PhysicsObject.h"
  23 #include "../../include/core/common.h"
  24
  25 #include <stdexcept>
  26
  27 using namespace fragrant;
  28
  29 PhysicsObject::PhysicsObject(ActorPhysics data)
  30 {
  31   parent = 0;
  32   fixed = data.fixed;
  33
  34   if (data.fixed)
  35     {
  36       body = cpBodyNew(static_cast<float>(INFINITY),
  37                        static_cast<float>(INFINITY));
  38     }
  39
  40   else
  41     {
  42       body = cpBodyNew(data.mass, getMoment(data.shapes, data.mass));
  43     }
  44
  45   int cur;
  46   for (cur = 0; cur < data.shapes.size(); cur++)
  47     {
  48       PhysicsShape cur_shape = data.shapes.at(cur);
  49       cpShape* nshape = 0;
  50
  51       switch (cur_shape.shape)
  52         {
  53           case (S_Line):
  54             {
  55               cur_shape.data.at(0).x += data.base_position.x;
  56               cur_shape.data.at(0).y += data.base_position.y;
  57
  58               cur_shape.data.at(1).x += data.base_position.x;
  59               cur_shape.data.at(1).y += data.base_position.y;
  60
  61               nshape = cpSegmentShapeNew(body,
  62                 cpv(cur_shape.data.at(0).x, cur_shape.data.at(0).y),
  63                 cpv(cur_shape.data.at(1).x, cur_shape.data.at(1).y),
  64                 cur_shape.data.at(2).x);
  65               break;
  66             }
  67
  68           case (S_Circle):
  69             {
  70               nshape = cpCircleShapeNew(body,
  71                 cur_shape.data.at(0).x,
  72                 cpv(cur_shape.offset.x, cur_shape.offset.y));
  73               break;
  74             }
  75
  76           case (S_Poly):
  77             {
  78               cpVect vect_data[cur_shape.data.size()];
  79
  80               int cur_vect;
  81               for (cur_vect = 0; cur_vect < cur_shape.data.size(); cur_vect++)
  82                 vect_data[cur_vect] = cpv(
  83                   cur_shape.data.at(cur_vect).x,
  84                   cur_shape.data.at(cur_vect).y);
  85
  86               nshape = cpPolyShapeNew(body, cur_shape.data.size(),
  87                 vect_data, cpv(cur_shape.offset.x, cur_shape.offset.y));
  88               break;
  89             }
  90         }
  91
  92       nshape->e = cur_shape.elasticity;
  93       nshape->u = cur_shape.friction;
  94
  95       shapes.push_back(nshape);
  96     }
  97 }
  98
  99 PhysicsObject::~PhysicsObject()
 100 {
 101   if (parent)
 102     parent->removePhysicsObject(this);
 103
 104   if (body)
 105     cpBodyFree(body);
 106
 107   int cur;
 108   for (cur = 0; cur < shapes.size(); cur++)
 109     if (shapes.at(cur))
 110       cpShapeFree(shapes.at(cur));
 111 }
 112
 113 void PhysicsObject::setPosition(ActorPair npos)
 114 {
 115   if (!body)
 116     throw std::runtime_error("PhysicsObject::setPosition(): body is zero");
 117
 118   body->p.x = npos.x;
 119   body->p.y = npos.y;
 120
 121   if (fixed && parent)
 122     cpSpaceRehashStatic(parent->space);
 123
 124   return;
 125 }
 126
 127 ActorPair PhysicsObject::getPosition()
 128 {
 129   if (!body)
 130     throw std::runtime_error("PhysicsObject::getPosition(): body is zero");
 131
 132   ActorPair results;
 133
 134   results.x = body->p.x;
 135   results.y = body->p.y;
 136
 137   return results;
 138 }
 139
 140 void PhysicsObject::setAngle(float nangle) // i hate radians
 141 {
 142   cpBodySetAngle(body, toRadians(nangle));
 143
 144   if (fixed && parent)
 145     cpSpaceRehashStatic(parent->space);
 146
 147   return;
 148 }
 149
 150 float PhysicsObject::getAngle()
 151 {
 152   if (!fixed)
 153     return fromRadians(body->a);
 154
 155   return 0;
 156 }
 157
 158 ActorPair PhysicsObject::getCenter()
 159 {
 160   cpVect world = cpBodyLocal2World(body, cpv(0,0));
 161   ActorPair results;
 162
 163   results.x = world.x;
 164   results.y = world.y;
 165
 166   return results;
 167 }
 168
 169 ActorPair PhysicsObject::Object2World(ActorPair input)
 170 {
 171   cpVect world = cpBodyLocal2World(body, cpv(input.x, input.y));
 172   return makePair(world.x, world.y);
 173 }
 174
 175 void PhysicsObject::applyImpulse(ActorPair force, ActorPair offset)
 176 {
 177   cpBodyApplyImpulse(body, cpv(force.x, force.y), cpv(offset.x, offset.y));
 178   return;
 179 }
 180
 181 ActorPair PhysicsObject::getVelocity()
 182 {
 183   return makePair(body->v.x, body->v.y);
 184 }
 185
 186 void PhysicsObject::setVelocity(ActorPair nvelocity)
 187 {
 188   body->v = cpv(nvelocity.x, nvelocity.y);
 189
 190   return;
 191 }
 192
 193 float PhysicsObject::getAngularVelocity()
 194 {
 195   return fromRadians(body->w);
 196 }
 197
 198 void PhysicsObject::setAngularVelocity(float nv)
 199 {
 200   body->w = toRadians(nv);
 201   return;
 202 }
 203
 204 void PhysicsObject::addToSpace(cpSpace* space)
 205 {
 206   if (!fixed)
 207     cpSpaceAddBody(space, body);
 208
 209   int cur;
 210   for (cur = 0; cur < shapes.size(); cur++)
 211     {
 212       if (fixed)
 213         cpSpaceAddStaticShape(space, shapes.at(cur));
 214       else
 215         cpSpaceAddShape(space, shapes.at(cur));
 216     }
 217
 218   return;
 219 }
 220
 221 void PhysicsObject::removeFromSpace(cpSpace* space)
 222 {
 223   if (!fixed)
 224     cpSpaceRemoveBody(space, body);
 225
 226   int cur;
 227   for (cur = 0; cur < shapes.size(); cur++)
 228     {
 229       if (fixed)
 230         cpSpaceRemoveStaticShape(space, shapes.at(cur));
 231       else
 232         cpSpaceRemoveShape(space, shapes.at(cur));
 233     }
 234
 235   return;
 236 }
 237
 238 float PhysicsObject::getMoment(std::vector<PhysicsShape> shapes, float mass)
 239 {
 240   float results;
 241   float total;
 242   int count = 0;
 243
 244   int cur;
 245   for (cur = 0; cur < shapes.size(); cur++)
 246     {
 247       PhysicsShape cur_shape = shapes.at(cur);
 248
 249       if (shapes.at(cur).shape == S_Poly)
 250         {
 251           cpVect vect_data[cur_shape.data.size()];
 252
 253           int cur_vect;
 254           for (cur_vect = 0; cur_vect < cur_shape.data.size(); cur_vect++)
 255              vect_data[cur_vect] = cpv(
 256                cur_shape.data.at(cur_vect).x,
 257                cur_shape.data.at(cur_vect).y);
 258
 259           total += cpMomentForPoly(mass,
 260             cur_shape.data.size(), vect_data,
 261             cpv(shapes.at(cur).offset.x, shapes.at(cur).offset.y));
 262           count++;
 263         }
 264
 265       if (shapes.at(cur).shape == S_Circle)
 266         {
 267           total += cpMomentForCircle(mass, cur_shape.data.at(0).x,
 268             (cur_shape.data.at(0).x/2), cpv(cur_shape.offset.x,
 269             cur_shape.offset.y));
 270           count++;
 271         }
 272     }
 273
 274   return (total / count);
 275 }