add some grid functionality and refactor

Author: Gedulis12

build.sh

@@ -2,4 +2,7 @@
 
 set -xe
 
-gcc -o main main.c -I/usr/include/SDL2 -lSDL2 -lSDL2_ttf -lm -Wall -Wextra -g
+gcc \
+    -o main \
+    main.c grid.c common.c particle.c \
+    -I/usr/include/SDL2 -lSDL2 -lSDL2_ttf -lm -Wall -Wextra -g -O3

common.c

@@ -0,0 +1,75 @@
+#include "common.h"
+
+
+int sdl_setup(SDL_Window **w, SDL_Renderer **r, TTF_Font **f)
+{
+    if (SDL_Init(SDL_INIT_EVERYTHING) != 0)
+    {
+        fprintf(stderr, "SDL_Init failed: %s\n", SDL_GetError());
+        return 1;
+    }
+
+    *w = SDL_CreateWindow("SDL2 test",
+                                      SDL_WINDOWPOS_CENTERED,
+                                      SDL_WINDOWPOS_CENTERED,
+                                      SCREEN_W, SCREEN_H,
+                                      SDL_WINDOW_RESIZABLE);
+
+    if (!*w)
+    {
+        fprintf(stderr, "SDL_CreateWindow failed: %s\n", SDL_GetError());
+        return 1;
+    }
+
+    if (TTF_Init() != 0) {
+        fprintf(stderr, "TTF_Init failed: %s\n", TTF_GetError());
+        SDL_Quit();
+        return 1;
+    }
+
+    *r = SDL_CreateRenderer(*w, -1, SDL_RENDERER_ACCELERATED);
+    if (!*r)
+    {
+        fprintf(stderr, "SDL_CreateRenderer failed: %s\n", SDL_GetError());
+        return 1;
+    }
+
+    *f = TTF_OpenFont("/usr/share/fonts/truetype/noto/NotoSansMono-Regular.ttf", 24);
+    if (!*f) {
+        fprintf(stderr, "TTF_OpenFont failed: %s\n", TTF_GetError());
+        SDL_DestroyRenderer(*r);
+        SDL_DestroyWindow(*w);
+        TTF_Quit();
+        SDL_Quit();
+        return 1;
+    }
+    return 0;
+}
+
+void sdl_cleanup(SDL_Window **w, SDL_Renderer **r, TTF_Font **f)
+{
+    TTF_CloseFont(*f);
+    SDL_DestroyRenderer(*r);
+    SDL_DestroyWindow(*w);
+    TTF_Quit();
+    SDL_Quit();
+}
+
+void draw_stats(SDL_Renderer *r, float dt, int particle_count, TTF_Font *font) {
+    SDL_Color white = {255, 255, 255, 255};
+    char stats_text[64];
+    float fps = 1.0f / dt;
+    snprintf(stats_text, sizeof(stats_text), "Particles: %d, FPS: %.2f", particle_count, fps);
+
+    SDL_Surface* text_surface = TTF_RenderText_Solid(font, stats_text, white);
+    SDL_Texture* text_texture = SDL_CreateTextureFromSurface(r, text_surface);
+    SDL_Rect text_rect = {10, 10, text_surface->w, text_surface->h};
+    SDL_RenderCopy(r, text_texture, NULL, &text_rect);
+    SDL_FreeSurface(text_surface);
+    SDL_DestroyTexture(text_texture);
+}
+
+uint f_randi(uint index) {
+    index = (index << 13) ^ index;
+    return ((index * (index * index * 15731 + 789221) + 1376312589) & 0x7fffffff);
+}

common.h

@@ -0,0 +1,21 @@
+#ifndef _COMMON_
+#define _COMMON_
+#include <SDL2/SDL.h>
+#include <SDL2/SDL_ttf.h>
+
+#define SCREEN_W 800
+#define SCREEN_H 600
+
+#define MIN_RADIUS 8
+#define MAX_RADIUS 8
+
+typedef struct Vec2 {
+    float x, y;
+} Vec2;
+
+int sdl_setup(SDL_Window **w, SDL_Renderer **r, TTF_Font **f);
+void sdl_cleanup(SDL_Window **w, SDL_Renderer **r, TTF_Font **f);
+void draw_stats(SDL_Renderer *r, float dt, int particle_count, TTF_Font *font);
+uint f_randi(uint index);
+
+#endif //_COMMON_

grid.c

