1:
2:
3:
4:
5:
6:
7:
8:
9:
10:

    void move() {
      glm::vec3 dv(
        getForce(X),
        getForce(Y),
        getForce(Z)
      );
      
      v += glm::rotate(dv, player->rot.y, glm::vec3(0, -1, 0));
      player->pos += v * Time::diff;
    }					

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:

#define X 0
#define Y 1
#define Z 2
#define vFromH(v, a) sqrt(-2*a*v)

    Object3D* player;

    const float
      bounce = 0.2f,            //bounciness
      a[3] = { 40, 20, 40 },    //acceleration (force)
      vmax[3] = { 5, 100, 5 },  //max velocity
      vJump = vFromH(5, -a[Y]); //jump strength

    int8_t ad[3] = { 0, -1, 0 };  //acc direction
    glm::vec3 v(0);               //velocity					

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:

    float getForce(uint8_t d) {
      float dv;
      if (ad[d]) {              //accelerate
        if (d != Y)
          dv = 0;
        dv = ad[d] * a[d] * Time::diff;
        if (abs(v[d] + dv) > vmax[d]) {
          if (v[d] + dv > 0) return vmax[d] - v[d];
          return -vmax[d] - v[d];
        }
      } else {                  //brake
        if (!v[d]) return 0;
        dv = a[d] * Time::diff;
        if (v[d] > 0) dv = -dv;
        if (v[d] * (v[d] + dv) < 0) return -v[d]; //if change of sign -> v = 0
      }
      return dv;
    }					

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:

    glm::vec3 v(0), vLast;

    void move() {
      glm::vec3 dv(   //ermittelt geschwindigkeits-differenz zum nächsten Frame
        getForce(X),
        getForce(Y),
        getForce(Z)
      );

      //dreht geschwindigkeits-änderungs-Vektor um Y-Achse in Blickrichtung
      v += glm::rotate(dv, player->rot.y, glm::vec3(0, -1, 0));

      //wendet Maximalgeschwindigkeit an
      cropVel(X);
      cropVel(Y);
      cropVel(Z);

      //bewegt den Spieler
      player->pos += v * Time::diff; 

      //speichert Geschwindigkeit für nächste Berechnung
      vLast = v;                     
    }

    void cropVel(uint8_t d) {
      if (ad[d]) {                              //beim Beschleunigen
        if (v[d] > 0) {                         //  bei Positiver geschwindigkeit 
          if (v[d] > vmax[d]) v[d] = vmax[d];   //    v > vmax?
        } else                                  //  bei negativer geschwindigkeit 
          if (v[d] < -vmax[d]) v[d] = -vmax[d]; //    v < -vmax?
      } else                                    //beim Bremsen 
        if (v[d] * vLast[d] < 0) v[d] = 0;      //  Vorzeichenwechsel -> Beschleunigung beenden
    }

    float getForce(uint8_t d) {
      if (ad[d])                                //beim Beschleunigen 
        return ad[d] * a[d] * Time::diff;       //  richtung*beschl*Zeitdifferenz
      else {                                    //beim Bremsen
        if (!v[d]) return 0;                    //  keine Geschwindigkeit -> kein Bremsen nötig
                                                //  gegen geschwindigkeitsrichtung bremsen
        else if (v[d] < 0) return a[d] * Time::diff;
        else return -a[d] * Time::diff;
      }
    }					

1:
2:
3:
4:
5:
6:
7:

struct Actor {
  float mass;
  glm::vec3 x;  // position
  glm::vec3 dx; // velocity

  // vielleicht noch einen praktischen Konstruktor hinzufügen
}					

1:

typedef glm::vec3 Force;					

1:
2:
3:
4:
5:
6:

Actor simulate(const Actor& actor, const Force& f, const float dt) const {
  auto x = actor.x + actor.dx * dt;
  auto dx = actor.dx + f / actor.mass * dt; 
  
  return {actor.mass, x, dx};
}					

1:
2:
3:
4:
5:
6:
7:
8:
9:

// angenommen, wir haben eine Box "box" 
Actor box = {1.0f, {0.f, 0.f, 0.f}, {0.f, 0.f, 0.f}};
// und eine Kraft "f", sagen wir 1N in x-Richtung. 
Force f = {1.f, 0.f, 0.f}; 

// kannst du jetzt simulieren:
while (true) {
  box = simulate(box, f, Time::diff); 
}					

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:

Actor simulate(const Actor& actor, const Force& f, const float dt) const {
  auto x = actor.x + actor.dx * dt;
  auto dx = actor.dx + f / actor.mass * dt; 

  if (glm::abs(dx) > 42.f) {
    dx = dx / glm::abs(dx) * 42.f; // Vektor normieren, dann skalieren. Ob es glm::abs gibt oder nicht, ist mir vollkommen unklar ;-) 
  }
  
  return {actor.mass, x, dx};
}					

1:
2:
3:
4:

Force drag(const Actor& actor) {
  // angenommen cw * A * rho sei konstant = 1.0f
  return -(actor.dx / glm::abs(actor.dx)) * std::pow(glm::abs(actor.dx), 2);
}					

1:
2:
3:

// Ich will jetzt nicht ausschließen, dass dein Koordinatensystem anders ist, als ich hier annehme (x nach rechts, z nach oben, y in den Bildschirm hinein.) 
float alpha = player->rot.y; 
Force forwardForce = {std::cos(alpha), 0.f, std::sin(alpha)} * 10.f;					

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:

