spieleprogrammierer.de - Forum und Wiki zur Spieleprogrammierung und Spieleentwicklung

C-/C++-Quelltext

    void AddRotationAbs(const tbVector3& vAdd)  {m_vRotation += tbVector3TransformNormal(vAdd, m_mMatrix);}

C-/C++-Quelltext

// Kraft einwirken lassen

void tbObject::ApplyForce(const tbVector3& vAttack,
                          const tbVector3& vForce,
                          const float fMovementExaggeration,    // = 1.0f

                          const float fRotationExaggeration)    // = 1.0f

{
    // Diese Funktion stellt den Kern der gesamten Physikeinheit dar.

    // Sie berechnet die Wirkungen der Kraft mit der Richtung und

    // Stärke vForce, die am Punkt vAttack angreift.

    // Beides sind absolute Angaben.


    // Rotations- und Bewegungsfaktor werden berechnet.

    // Sie bestimmen, welcher Anteil der Kraft in eine Rotation und

    // welcher in eine Bewegung umgewandelt wird.

    // Ihre Summe ergibt immer 1, daher braucht man nur einen der

    // beiden Faktoren zu berechnen.

    // Der Rotationsfaktor ist das Verhältnis zwischen dem Quadrat der

    // kürzesten Distanz zwischen dem Schwerpunkt und der Linie

    // mit der Richtung der Kraft, die durch den Angriffspunkt geht,

    // und dem Quadrat des Radius.

    float r = tbPointLineDistance(m_vPosition,
                                  vAttack - (10000.0f * vForce),
                                  vAttack + (10000.0f * vForce));
    float fRotationFactor = (r * r) / (m_fRadius * m_fRadius);
    if(fRotationFactor > 1.0f) fRotationFactor = 1.0f;

    // Der Bewegungsfaktor kann nun ganz leicht berechnet werden.

    float fMovementFactor = 1.0f - fRotationFactor;

    // Kehrwert der Masse bestimmen (für schnellere Division)

    float fInvMass = 1.0f / m_fMass;

    if(fMovementFactor >= 0.0001f)
    {
        // Dem Objekt Bewegung hinzufügen. Man erhält sie, indem man

        // die Richtung der Kraft mit dem Bewegungsfaktor multipliziert

        // und das Produkt durch die Masse des Objekts teilt.

        // Alles wird noch mit einem bestimmten Faktor multipliziert,

        // um den Effekt ein wenig zu übertreiben.

        AddVelocityAbs(fMovementFactor * fMovementExaggeration * vForce * fInvMass);
    }

    if(fRotationFactor >= 0.0001f)
    {
        // Rotation hinzufügen. Erst rechnen wir die relative Position des Angriffspunkts

        // aus und teilen sie durch den Radius. Die Richtung der Kraft wird ebenfalls

        // in eine relative Richtung umgerechnet.

        tbVector3 vRelAttack(AbsToRelPos(vAttack) / m_fRadius);
        tbVector3 vRelForce(AbsToRelDir(vForce));

        // Rotation um die x-Achse

        AddRotationRel(tbVector3(vRelAttack.z * -vRelForce.y * fInvMass, 0.0f, 0.0f));
        AddRotationRel(tbVector3(vRelAttack.y * vRelForce.z * fInvMass, 0.0f, 0.0f));

        // Rotation um die y-Achse

        AddRotationRel(tbVector3(0.0f, vRelAttack.x * vRelForce.z * fInvMass, 0.0f));
        AddRotationRel(tbVector3(0.0f, vRelAttack.z * vRelForce.x * fInvMass, 0.0f));

        // Rotation um die z-Achse

        AddRotationRel(tbVector3(0.0f, 0.0f, vRelAttack.x * -vRelForce.y * fInvMass));
        AddRotationRel(tbVector3(0.0f, 0.0f, vRelAttack.y * vRelForce.x * fInvMass));
    }
}

C-/C++-Quelltext

        // Rotation um die x-Achse

        AddRotationRel(tbVector3(vRelAttack.z * -vRelForce.y * fInvMass, 0.0f, 0.0f));
        AddRotationRel(tbVector3(vRelAttack.y * vRelForce.z * fInvMass, 0.0f, 0.0f));

        // Rotation um die y-Achse

        AddRotationRel(tbVector3(0.0f, vRelAttack.x * vRelForce.z * fInvMass, 0.0f));
        AddRotationRel(tbVector3(0.0f, vRelAttack.z * vRelForce.x * fInvMass, 0.0f));

        // Rotation um die z-Achse

        AddRotationRel(tbVector3(0.0f, 0.0f, vRelAttack.x * -vRelForce.y * fInvMass));
        AddRotationRel(tbVector3(0.0f, 0.0f, vRelAttack.y * vRelForce.x * fInvMass));