@@ -0,0 +1,152 @@
+#include "grid.h"
+#include "particle.h"
+
+Grid* grid_init()
+{
+    Grid *g = (Grid*)malloc(sizeof(Grid));
+    grid_get_tile_len(g, SCREEN_W, SCREEN_H, MAX_RADIUS);
+    g->cols = (SCREEN_W / g->tile_len);
+    g->rows = (SCREEN_H / g->tile_len);
+    g->tiles = (Tile*)malloc(sizeof(Tile) * (g->rows * g->cols));
+    for (int i = 0; i < g->rows; i++)
+    {
+        for (int j = 0; j < g->cols; j++)
+        {
+            int id = i * g->cols + j;
+
+            g->tiles->id = id;
+            g->tiles[id].pos.x = j * g->tile_len;
+            g->tiles[id].pos.y = i * g->tile_len;
+            printf("id: %d, x: %d, y: %d\n", id, j*g->tile_len, i*g->tile_len);
+        }
+    }
+    printf("rows: %d, cols: %d\n", g->rows, g->cols);
+    return g;
+}
+
+void grid_get_tile_len(Grid *g, int w, int h, int max_radius)
+{
+    int size = max_radius;
+    while ((w % size != 0 || h % size != 0) && (size < w && size < h))
+    {
+        size++;
+    }
+    g->tile_len = size;
+}
+
+Tile* grid_get_tile_by_pos(Grid *g, int x, int y)
+{
+
+    int id = (g->cols - 1) * y + x;
+    if (id == g->tiles->id)
+    {
+        return &g->tiles[id];
+    }
+    return NULL;
+}
+
+void grid_free(Grid *g)
+{
+    free(g->tiles);
+    g->tiles = NULL;
+    free(g);
+}
+
+void grid_debug_draw(SDL_Renderer *r, Grid *g)
+{
+    if (g == NULL) return;
+
+    SDL_SetRenderDrawColor(r, 255, 255, 255, 0);
+    int x = g->tile_len;
+    int y = g->tile_len;
+    while (x < SCREEN_W)
+    {
+        SDL_RenderDrawLine(r, x, 0, x, SCREEN_H);
+        x += g->tile_len;
+    }
+    while (y < SCREEN_H)
+    {
+        SDL_RenderDrawLine(r, 0, y, SCREEN_W, y);
+        y += g->tile_len;
+    }
+}
+
+void tiles_check_collisions(Tile *t1, Tile *t2)
+{
+    Particles p;
+    particles_init(&p, 8);
+
+    for (size_t i = 0; i < t1->p->used; i++)
+    {
+        particles_add(&p, t1->p->array[i]);
+    }
+
+    for (size_t i = 0; i < t2->p->used; i++)
+    {
+        particles_add(&p, t2->p->array[i]);
+    }
+
+    particles_solve_collisions(&p);
+    particles_free(&p);
+}
+
+void grid_populate_tiles_with_particles(Grid *g, Particles *p)
+{
+    for (size_t i = 0; i < p->used; i++)
+    {
+        Particle *check = &p->array[i];
+        int x = check->current.x / (g->cols * g->tile_len);
+        int y = check->current.y / (g->rows * g->tile_len);
+
+        Tile *t = grid_get_tile_by_pos(g, x, y);
+
+        if (!t->p->array)
+        {
+            particles_init(t->p, 4);
+        }
+        particles_add(t->p, *check);
+    }
+}
+
+/*
+-int grid_get_id_by_pos(Grid *g, int x, int y)
+-{
+-    if (x < 0 || x >= SCREEN_W || y < 0 || y >= SCREEN_H) {
+-        return -1;
+-    }
+-
+-    int colid = (int)(x / g->tile_len);
+-    int rowid = (int)(y / g->tile_len);
+-    int id = rowid * g->cols + colid;
+-    printf("id: %d, x: %d, y: %d\n", id, x, y);
+-    return id;
+-}
+*/
+
+void grid_find_collisions(Grid *g)
+{
+    for (int x = 0; x < g->cols; x++)
+    {
+        for (int y = 0; y < g->rows; x++)
+        {
+            Tile *t = grid_get_tile_by_pos(g, x, y);
+
+            int dx_min, dx_max = -1;
+            int dy_min, dy_max = 1;
+
+            if (x == 0) dx_min = 0;
+            if ((int)x == g->cols-1) dx_max = 0;
+
+            if (y == 0) dy_min = 0;
+            if ((int)y == g->rows-1) dy_max = 0;
+
+            for (int dx = dx_min; dx <= dx_max; dx++)
+            {
+                for (int dy = dy_min; dy <= dy_max; dy++)
+                {
+                    Tile *t2 = grid_get_tile_by_pos(g, x + dx, y + dy);
+                }
+            }
+        }
+    }
+}

grid.h

@@ -0,0 +1,28 @@
+#ifndef _GRID_
+#define _GRID_
+
+#include <stdint.h>
+#include "common.h"
+#include "particle.h"
+
+typedef struct tile {
+    int id;
+    Vec2 pos;
+    Particles *p;
+} Tile;
+
+typedef struct {
+    Tile *tiles;
+    int tile_len;
+    int rows, cols;
+} Grid;
+
+Grid* grid_init();
+void grid_get_tile_len(Grid *g, int w, int h, int max_radius);
+Tile* grid_get_tile_by_pos(Grid *g, int x, int y);
+void tiles_check_collisions(Tile *t1, Tile *t2);
+void grid_find_collisions(Grid *g);
+void grid_debug_draw(SDL_Renderer *r, Grid *g);
+void grid_free(Grid *g);
+
+#endif //_GRID_