Ejemplo n.º 1
0
/**
 * Start has to happen gracefully: If the simulation was stopped for any
 * reason, it has to pick up where it left off.
 * The "runtime" argument is the additional time to run the simulation.
 */
void Clock::handleStart( const Eref& e, double runtime )
{
	if ( stride_ == 0 || stride_ == ~0U )
			stride_ = 1;
	unsigned long n = round( runtime / ( stride_ * dt_ ) );
	handleStep( e, n );
}
Ejemplo n.º 2
0
void SelectionSortWidget::on_btnReset_clicked(){
    BaseSortWidget::on_btnReset_clicked();

    for(int i = 0; i<numbOfValues; i++){
        displayValues[i]->setValue(startTuple[i]);
    }
    handleStep();
}
Ejemplo n.º 3
0
bool parseStepperMessage(int size, const byte *msg, CONTEXT *context)
    {
    switch (msg[0]) 
        {
        case STEP_CMD_2PIN:
            handle2Pin(size, msg, context);
            break;
        case STEP_CMD_4PIN:
            handle4Pin(size, msg, context);
            break;
        case STEP_CMD_SET_SPEED:
            handleSetSpeed(size, msg, context);
            break;
        case STEP_CMD_STEP:
            handleStep(size, msg, context);
            break;
        }
    return false;
    }
Ejemplo n.º 4
0
SelectionSortWidget::SelectionSortWidget(QWidget *parent, AlgorithmController* algoCtrl, int* startTuple, int numbOfValues) :
    BaseSortWidget(parent, algoCtrl, startTuple, numbOfValues)
{
    displayValues = new SortValue*[numbOfValues];
    SortValue* newValue;

    int max = 0;
    for (int i = 0; i < numbOfValues; i++){
        if(max < startTuple[i])
            max = startTuple[i];
    }

    for (int i = 0; i < numbOfValues; i++){
        newValue = new SortValue(0,startTuple[i], max, i);
        ui->horLayoutSorting->addWidget(newValue,0,Qt::AlignBottom);
        displayValues[i] = newValue;
    }

    this->url = QString("http://de.wikipedia.org/wiki/SelectionSort");

    handleStep();
}
Ejemplo n.º 5
0
void CharacterController::checkCollision(MeshCollider* collider)
{
  Vector3 pos = getGameObject()->getTransform()->getPosition();

  Mesh* mesh = collider->getMesh();
  std::vector<Vector3>* vertices = mesh->getVertices();

  // We basically want to set the mesh to the origin, including its rotation.
  // If we rotate the mesh, then we need to make sure we rotate the characters bounds too
  // so that the angle between the mesh and character remains the same.
  // If we set position to 0, 0, then we need to make the characters bounds box move the same way
  // (minus the mesh's position) so that it doesn't get closer.

  Matrix4x4 mat = Matrix4x4::getTrs(collider->getGameObject()->getTransform()->getPosition(),
                          collider->getGameObject()->getTransform()->getRotation(),
                          Vector3(1, 1, 1));
  mat = mat.inverse();

  Vector3 relPos = mat * pos;
  Vector3 extents = bounds.extents;
  extents.y = extents.y / 2.0f; // Set to 20.0f for a large step

  //**********************************************
  Collision collision;
  //collision.relativeVelocity = frameMoveSpeed;

  for(int v = 0; v < vertices->size(); v+=3)
  {
    Vector3 a = vertices->at(v);
    Vector3 b = vertices->at(v+1);
    Vector3 c = vertices->at(v+2);

    if(colliding(relPos, extents, a, b, c) == true)
    {
      ContactPoint contact;

      contact.normal = findNormal(a, b, c);
      contact.thisCollider = this;
      contact.otherCollider = collider;
      contact.a = a;
      contact.b = b;
      contact.c = c;

      collision.contacts.push_back(contact);
    }
  }

  Matrix4x4 rotMat = Matrix4x4::getIdentity();
  rotMat = rotMat.rotate(collider->getGameObject()->getTransform()->getRotation() * -1.0f);

  if(collision.contacts.size() > 0)
  {
    //relPos = handleCollision(collision, relPos, extents);
    //relPos = relPos + (rotMat * handleCollision(collision, relPos, extents));
    relPos = relPos + handleCollision(collision, relPos, extents);
  }
  //*******************************************

  ///////////////////////////////////
  Collision stepCollision;
  Vector3 stepExtents = bounds.extents;
  stepExtents.x = stepExtents.x / 2.0f;
  stepExtents.z = stepExtents.z / 2.0f;
  stepExtents.y = stepExtents.y + 0.01f;

  for(int v = 0; v < vertices->size(); v+=3)
  {
    Vector3 a = vertices->at(v);
    Vector3 b = vertices->at(v+1);
    Vector3 c = vertices->at(v+2);

    if(colliding(relPos, stepExtents, a, b, c) == true)
    {
      ContactPoint contact;

      contact.normal = findNormal(a, b, c);
      contact.thisCollider = this;
      contact.otherCollider = collider;
      contact.a = a;
      contact.b = b;
      contact.c = c;

      stepCollision.contacts.push_back(contact);
    }
  }

  stepExtents.y = stepExtents.y - 0.01f;

  if(stepCollision.contacts.size() > 0)
  {
    grounded = true;
    relPos = relPos + (rotMat * handleStep(stepCollision, relPos, stepExtents));
  }
  else
  {
    //grounded = false;
  }
  ///////////////////////////////////

  mat = mat.inverse();
  getGameObject()->getTransform()->setPosition(mat * relPos);
}
Ejemplo n.º 6
0
/**
 * Start has to happen gracefully: If the simulation was stopped for any
 * reason, it has to pick up where it left off.
 * The "runtime" argument is the additional time to run the simulation.
 */
void Clock::handleStart( const Eref& e, double runtime )
{
	unsigned int n = round( runtime / dt_ );
	handleStep( e, n );
}