fphysics/main.c

#include <math.h>
#include <time.h>
#include <pthread.h>
#include <raylib.h>
#include <stdio.h>
#include <stdlib.h>

static const Vector2 NULL_VEC2 = {0, 0};

typedef struct {
  float mass;
  float radius;
  Vector2 position;
  Vector2 speed;
} mass_body_t;

int center_x_text(const char *text, int width, int size) {
  return (width - MeasureText(text, size)) / 2;
}

static inline int center_y_text(int height, int size) { return (height - size) / 2; }

Vector2 transform_to_center(Vector2 v) {
  int width = GetRenderWidth();
  int height = GetRenderHeight();
  Vector2 result = {v.x + width / 2.0, v.y + height / 2.0};
  return result;
}

Vector2 vec2_sum(const Vector2 *a, const Vector2 *b) {
  Vector2 result = {a->x + b->x, a->y + b->y};
  return result;
}
Vector2 vec2_diff(const Vector2 *a, const Vector2 *b) {
  Vector2 result = {a->x - b->x, a->y - b->y};
  return result;
}

float vec2_len(Vector2 v) { return sqrtf(v.x * v.x + v.y * v.y); }

Vector2 vec2_normalize(const Vector2 v) {
  float len = vec2_len(v);
  Vector2 result = {v.x / len, v.y / len};
  return result;
}

Vector2 vec2_scale(const Vector2 *normal, const float len) {
  Vector2 result = {len * normal->x, len * normal->y};
  return result;
}

float vec2_dot(const Vector2 *a, const Vector2 *b) {
  return a->x * b->x + a->y * b->y;
}

Vector2 body_collision(mass_body_t *a, mass_body_t *b) {
  Vector2 diff = vec2_diff(&a->position, &b->position);
  float len = vec2_len(diff);
  if (len > a->radius + b->radius) {
    return NULL_VEC2;
  }
  Vector2 result = vec2_normalize(diff);
  return result;
}

Vector2 edge_collision(mass_body_t *b) {
  float width = GetRenderWidth();
  float height = GetRenderHeight();
  Vector2 result = {0, 0};
  if (b->position.x + b->radius > width / 2) {
    result.x = -1;
  } else if (b->position.x - b->radius < -width / 2) {
    result.x = 1;
  }

  if (b->position.y + b->radius > height / 2) {
    result.y = -1;
  } else if (b->position.y - b->radius < -height / 2) {
    result.y = 1;
  }

  if (result.x == 0 && result.y == 0) {
    return NULL_VEC2;
  }

  return vec2_normalize(result);
}

void collide(mass_body_t *a, mass_body_t *b, const Vector2 *normal,
             float resitution) {
  Vector2 relative = vec2_diff(&b->speed, &a->speed);
  float v_normal = vec2_dot(&relative, normal);

  float factor = -(1 + resitution);
  float j = factor * v_normal;

  j /= (1.0 / a->mass) + (1.0 / b->mass);

  Vector2 final = vec2_scale(normal, j);

  Vector2 a_diff = vec2_scale(&final, 1.0 / a->mass);
  a->speed = vec2_diff(&a->speed, &a_diff);
  Vector2 b_diff = vec2_scale(&final, 1.0 / b->mass);
  b->speed = vec2_sum(&b->speed, &b_diff);
}

void collide_rigid(mass_body_t *a, const Vector2 *normal, float restitution) {

  float v_normal = vec2_dot(&a->speed, normal);

  Vector2 delta_v = vec2_scale(normal, -(1.0 + restitution) * v_normal);
  a->speed = vec2_sum(&a->speed, &delta_v);
}

bool vec2_is_null(Vector2 v) {
  if (v.x == 0 && v.y == 0) {
    return true;
  }
  return false;
}

typedef struct universe {
  unsigned int num_bodies;
  mass_body_t *bodies;
} universe_t;

void *physics(void *args) {
  universe_t* uni= (universe_t*)args;
  mass_body_t body_1;
  mass_body_t body_2;
  Vector2 collision;
  while(true){
      for(unsigned int i=0;i<uni->num_bodies;i++){
          body_1=uni->bodies[i];
          printf("body %d pos is : %f %f \n speed is : %f %f\n",i,uni->bodies[i].position.x,uni->bodies[i].position.y,uni->bodies[i].speed.x,uni->bodies[i].speed.x);
          body_1.position = vec2_sum(&body_1.position, &body_1.speed);
          printf("body %d pos is : %f %f \n speed is : %f %f\n",i,uni->bodies[i].position.x,uni->bodies[i].position.y,uni->bodies[i].speed.x,uni->bodies[i].speed.x);
          for(unsigned int y=0;y<uni->num_bodies;y++){
              body_2=uni->bodies[y];
              collision = body_collision(&body_1, &body_2);
              if(!vec2_is_null(collision)){
                  collide(&body_1,&body_2,&collision,1.0);
              }
              uni->bodies[y]=body_2;
          }
        collision = edge_collision(&body_1);
        if (!vec2_is_null(collision)) {
            collide_rigid(&body_1, &collision, 1.0);
        }
        uni->bodies[i]=body_1;
      }
  }
}

int main(void) {
  pthread_t physics_thread;
  const char *welcome_text = "Welcome to Fucked Physics!";
  universe_t universe = {0, NULL};
  pthread_create(&physics_thread,NULL,physics,(void*)&universe);
  universe.bodies = malloc(1024 * sizeof(mass_body_t));

  mass_body_t body_1 = {100, 50, {-200, -100}, {0.5, 0.1}};
  mass_body_t body_2 = {100, 50, {200, 0}, {-0.5, 0}};
  universe.bodies[0]=body_1;
  universe.bodies[1]=body_2;
  universe.num_bodies=2;
  SetConfigFlags(FLAG_WINDOW_RESIZABLE);
  InitWindow(800, 450, "Fucked Physics");
  SetTargetFPS(120);

  while (!WindowShouldClose()) {

    BeginDrawing();
    ClearBackground(RAYWHITE);
    for(unsigned int i=0;i<universe.num_bodies;i++){
        DrawCircleV(transform_to_center(universe.bodies[i].position), universe.bodies[i].radius, (Color){((256/universe.num_bodies)*i)%256,255*(i%2),255*(i%2)*(i%3),255});
    }




    DrawText(welcome_text, center_x_text(welcome_text, GetRenderWidth(), 20),
    center_y_text(GetRenderHeight(), 20), 20, BLACK);
    EndDrawing();
  }

  CloseWindow();
  return EXIT_SUCCESS;
}