float Player::vmax = 5;
/* ... */
    void move() {
      glm::vec3 dv(
        getForce(X),
        getForce(Y),
        getForce(Z)
      );

      float dvges = sqrt(dv.x*dv.x + dv.z*dv.z);
      dv.x = dvges * std::sin(player->rot.y);
      dv.z = dvges * std::cos(player->rot.y);

      v += dv;
      
      float vges = sqrt(v.x*v.x + v.z*v.z);
      if (vges > Player::vmax) printf("%f    %f\n", dv.x, dv.z), v = Player::vmax * v / vges;

      player->pos += v * Time::diff;
      vLast = v;
    }					

1:
2:
3:
4:
5:
6:
7:

      float dvges = sqrt(dv.x*dv.x + dv.z*dv.z);
      
      if (dv.x < 0) dv.x = -dvges * sin(player->rot.y);
      else dv.x = dvges * sin(player->rot.y);
      
      if (dv.z < 0) dv.z = -dvges * cos(player->rot.y);
      else dv.z = dvges * cos(player->rot.y);					

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:

    void move() {
      glm::vec3 dv(
        getForce(X),
        getForce(Y),
        getForce(Z)
      );
      
      float ang = atan2(dv.x, dv.z) + player->rot.y;
      //Ausgabe: Blickwinkel, Pfeiltastenwinkel, resultierender Bewegungswinkel, Winkel nach Bewegung
      //ich hätte erst vermutet, dass es atan2(cos,sin) sein müsste, aber das war irgendwie nicht so
      //der Winkel nach Bewegung ist jetzt so eingestellt, dass er gleich dem resultierender Bewegungswinkel ist
      printf("%f\t%f\t%f\t%f\n", player->rot.y, atan2(dv.x, dv.z), ang, atan2(sin(ang), cos(ang)));
      //wenn ich folgende zwei Zeilen auskommentiere, werden alle Winkel richtig errechnet
      //wenn sie aber drin sind, ist sogar die obige Ausgabe fehlerhaft, obwohl beide nichts miteinander zu tun haben
      dv.x = total*sin(ang);
      dv.z = total*cos(ang);

      v += dv * Time::diff;
      
      total = sqrt(v.x*v.x + v.z*v.z);
      if (total > Player::vmax) {
        v.x = Player::vmax * v.x / total;
        v.z = Player::vmax * v.z / total;
      }
      if (!ad[X] && vLast.x * v.x < 0) v.x = 0;
      if (!ad[Y] && vLast.y * v.y < 0) v.y = 0;
      if (!ad[Z] && vLast.z * v.z < 0) v.z = 0;

      player->pos += v * Time::diff;
      vLast = v;
    }					

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:

#pragma once

#include "Object3D.h"

class Actor : public Object3D {
public:

  float mass;
  glm::vec3 v; //velocity
  //pos and rot come from Object3D

  Actor(uint8_t type, GLuint texture, GLuint shader, glm::vec3 pos = glm::vec3(0), float mass = 1);
  Actor(Object3D obj, glm::vec3 pos = glm::vec3(0), float mass = 1);
  ~Actor();

  void move(glm::vec3 force, float dt);
};					

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:

#include "stdafx.h"
#include "Actor.h"

Actor::Actor(uint8_t type, GLuint texture, GLuint shader, glm::vec3 pos, float mass) : Object3D(type, texture, shader) {
  this->pos = pos;
  this->mass = mass;
}

Actor::Actor(Object3D obj, glm::vec3 pos, float mass) : Object3D(obj) {
  this->pos = pos;
  this->mass = mass;
}

Actor::~Actor() {}

void Actor::move(glm::vec3 force, float dt)  {
  v += dt * force / mass;
  pos += dt * v;
}					

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:

namespace Game {
  /* ... */

  namespace Player {
    Actor* player;

    const float
      vmax = 5,
      bounce = 0.2f,
      aMove[3] = { 20, -9.81f, 20 },
      vJump = vFromH(5, -aMove[Y]);

    bool collided = false;
  }

  /* ... */
}

/* ... */

void Game::handleInput() {
  // Keyboard
  if (glfwGetKey(window, GLFW_KEY_SPACE) == GLFW_PRESS) Player::player->v.y = Player::vJump;
  if (glfwGetKey(window, GLFW_KEY_LEFT) == GLFW_PRESS) Player::player->rot.y += Mouse::speed;
  if (glfwGetKey(window, GLFW_KEY_RIGHT) == GLFW_PRESS) Player::player->rot.y -= Mouse::speed;

  //die Stelle sier sieht seltsam aus, ich weiß
  //beschleunigung * x/y-Komponente des Winkels * Tastendruck
  glm::vec3 force = {
    Player::aMove[X] * std::cos(Player::player->rot.y) * ((glfwGetKey(window, GLFW_KEY_S) == GLFW_PRESS) - (glfwGetKey(window, GLFW_KEY_W) == GLFW_PRESS)),
    Player::aMove[Y],
    Player::aMove[Z] * std::sin(Player::player->rot.y) * ((glfwGetKey(window, GLFW_KEY_D) == GLFW_PRESS) - (glfwGetKey(window, GLFW_KEY_A) == GLFW_PRESS))
  };

  Player::player->move(force, Time::diff);

  /* ... */
}					

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:

blick pfeil beweg(relativ zu blickrichtung)
------------------
  0°  oben   links
      unten  rechts
 90°  links  links
      rechts rechts
180°  oben   links
      unten  rechts
-90°  links  links
      rechts rechts

die jeweils anderen zwei Pfeiltasten bewirken nichts