Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

Changeset 9110 in orxonox.OLD for trunk/src/lib


Ignore:
Timestamp:
Jul 4, 2006, 11:18:41 AM (18 years ago)
Author:
bensch
Message:

orxonox/trunk: merged the Presentation back

Location:
trunk/src/lib
Files:
26 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/lib/collision_detection/cd_engine.cc

    r8894 r9110  
    4545
    4646  this->bAbordOnFirstCollision = false;
     47 
     48  this->terrain = NULL;
    4749}
    4850

  • trunk/src/lib/collision_reaction/cr_physics_ground_walk.cc

    r9061 r9110  
    7070
    7171
    72   float CR_MAX_WALK_HEIGHT = 2.0f;
     72  float CR_MAX_WALK_HEIGHT = 15.0f;
    7373  float CR_THRESHOLD = 0.2f;
    7474
    75   float height = 0;
    76   float front = 0;
    77   float side = 0;
    78 
    79   //PRINTF(0)("collision raction======================================\n");
     75  float height = 0.0f;
     76  float front = 0.0f;
     77  float back = 0.0f;
     78  float right = 0.0f;
     79  float left = 0.0f;
     80
    8081
    8182  const std::vector<CollisionEvent*>* collisionEvents = &(collision->getCollisionEvents());
    … …  
    9394    switch( ce->getType())
    9495    {
    95         // collision in the x-axis
     96        /* collision in the X-AXIS */
    9697      case COLLISION_TYPE_AXIS_X:
    97         front = collPos.len() - box->halfLength[0]; // should be [0]
     98        front = collPos.len() - box->halfLength[0];
    9899
    99100        // object is beneath the plane (ground)
    100101        if( front <= 0.0f )
    101102        {
    102           Vector dirX = entity->getAbsDirX(); dirX.y = 0.0f; dirX.normalize();
     103          Vector dirX = entity->getAbsDirX();
     104          dirX.y = 0.0f;
     105          dirX.normalize();
    103106          Vector backoff = dirX * front;
    104          
    105           entity->setAbsCoor(entity->getLastAbsCoor());
    106          // entity->shiftCoor(backoff);
    107         }
    108         // object is already in the wall
    109         else if( ce->isInWall())
    110         {
    111               entity->setAbsCoor(entity->getLastAbsCoor());
    112         }
    113         break;
    114        
     107
     108          entity->shiftCoor(backoff);
     109        }
     110        else if( ce->isInWall())
     111        {
     112          // object is already in the wall
     113          entity->setAbsCoor(entity->getLastAbsCoor());
     114        }
     115        break;
     116
    115117      case COLLISION_TYPE_AXIS_X_NEG:
    116         front = collPos.len() - box->halfLength[0]; // should be [0]
    117 
    118         // object is beneath the plane (ground)
    119         if( front <= 0.0f )
    120         {
    121           Vector dirX = entity->getAbsDirX(); dirX.y = 0.0f; dirX.normalize();
    122           Vector backoff = dirX * front * -1.0f;
    123          
    124           entity->setAbsCoor(entity->getLastAbsCoor());
    125          // entity->shiftCoor(backoff);
    126         }
    127         // object is already in the wall
    128         else if( ce->isInWall())
    129         {
    130           entity->setAbsCoor(entity->getLastAbsCoor());
    131         }
    132         break;
    133 
    134 
    135         // collision in the y-axis
     118        back = collPos.len() - box->halfLength[0];
     119
     120        // object is beneath the plane (ground)
     121        if( back <= 0.0f)
     122        {
     123          Vector dirX = entity->getAbsDirX();
     124          dirX.y = 0.0f;
     125          dirX.normalize();
     126          Vector backoff = dirX * back * -1.0f;
     127
     128          entity->shiftCoor(backoff);
     129        }
     130        else if( ce->isInWall())
     131        {
     132          // object is already in the wall
     133          entity->setAbsCoor(entity->getLastAbsCoor());
     134        }
     135        break;
     136
     137
     138        /* collision in the Y-AXIS */
    136139      case COLLISION_TYPE_AXIS_Y_NEG:
    137140        // calulate the height above ground
    138         height = collPos.y - box->halfLength[1];
    139 
    140 
    141         // object is beneath the plane (ground)
    142         if(height >= 0.0f && height <= 0.0001f) break ;// Do nothing
    143         else if( height < 0.0f )
     141        height = collPos.len() - box->halfLength[1];
     142
     143
     144        // object is beneath the plane (ground)
     145        //         if(height >= 0.0f && height <= 0.0001f) break ;// Do nothing
     146        if( height < 0.0f && -height < CR_MAX_WALK_HEIGHT)
    144147        {
    145148          entity->shiftCoor(Vector(0.0f, -height + 0.00001, 0.0f));
    … …  
    160163
    161164
     165        /* collision in the Z-AXIS */
     166      case COLLISION_TYPE_AXIS_Z:
     167
     168        right = collPos.len()  - box->halfLength[2];
     169
     170        // object is beneath the plane (ground)
     171        if( right <= 0.0f )
     172        {
     173          Vector dirZ = entity->getAbsDirZ();
     174          dirZ.y = 0.0f;
     175          dirZ.normalize();
     176          Vector backoff = dirZ * right;
     177          entity->shiftCoor(backoff);
     178        }
     179        else if( ce->isInWall())
     180        {
     181          // object is already in the wall
     182          entity->setAbsCoor(entity->getLastAbsCoor());
     183        }
     184        break;
     185
     186
    162187        // collision in the z-axis
    163       case COLLISION_TYPE_AXIS_Z:
    164 
    165         side = collPos.len()  - box->halfLength[2]; // should be [2]
    166 
    167         // object is beneath the plane (ground)
    168         if( side <= 0.0f )
    169         {
    170           entity->setAbsCoor(entity->getAbsCoor());
    171           Vector dirZ = entity->getAbsDirZ(); dirZ.y = 0.0f; dirZ.normalize();
    172           Vector backoff = dirZ * side;
    173           entity->shiftCoor(backoff);
    174         }
    175         // object is already in the wall
    176         else if( ce->isInWall())
    177         {
    178           entity->setAbsCoor(entity->getLastAbsCoor());
    179         }
    180         break;
    181        
    182        
    183          // collision in the z-axis
    184188      case COLLISION_TYPE_AXIS_Z_NEG:
    185189
    186         side = collPos.len()  - box->halfLength[2]; // should be [2]
    187 
    188         // object is beneath the plane (ground)
    189         if( side <= 0.0f )
    190         {
    191          
    192           Vector dirZ = entity->getAbsDirZ(); dirZ.y = 0.0f; dirZ.normalize();
    193           Vector backoff = dirZ * side*-1.0f;
     190        left = collPos.len()  - box->halfLength[2];
     191
     192        // object is beneath the plane (ground)
     193        if( left <= 0.0f )
     194        {
     195          Vector dirZ = entity->getAbsDirZ();
     196          dirZ.y = 0.0f;
     197          dirZ.normalize();
     198          Vector backoff = dirZ * left*-1.0f;
    194199          entity->shiftCoor(backoff);
    195200        }
    … …  
    209214
    210215
    211 #if 0
    212   if( box != NULL)
    213     height = ( ce->getCollisionPosition() - collision->getEntityB()->getAbsCoor() )*(-1.0f) ;
    214   else
    215     height = ce->getCollisionPosition() - collision->getEntityB()->getAbsCoor() ;
    216 
    217 
    218   if( box != NULL)
    219   {
    220 
    221 
    222     if(ce->getCollisionPosition().x <= 0.9 && ce->getGroundNormal().len() <= 1.4f)
    223     {
    224       collision->getEntityB()->setAbsCoor(collision->getEntityB()->getLastAbsCoor());
    225       return;
    226     }
    227     if(ce->getCollisionPosition().z <= 0.9 && ce->getGroundNormal().len() <= 1.4f)
    228     {
    229       collision->getEntityB()->setAbsCoor(collision->getEntityB()->getLastAbsCoor());
    230       return;
    231     }
    232 
    233     if(ce->getGroundNormal().len() <= 0.1f)
    234     {
    235       collision->getEntityB()->setAbsCoor(collision->getEntityB()->getLastAbsCoor());
    236       return;
    237     }
    238 
    239 
    240     if(ce->getGroundNormal().len() >= 1.4f)
    241     {
    242       downspeed++;
    243       collision->getEntityB()->setAbsCoor(collision->getEntityB()->getAbsCoor() + Vector(0.0,-0.08*downspeed,0.0));
    244       return;
    245     }
    246 
    247 
    248     if(height.y > box->halfLength[1] + 0.0f ) // Above ground
    249     {
    250       if(height.y < box->halfLength[1] + 2.3f) // Snap in
    251       {
    252         downspeed = 0;
    253         collision->getEntityB()->setAbsCoor(collision->getEntityB()->getAbsCoor() - Vector(0.0,height.y  - box->halfLength[1] - 0.0f,0.0));
    254       } else
    255       {
    256         downspeed++;
    257         collision->getEntityB()->setAbsCoor(collision->getEntityB()->getAbsCoor() + Vector(0.0,-0.08*downspeed,0.0));
    258       }
    259 
    260     }
    261     else
    262     {
    263       if(height.y <  box->halfLength[1] + 0.0f   /* && height.y  >  - 55.0f*/) // below ground
    264       {
    265         //if(downspeed <= 0) downspeed =1;
    266         collision->getEntityB()->setAbsCoor(collision->getEntityB()->getAbsCoor() + Vector(0.0, -height.y  +  box->halfLength[1] + 2.0f,0.0));
    267         //collision->getEntityB()->setVelocity(Vector(0.0,0.0,0.0));
    268         downspeed = 0;
    269       }
    270 
    271     }
    272 
    273   }// if(box!= NULL)
    274 #endif
    275   /*
    276   PRINTF(0)("Collision with Ground: \n");
    277   collision->getEntityB()->getAbsCoor().debug();
    278   collision->getEntityB()->setVelocity(Vector());
    279   collision->getEntityB()->setAbsCoor(this->lastPositions[1]);
    280 
    281   */
    282216
    283217}

  • trunk/src/lib/graphics/importer/bsp_manager.cc

    r9061 r9110  
    960960  this->outputFraction = 1.0f;
    961961
     962
     963  this->checkCollisionX(worldEntity);
     964  this->checkCollisionY(worldEntity);
     965  this->checkCollisionZ(worldEntity);
     966
     967
     968#if 0
    962969  // Retrieve Bounding box
    963970  AABB* box = worldEntity->getModelAABB();
    … …  
    985992
    986993
     994  plane* testPlane;
     995
     996  bool xCollision = false;
     997  bool zCollision = false;
     998
    987999
    9881000  float height = 40;
    … …  
    9981010    dest1     = worldEntity->getAbsCoor() +  box->center + dirX * (box->halfLength[0]  + BSP_X_OFFSET);
    9991011    dest2     = worldEntity->getAbsCoor() -  box->center + dirX * (box->halfLength[0]  + BSP_X_OFFSET);
    1000    
     1012
    10011013    Vector dirZ =  worldEntity->getAbsDirZ(); dirX.y = 0.0f; dirZ.normalize();
    10021014    //position2 = worldEntity->getAbsCoor() +  box->center - dirZ * (box->halfLength[2]  + BSP_Z_OFFSET);
    … …  
    10091021
    10101022
    1011 //   PRINTF(0)("x and v\n");
    1012 //   worldEntity->getAbsDirX().debug();
    1013 //   worldEntity->getAbsDirV().debug();
    1014 
    1015 
    1016   // 1st Ray
     1023
     1024  // 1st Ray: Y RAY
    10171025  this->inputStart =  position;
    10181026  this->inputEnd =   dest;
    … …  
    10521060      this->out = out;
    10531061    }
    1054 
    1055 
    1056   }
    1057 
    1058   plane* testPlane = this->collPlane;
    1059 
    1060   bool xCollision = false;
    1061   bool zCollision = false;
     1062  }
     1063    testPlane = this->collPlane;
     1064
     1065
    10621066  bool xCollisionNeg = false;
    10631067  bool zCollisionNeg = false;
    1064  
    1065 
    1066 
    1067     // 2nd Collision Detection
     1068
     1069
     1070
     1071    // 2nd Collision Detection X-RAY
    10681072    this->outputStartsOut = true;
    10691073    this->outputAllSolid = false;
    … …  
    10931097
    10941098
    1095       // 3rd Collision Detection
     1099      // 3rd Collision Detection Z-RAY
    10961100      this->outputStartsOut = true;
    10971101      this->outputAllSolid = false;
    … …  
    11211125      }
    11221126
    1123   //end if
    1124   /*
    1125   This is how you would calculate the Coordinates where worldEntity Collided with the BSP world.
    1126   out.x = position1.x + (dest.x -position1.x) * this->outputFraction;
    1127   out.z = position1.z + (dest.z -position1.z) * this->outputFraction;
    1128   */
    1129 
    11301127
    11311128  // Return the normal here: Normal's stored in this->collPlane;
    11321129  if( collision) {
    1133     worldEntity->registerCollision(COLLISION_TYPE_AXIS_Y_NEG , this->parent, worldEntity, Vector(testPlane->x, testPlane->y, testPlane->z), out, SolidFlag);
     1130    worldEntity->registerCollision(COLLISION_TYPE_AXIS_Y , this->parent, worldEntity, Vector(testPlane->x, testPlane->y, testPlane->z), out, SolidFlag);
    11341131}
    11351132  if(xCollision) {
    11361133    worldEntity->registerCollision(COLLISION_TYPE_AXIS_X , this->parent, worldEntity, Vector(testPlane->x, testPlane->y, testPlane->z),dest1 , SolidFlag);
    11371134  }
    1138  
     1135
    11391136  if(zCollision) {
    11401137    worldEntity->registerCollision(COLLISION_TYPE_AXIS_Z , this->parent, worldEntity, Vector(testPlane->x, testPlane->y, testPlane->z), dest2 , SolidFlag);
    11411138  }
    1142 
    1143 
    1144   //else  worldEntity->registerCollision(COLLISION_TYPE_AXIS_Y, this->parent, worldEntity, Vector(0.0, 2.0, 0.0), dest, false);
    1145 
    1146 }
     1139#endif
     1140
     1141}
     1142
     1143
     1144
     1145/**
     1146 * check the collision in the x direction (forward, backward)
     1147 */
     1148void BspManager::checkCollisionX(WorldEntity* entity)
     1149{
     1150  // Retrieve Bounding box
     1151  AABB* box = entity->getModelAABB();
     1152
     1153
     1154  plane*            testPlane          = NULL;  //!< the collision test plane
     1155
     1156  Vector            forward;                    //!< left collision ray
     1157  Vector            backward;                   //!< right collision ray
     1158  Vector            collPos;                    //!< the collision position
     1159
     1160  bool              xCollisionForward  = false; //!< flag true if right collision
     1161  bool              xCollisionBackward = false; //!< flag true if left collision
     1162  bool              SolidFlag          = false; //!< flag set true if solid
     1163
     1164  Vector            position;                   //!< current position of the entity
     1165  Vector            dirX;                       //!< direction x
     1166
     1167  position = entity->getAbsCoor();
     1168  dirX =  entity->getAbsDirX(); dirX.y = 0.0f; dirX.normalize();
     1169
     1170  // calculate the rays
     1171  if( box != NULL)
     1172  {
     1173    forward  = entity->getAbsCoor() +  box->center + dirX * (box->halfLength[0]  + BSP_X_OFFSET);
     1174    backward = entity->getAbsCoor() +  box->center - dirX * (box->halfLength[0]  + BSP_X_OFFSET);
     1175  }
     1176  else
     1177  {
     1178    forward  = position + dirX * 4.0f;
     1179    backward = position + Vector(0.0, 1.0, 0.0) + dirX * 4.0;
     1180  }
     1181
     1182
     1183  /*   X Ray forward  */
     1184  // init some member variables before collision check
     1185  this->outputStartsOut = true;
     1186  this->outputAllSolid = false;
     1187  this->outputFraction = 1.0f;
     1188  this->inputStart =  position;
     1189  this->inputEnd =   forward;
     1190  this->checkCollisionRayN(this->root, 0.0f, 1.0f, &position, &forward );
     1191
     1192  // collision occured
     1193  if( this->outputFraction < 1.0f)
     1194  {
     1195    collPos = position + (forward - position) * this->outputFraction;
     1196    xCollisionForward = true;
     1197    testPlane = this->collPlane;
     1198  }
     1199  if(this->outputAllSolid )
     1200  {
     1201    this->collPlane = new plane;
     1202    this->collPlane->x = 0.0f;
     1203    this->collPlane->y = 0.0f;
     1204    this->collPlane->z = 0.0f;
     1205    testPlane = this->collPlane;
     1206    SolidFlag = true;
     1207    xCollisionForward = true;
     1208  }
     1209
     1210  // collision registration
     1211  if( xCollisionForward)
     1212  {
     1213    entity->registerCollision(COLLISION_TYPE_AXIS_X ,
     1214                              this->parent, entity,
     1215                              Vector(testPlane->x, testPlane->y, testPlane->z),
     1216                              collPos,
     1217                              SolidFlag);
     1218  }
     1219
     1220
     1221
     1222  /*   X Ray backward  */
     1223  // init some member variables before collision check
     1224  this->outputStartsOut = true;
     1225  this->outputAllSolid = false;
     1226  this->outputFraction = 1.0f;
     1227  this->inputStart =  position;
     1228  this->inputEnd =   backward;
     1229  this->checkCollisionRayN(this->root, 0.0f, 1.0f, &position, &backward );
     1230
     1231  // collision occured
     1232  if( this->outputFraction < 1.0f)
     1233  {
     1234    collPos = position + (backward - position) * this->outputFraction;
     1235    xCollisionBackward = true;
     1236    testPlane = this->collPlane;
     1237  }
     1238  if( this->outputAllSolid)
     1239  {
     1240    this->collPlane = new plane;
     1241    this->collPlane->x = 0.0f;
     1242    this->collPlane->y = 0.0f;
     1243    this->collPlane->z = 0.0f;
     1244    testPlane = this->collPlane;
     1245    SolidFlag = true;
     1246    xCollisionBackward = true;
     1247  }
     1248
     1249  // collision registration
     1250  if( xCollisionBackward)
     1251  {
     1252    entity->registerCollision(COLLISION_TYPE_AXIS_X_NEG ,
     1253                              this->parent, entity,
     1254                              Vector(testPlane->x, testPlane->y, testPlane->z),
     1255                              collPos,
     1256                              SolidFlag);
     1257  }
     1258}
     1259
     1260
     1261/**
     1262 * check the collision in the z direction (up, down)
     1263 */
     1264void BspManager::checkCollisionY(WorldEntity* entity)
     1265{
     1266
     1267  // Retrieve Bounding box
     1268  AABB* box = entity->getModelAABB();
     1269
     1270
     1271  plane*            testPlane          = NULL;  //!< the collision test plane
     1272
     1273  Vector            up;                         //!< up collision ray
     1274  Vector            down;                       //!< down collision ray
     1275  Vector            collPos;                    //!< the collision position
     1276
     1277  bool              yCollisionUp       = false; //!< flag true if right collision
     1278  bool              yCollisionDown     = false; //!< flag true if left collision
     1279  bool              SolidFlag          = false; //!< flag set true if solid
     1280
     1281  Vector            position;                   //!< current position of the entity
     1282  Vector            dirY;                       //!< direction x
     1283
     1284  position = entity->getAbsCoor();
     1285  collPos = position;
     1286  dirY =  Vector(0.0, 1.0, 0.0);
     1287
     1288  // calculate the rays
     1289  if( box != NULL)
     1290  {
     1291    up   = position +  box->center + dirY * (box->halfLength[1]/*  + BSP_Y_OFFSET*/);
     1292    down = position +  box->center - dirY * (box->halfLength[1]  + BSP_Y_OFFSET);
     1293  }
     1294  else
     1295  {
     1296    up   = position + dirY * 4.0f;
     1297    down = position + Vector(0.0, 1.0, 0.0) + dirY * 4.0;
     1298  }
     1299
     1300
     1301
     1302
     1303  /*   Y Ray up */
     1304  // init some member variables before collision check
     1305  this->inputStart = position;
     1306  this->inputEnd   = up;
     1307  this->checkCollisionRayN(this->root,0.0f,1.0f, &position, &up );
     1308
     1309  if( !this->outputStartsOut )
     1310  {
     1311    this->collPlane = new plane;
     1312    this->collPlane->x = 0.0f;
     1313    this->collPlane->y = 0.0f;
     1314    this->collPlane->z = 0.0f;
     1315    yCollisionUp = true;
     1316  }
     1317  else
     1318  {
     1319    if( this->outputFraction == 1.0f)
     1320    {
     1321      if( this->outputAllSolid )
     1322      {
     1323        this->collPlane = new plane;
     1324        this->collPlane->x = 0.0f;
     1325        this->collPlane->y = 0.0f;
     1326        this->collPlane->z = 0.0f;
     1327        yCollisionUp = true;
     1328        SolidFlag = true;
     1329      }
     1330      else
     1331      {
     1332        yCollisionUp = false;
     1333        collPos = up;
     1334      }
     1335    }
     1336    else
     1337    {
     1338      yCollisionUp = true;
     1339      collPos = position + (up - position) * this->outputFraction;
     1340      this->out = collPos;        // why this????
     1341    }
     1342  }
     1343  testPlane = this->collPlane;
     1344
     1345  // collision registration
     1346  if( yCollisionUp)
     1347  {
     1348    entity->registerCollision(COLLISION_TYPE_AXIS_Y , this->parent,
     1349                              entity,
     1350                              Vector(testPlane->x, testPlane->y, testPlane->z),
     1351                              collPos, SolidFlag);
     1352  }
     1353
     1354
     1355
     1356
     1357  /*   Y Ray down */
     1358  // init some member variables before collision check
     1359  this->inputStart = position;
     1360  this->inputEnd   = down;
     1361  this->checkCollisionRayN(this->root,0.0f,1.0f, &position, &down );
     1362
     1363  if( !this->outputStartsOut )
     1364  {
     1365    this->collPlane = new plane;
     1366    this->collPlane->x = 0.0f;
     1367    this->collPlane->y = 0.0f;
     1368    this->collPlane->z = 0.0f;
     1369    yCollisionDown = true;
     1370  }
     1371  else
     1372  {
     1373    if( this->outputFraction == 1.0f)
     1374    {
     1375      if( this->outputAllSolid )
     1376      {
     1377        this->collPlane = new plane;
     1378        this->collPlane->x = 0.0f;
     1379        this->collPlane->y = 0.0f;
     1380        this->collPlane->z = 0.0f;
     1381        yCollisionDown = true;
     1382        SolidFlag = true;
     1383      }
     1384      else
     1385      {
     1386        yCollisionDown = false;
     1387        collPos = down;
     1388      }
     1389    }
     1390    else
     1391    {
     1392      yCollisionDown = true;
     1393      collPos = position + (down - position) * this->outputFraction;
     1394      this->out = collPos;        // why this????
     1395    }
     1396  }
     1397  testPlane = this->collPlane;
     1398
     1399  // collision registration
     1400  if( yCollisionDown)
     1401  {
     1402    entity->registerCollision(COLLISION_TYPE_AXIS_Y_NEG , this->parent,
     1403                              entity,
     1404                              Vector(testPlane->x, testPlane->y, testPlane->z),
     1405                              collPos, SolidFlag);
     1406  }
     1407
     1408
     1409}
     1410
     1411
     1412
     1413
     1414/**
     1415 * check the collision in the z direction (left, right)
     1416 */
     1417void BspManager::checkCollisionZ(WorldEntity* entity)
     1418{
     1419  // Retrieve Bounding box
     1420  AABB* box = entity->getModelAABB();
     1421
     1422
     1423  plane*            testPlane          = NULL;  //!< the collision test plane
     1424
     1425  Vector            right;                      //!< right collision ray
     1426  Vector            left;                       //!< left collision ray
     1427  Vector            collPos;                    //!< the collision position
     1428
     1429  bool              zCollisionRight    = false; //!< flag true if right collision
     1430  bool              zCollisionLeft     = false; //!< flag true if left collision
     1431  bool              SolidFlag          = false; //!< flag set true if solid
     1432
     1433  Vector            position;                   //!< current position of the entity
     1434  Vector            dirZ;                       //!< direction x
     1435
     1436  position = entity->getAbsCoor();
     1437  dirZ =  entity->getAbsDirZ(); dirZ.y = 0.0f; dirZ.normalize();
     1438
     1439  // calculate the rays
     1440  if( box != NULL)
     1441  {
     1442    right = entity->getAbsCoor() +  box->center + dirZ * (box->halfLength[2]  + BSP_Z_OFFSET);
     1443    left  = entity->getAbsCoor() +  box->center - dirZ * (box->halfLength[2]  + BSP_Z_OFFSET);
     1444  }
     1445  else
     1446  {
     1447    right = position + dirZ * 4.0f;
     1448    left  = position + Vector(0.0, 1.0, 0.0) + dirZ * 4.0;
     1449  }
     1450
     1451
     1452  /*   Z Ray right */
     1453  // init some member variables before collision check
     1454  this->outputStartsOut = true;
     1455  this->outputAllSolid = false;
     1456  this->outputFraction = 1.0f;
     1457  this->inputStart =  position;
     1458  this->inputEnd =   right;
     1459  this->checkCollisionRayN(this->root, 0.0f, 1.0f, &position, &right );
     1460
     1461
     1462  // collision occured
     1463  if( this->outputFraction < 1.0f )
     1464  {
     1465    collPos = position + (right - position) * this->outputFraction;
     1466    zCollisionRight = true;
     1467    testPlane = this->collPlane;
     1468  }
     1469  if(this->outputAllSolid )
     1470  {
     1471    this->collPlane = new plane;
     1472    this->collPlane->x = 0.0f;
     1473    this->collPlane->y = 0.0f;
     1474    this->collPlane->z = 0.0f;
     1475    testPlane = this->collPlane;
     1476
     1477    SolidFlag = true;
     1478    zCollisionRight = true;
     1479  }
     1480
     1481
     1482  if( zCollisionRight) {
     1483    entity->registerCollision(COLLISION_TYPE_AXIS_Z , this->parent,
     1484                              entity,
     1485                              Vector(testPlane->x, testPlane->y, testPlane->z),
     1486                              collPos , SolidFlag);
     1487  }
     1488
     1489
     1490
     1491  /*   Z Ray left */
     1492  // init some member variables before collision check
     1493  this->outputStartsOut = true;
     1494  this->outputAllSolid = false;
     1495  this->outputFraction = 1.0f;
     1496  this->inputStart =  position;
     1497  this->inputEnd =    left;
     1498  this->checkCollisionRayN(this->root, 0.0f, 1.0f, &position, &left);
     1499
     1500
     1501  // collision occured
     1502  if( this->outputFraction < 1.0f )
     1503  {
     1504    collPos = position + (left - position) * this->outputFraction;
     1505    zCollisionLeft = true;
     1506    testPlane = this->collPlane;
     1507  }
     1508  if(this->outputAllSolid )
     1509  {
     1510    this->collPlane = new plane;
     1511    this->collPlane->x = 0.0f;
     1512    this->collPlane->y = 0.0f;
     1513    this->collPlane->z = 0.0f;
     1514    testPlane = this->collPlane;
     1515
     1516    SolidFlag = true;
     1517    zCollisionLeft = true;
     1518  }
     1519
     1520
     1521  if( zCollisionLeft) {
     1522    entity->registerCollision(COLLISION_TYPE_AXIS_Z_NEG , this->parent,
     1523                              entity,
     1524                              Vector(testPlane->x, testPlane->y, testPlane->z),
     1525                              collPos , SolidFlag);
     1526  }
     1527
     1528}
     1529
     1530
    11471531
    11481532

  • trunk/src/lib/graphics/importer/bsp_manager.h

    r9061 r9110  
    2828
    2929
    30 #define BSP_X_OFFSET 40.0f
     30#define BSP_X_OFFSET 20.0f
    3131#define BSP_Y_OFFSET 40.0f
    32 #define BSP_Z_OFFSET 40.0f
     32#define BSP_Z_OFFSET 20.0f
    3333
    3434
    … …  
    7979
    8080private:
    81   // Functions
     81  // collision functions
    8282  BspTreeNode* getLeaf(BspTreeNode*  node,   Vector* cam) ;  //!< Traverses the tree
    8383  void  checkCollision(BspTreeNode* node, Vector* cam); //!< Obsolete. Use this function for debugging only!
    8484  void  checkCollisionRay(BspTreeNode * node,float startFraction, float endFraction, Vector* start, Vector* end);
    8585  void  checkCollisionRayN(BspTreeNode * node,float startFraction, float endFraction, Vector* start, Vector* end);
    86   void  TraceBox( Vector& inputStart, Vector& inputEnd,Vector& inputMins, Vector& inputMaxs );
     86
     87  void checkCollisionX(WorldEntity* entity);
     88  void checkCollisionY(WorldEntity* entity);
     89  void checkCollisionZ(WorldEntity* entity);
     90
    8791  void  checkCollisionBox(void);
    8892  void  checkBrushRay(brush* curBrush);
    8993  void  checkBrushRayN(brush* curBrush);
    9094  void  checkBrushRayN(brush* curBrush, Vector& inputStart, Vector& inputEnd);
    91   float  checkPatchAltitude(BspTreeNode* node); //! To be implemented...
     95  float checkPatchAltitude(BspTreeNode* node); //! To be implemented...
    9296
     97  void  TraceBox( Vector& inputStart, Vector& inputEnd,Vector& inputMins, Vector& inputMaxs );
     98
     99
     100  // visibility functions
    93101  void drawDebugCube(Vector* cam);
    94102  bool isAlreadyVisible(int Face);

  • trunk/src/lib/graphics/importer/md3/md3_model.cc

    r8724 r9110  
    525525    float  interpolatedMatrix[4][4];
    526526
    527     Quaternion currQuat(currFrameTag->matrix); currQuat.matrix(currRot);
    528     Quaternion nextQuat(nextFrameTag->matrix); nextQuat.matrix(nextRot);
     527    /// TODO CHANGED BY BENSCH TO MATCH NEW QUATERNION FUNCTIONALITY
     528    Quaternion currQuat; currQuat.from3x3(currFrameTag->matrix); currQuat.matrix(currRot);
     529    Quaternion nextQuat; nextQuat.from3x3(nextFrameTag->matrix); nextQuat.matrix(nextRot);
    529530
    530531    Quaternion interpolatedQuat = Quaternion::quatSlerp(currQuat, nextQuat, frac); interpolatedQuat.matrix(interpolatedMatrix);

  • trunk/src/lib/graphics/importer/primitive_model.cc

    r8316 r9110  
    1818#include "primitive_model.h"
    1919
    20 #include <math.h>
    2120#include "vector.h"
    2221#include "debug.h"

  • trunk/src/lib/graphics/spatial_separation/quadtree.cc

    r8293 r9110  
    5252
    5353  /* make an array with access to the leafs of the Quad-Tree */
    54   this->nodes = new QuadtreeNode*[(int)pow(4, treeDepth)];
     54  this->nodes = new QuadtreeNode*[(int)pow(4.0, treeDepth)];
    5555  int index = 0; //new int; *index = 0; // !!changed by bensch!!
    56   for(int i = 0; i < (int)pow(2, treeDepth); ++i)
     56  for(int i = 0; i < (int)pow(2.0, treeDepth); ++i)
    5757  {
    5858    this->rootNode->buildHashTable(this->nodes, &index);
    … …  
    7070  this->offset->x = xOff;
    7171  this->offset->z = yOff;
    72   this->maxIndex = (int)pow(2, this->treeDepth);
     72  this->maxIndex = (int)pow(2.0, this->treeDepth);
    7373}
    7474
    … …  
    103103void Quadtree::revertHashTable(QuadtreeNode** nodes)
    104104{
    105   int                  len         = (int)pow(2, this->treeDepth);          //!< the length of a quadtree side
     105  int                  len         = (int)pow(2.0, this->treeDepth);          //!< the length of a quadtree side
    106106  int                  iterator    = 0;                                     //!< iterator used for mapping
    107107  QuadtreeNode*        tmpNode     = NULL;                                  //!< temp saving place
    … …  
    132132void Quadtree::sortHashTable(QuadtreeNode** nodes)
    133133{
    134   int                  len         = (int)pow(2, this->treeDepth);          //!< the length of a quadtree side
     134  int                  len         = (int)pow(2.0, this->treeDepth);          //!< the length of a quadtree side
    135135  float                a;                                                   //!< temp place for float a
    136136  float                b;                                                   //!< temp place for float b
    … …  
    207207{
    208208  //this->rootNode->drawTree();
    209   for(int i = 0; i < (int)pow(4, this->treeDepth); ++i)
     209  for(int i = 0; i < (int)pow(4.0, this->treeDepth); ++i)
    210210  {
    211211    this->nodes[i]->draw();

  • trunk/src/lib/graphics/spatial_separation/quadtree_node.cc

    r6022 r9110  
    164164
    165165  /*              offset              #of elements in a row            #of rows in a quadtree          */
    166   int threshold = this->nodeIter + (int)pow(2, this->maxDepth) * (int)pow(2, maxDepth - treeDepth - 1);
     166  int threshold = this->nodeIter + (int)pow(2.0, this->maxDepth) * (int)pow(2.0, maxDepth - treeDepth - 1);
    167167  int loopLimit = (*index < threshold)?2:4;
    168168

  • trunk/src/lib/gui/gl/glgui_box.cc

    r8717 r9110  
    5959  void GLGuiBox::unpack(GLGuiWidget* widget)
    6060  {
    61     assert(widget == NULL);
     61    assert(widget != NULL);
    6262
    6363    std::vector<GLGuiWidget*>::iterator delWidget = std::find(this->children.begin(), this->children.end(), widget);

  • trunk/src/lib/gui/gtk/gui_gtk.cc

    r8145 r9110  
    3030#include <string.h>
    3131#include <stdlib.h>
    32 #include <math.h>
     32#include <cmath>
    3333
    3434using namespace std;

  • trunk/src/lib/math/curve.cc

    r5232 r9110  
    2929#include "debug.h"
    3030
    31 #include <math.h>
     31#include <cmath>
    3232#include <stdio.h>
    3333

  • trunk/src/lib/math/line.h

    r6617 r9110  
    2424#define __LINE_H_
    2525
    26 #include <math.h>
    2726#include "compiler.h"
    2827#include "vector.h"

  • trunk/src/lib/math/matrix.cc

    r7711 r9110  
    1414*/
    1515#include "matrix.h"
    16 #include <math.h>
     16#include <cmath>
    1717
    1818#ifdef DEBUG

  • trunk/src/lib/math/matrix.h

    r5698 r9110  
    44 */
    55
    6 #include <math.h>
    76#include "vector.h"
    87

  • trunk/src/lib/math/plane.h

    r7711 r9110  
    2424#define __PLANE_H_
    2525
    26 #include <math.h>
    2726#include "compiler.h"
    2827#include "vector.h"

  • trunk/src/lib/math/quaternion.cc

    r8731 r9110  
    2828  #define PRINT(x) printf
    2929#endif
    30 
    31 using namespace std;
    3230
    3331/////////////////
    … …  
    5856  m[0][1] = x.y;
    5957  m[0][2] = x.z;
    60   m[0][3] = 0;
     58  m[0][3] = 0.0;
    6159  m[1][0] = y.x;
    6260  m[1][1] = y.y;
    6361  m[1][2] = y.z;
    64   m[1][3] = 0;
     62  m[1][3] = 0.0;
    6563  m[2][0] = z.x;
    6664  m[2][1] = z.y;
    6765  m[2][2] = z.z;
    68   m[2][3] = 0;
    69   m[3][0] = 0;
    70   m[3][1] = 0;
    71   m[3][2] = 0;
    72   m[3][3] = 1;
    73 
    74   *this = Quaternion (m);
     66  m[2][3] = 0.0;
     67  m[3][0] = 0.0;
     68  m[3][1] = 0.0;
     69  m[3][2] = 0.0;
     70  m[3][3] = 1.0;
     71
     72  this->from4x4(m);
    7573}
    7674
    … …  
    279277 * @param m: a 4x4 matrix in glMatrix order
    280278 */
    281 Quaternion::Quaternion (float m[4][4])
     279void Quaternion::from4x4(float m[4][4])
    282280{
    283281
    … …  
    285283  int    i, j, k;
    286284
    287   int nxt[3] = {1, 2, 0};
     285  static int nxt[3] = {1, 2, 0};
    288286
    289287  tr = m[0][0] + m[1][1] + m[2][2];
    … …  
    327325
    328326/**
    329  * Creates a quaternion from a 3x3 rotation matrix.
     327 * applies a quaternion from a 3x3 rotation matrix.
    330328 * @param mat The 3x3 source rotation matrix.
    331329 * @return The equivalent 4 float quaternion.
    332330 */
    333 Quaternion::Quaternion(float mat[3][3])
     331void Quaternion::from3x3(float mat[3][3])
    334332{
    335333  int   NXT[] = {1, 2, 0};

  • trunk/src/lib/math/quaternion.h

    r8894 r9110  
    2424#define __QUATERNION_H_
    2525
    26 #include <math.h>
    2726#include "compiler.h"
    28 //! PI the circle-constant
    29 #define PI 3.14159265359f
    3027#include "vector.h"
    3128
    … …  
    3936  /** creates a Default quaternion (multiplicational identity Quaternion)*/
    4037  inline Quaternion () { w = 1; v = Vector(0,0,0); }
     38  /** Copy constructor @param q the Quaternion to copy. */
     39  inline Quaternion (const Quaternion& q) { w = q.w; v = q.v; };
    4140  /** creates a Quaternion looking into the direction v @param v: the direction @param f: the value */
    4241  inline Quaternion (const Vector& v, float f) { this->w = f; this->v = v; }
    43   Quaternion (float m[4][4]);
    44   Quaternion (float m[3][3]);
    4542  /** turns a rotation along an axis into a Quaternion @param angle: the amount of radians to rotate @param axis: the axis to rotate around */
    4643  inline Quaternion (float angle, const Vector& axis) { w = cos(angle/2.0); v = axis * sin(angle/2.0); }
    4744  Quaternion (const Vector& dir, const Vector& up);
    4845  Quaternion (float roll, float pitch, float yaw);
     46
     47  void from3x3(float m[3][3]);
     48  void from4x4(float m[4][4]);
     49
    4950
    5051  /** @param q: the Quaternion to compare with this one. @returns true if the Quaternions are the same, false otherwise */

  • trunk/src/lib/math/vector.cc

    r6617 r9110  
    2929#endif
    3030
    31 using namespace std;
    3231
    3332/////////////
    … …  
    4039Vector Vector::getNormalized() const
    4140{
    42   float l = this->len();
    43   if(unlikely(l == 1.0 || l == 0.0))
     41  float length = this->len();
     42  if (unlikely(length == 0.0))
    4443    return *this;
    4544  else
    46     return (*this / l);
     45    return (*this / length);
    4746}
    4847

  • trunk/src/lib/math/vector.h

    r8894 r9110  
    2424#define __VECTOR_H_
    2525
    26 #include <math.h>
     26#include <cmath>
    2727#include "compiler.h"
    2828//! PI the circle-constant
    … …  
    4242  Vector (float x, float y, float z) : x(x), y(y), z(z) {}  //!< assignment constructor
    4343  Vector () : x(0), y(0), z(0) {}
    44   ~Vector () {}
    4544
    4645  /** @param v: the Vecor to compare with this one @returns true, if the Vecors are the same, false otherwise */
    … …  
    9089  void scale(const Vector& v) {   x *= v.x;  y *= v.y; z *= v.z; };
    9190  /** @returns the length of the vector */
    92   inline float len() const { return sqrt (x*x+y*y+z*z); }
     91  inline float len() const { return sqrt (x*x + y*y + z*z); }
    9392  /** normalizes the vector */
    9493  inline void normalize() { float l = len(); if( unlikely(l == 0.0))return; this->x=this->x/l; this->y=this->y/l; this->z=this->z/l; };

  • trunk/src/lib/network/network_game_manager.cc

    r9059 r9110  
    9898  ClassID playableClassId = rules.getPlayableClassId( userId, team );
    9999  std::string playableModel = rules.getPlayableModelFileName( userId, team, playableClassId );
     100  std::string playableTexture = rules.getPlayableModelFileName( userId, team, playableClassId );
    100101 
    101102  BaseObject * bo = Factory::fabricate( playableClassId );
    … …  
    106107  Playable & playable = *(dynamic_cast<Playable*>(bo));
    107108 
    108   if (  playableModel != "" )
     109  if ( playableTexture != "" )
     110    playable.loadMD2Texture( playableTexture );
     111  if ( playableModel != "" )
    109112    playable.loadModel( playableModel );
    110113  playable.setOwner( userId );

  • trunk/src/lib/network/player_stats.cc

    r8708 r9110  
    238238}
    239239
     240
     241
     242ScoreList PlayerStats::getScoreList( )
     243{
     244  ScoreList result;
     245 
     246  const std::list<BaseObject*> * list = ClassList::getList( CL_PLAYER_STATS );
     247 
     248  if ( !list )
     249  {
     250    return result;
     251  }
     252 
     253  for ( std::list<BaseObject*>::const_iterator it = list->begin(); it != list->end(); it++ )
     254  {
     255    PlayerStats & stats = *dynamic_cast<PlayerStats*>(*it);
     256   
     257    TeamScoreList::iterator it = result[stats.getTeamId()].begin();
     258   
     259    while (  it != result[stats.getTeamId()].end() && stats.score > it->score )
     260    {
     261      it++;
     262    }
     263   
     264    PlayerScore score;
     265    score.name = stats.getNickName();
     266    score.score = stats.getScore();
     267   
     268    result[stats.getTeamId()].insert(it, score);
     269  }
     270 
     271  return result;
     272}

  • trunk/src/lib/network/player_stats.h

    r8623 r9110  
    2020  TEAM_SPECTATOR = -1
    2121};
     22
     23struct PlayerScore
     24{
     25  std::string name;
     26  int score;
     27};
     28typedef std::list<PlayerScore> TeamScoreList;
     29typedef std::map<int,TeamScoreList> ScoreList;
    2230
    2331//! A class for storing player information
    … …  
    6270   
    6371    static void deleteAllPlayerStats();
     72   
     73    static ScoreList getScoreList();
    6474
    6575  private:

  • trunk/src/lib/network/shared_network_data.cc

    r6822 r9110  
    4444 */
    4545SharedNetworkData::~SharedNetworkData()
    46 {}
     46{
     47  SharedNetworkData::singletonRef = NULL;
     48}

  • trunk/src/lib/network/synchronizeable.cc

    r8708 r9110  
    6767{
    6868  if ( this->networkStream )
     69  {
    6970    this->networkStream->disconnectSynchronizeable(*this);
    7071 
    71   if ( this->isServer() && this->beSynchronized() && this->getUniqueID() > 0 && !this->isA( CL_MESSAGE_MANAGER ) )
    72     NetworkGameManager::getInstance()->removeSynchronizeable( this->getUniqueID() );
     72    if ( this->isServer() && this->beSynchronized() && this->getUniqueID() > 0 && !this->isA( CL_MESSAGE_MANAGER ) )
     73      NetworkGameManager::getInstance()->removeSynchronizeable( this->getUniqueID() );
     74  }
    7375   
    7476  for ( SyncVarList::iterator it = syncVarList.begin(); it != syncVarList.end(); it++ )

  • trunk/src/lib/shell/shell_buffer.cc

    r8350 r9110  
    4141  ShellBuffer* ShellBuffer::singletonRef = NULL;
    4242  std::list<std::string> ShellBuffer::buffer;
    43   char ShellBuffer::bufferArray[SHELL_BUFFER_SIZE];
     43  char ShellBuffer::bufferArray[SHELL_BUFFER_SIZE] = "";
    4444
    4545

  • trunk/src/lib/util/loading/game_loader.cc

    r8717 r9110  
    5757    delete this->currentCampaign;
    5858  this->currentCampaign = NULL;
     59 
     60  GameLoader::singletonRef = NULL;
    5961}
    6062
Note: See TracChangeset for help on using the changeset viewer.