diff --git a/draw_12_tilted_rects.c b/draw_12_tilted_rects.c new file mode 100644 index 0000000..5697099 --- /dev/null +++ b/draw_12_tilted_rects.c @@ -0,0 +1,232 @@ +/*===================================================================== + draw_12_tilted_rects.c + --------------------------------------------------------------- + Creates an 800×600 ARGB frame‑buffer, draws 12 white rectangles + whose top and bottom edges are slanted (as in the Python example + you supplied) and streams the buffer to a TCP server on + localhost:12345. + + Compile (Linux / macOS): + gcc -Wall -O2 draw_12_tilted_rects.c -lm -o draw_12_tilted_rects + + Run: + ./draw_12_tilted_rects + + -------------------------------------------------------------------*/ +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#define FB_W 800 /* framebuffer width */ +#define FB_H 600 /* framebuffer height */ +#define BPP 4 /* bytes per pixel (A,R,G,B) */ +#define FRAMEBUF_SIZE (FB_W * FB_H * BPP) + +#define MARGIN_TOP 100 +#define MARGIN_BOTTOM 150 + +#define SPACING 10 /* space between rectangles */ +#define LINE_THICKNESS 4 /* thickness of outline (pixels) */ +#define NUM_RECTS 12 + +/*---------------------------------------------------------------*/ +/* 1. Per‑rectangle tilt angles (in degrees). Edit as you wish. */ +static int16_t rotAnglesDeg[NUM_RECTS] = { + 0, 5, 10, 15, 20, 25, + 30, 35, 40, 45, 50, 55 +}; + +/*---------------------------------------------------------------*/ +/* 2. ARGB colour helpers */ +static const uint32_t COL_BLACK = 0xFF000000; /* opaque black */ +static const uint32_t COL_WHITE = 0xFFFFFFFF; /* opaque white */ + +/*---------------------------------------------------------------*/ +/* 3. Simple pixel write (bounds‑checked) */ +static inline void set_pixel(uint8_t *fb, int x, int y, uint32_t col) +{ + if (x < 0 || x >= FB_W || y < 0 || y >= FB_H) + return; /* ignore out‑of‑bounds writes */ + uint32_t *dst = (uint32_t *)(fb + (y * FB_W + x) * BPP); + *dst = col; +} + +/*---------------------------------------------------------------*/ +/* 4. Thick line – Bresenham + square brush */ +static void draw_thick_line(uint8_t *fb, + int x0, int y0, + int x1, int y1, + uint32_t col, + int thickness) +{ + int dx = abs(x1 - x0); + int dy = -abs(y1 - y0); + int sx = (x0 < x1) ? 1 : -1; + int sy = (y0 < y1) ? 1 : -1; + int err = dx + dy; /* error term */ + + while (1) { + /* paint a square centred on the current pixel */ + for (int ty = -thickness/2; ty <= thickness/2; ++ty) { + for (int tx = -thickness/2; tx <= thickness/2; ++tx) { + set_pixel(fb, x0 + tx, y0 + ty, col); + } + } + if (x0 == x1 && y0 == y1) break; + int e2 = 2 * err; + if (e2 >= dy) { err += dy; x0 += sx; } + if (e2 <= dx) { err += dx; y0 += sy; } + } +} + +/*---------------------------------------------------------------*/ +/* 5. Build the whole framebuffer */ +static void build_framebuffer(uint8_t *fb) +{ + /* 5.1 background = opaque black */ + for (size_t i = 0; i < FRAMEBUF_SIZE; ++i) fb[i] = 0; + uint32_t *pix = (uint32_t *)fb; + for (size_t i = 0; i < FB_W * FB_H; ++i) pix[i] = COL_BLACK; + + /* 5.2 geometry that does NOT depend on the angle */ + const int usable_h = FB_H - MARGIN_TOP - MARGIN_BOTTOM; /* 400 */ + const int rect_h = usable_h; /* 400 */ + const int rect_w = rect_h / 8; /* ≈33 */ + const int half_w = rect_w / 2; + + const int total_rect_w = NUM_RECTS * rect_w + (NUM_RECTS - 1) * SPACING; + const int x0_start = (FB_W - total_rect_w) / 2; /* centre strip */ + + const int y_top = MARGIN_TOP; + const int y_bottom = FB_H - MARGIN_BOTTOM - 1; /* inclusive */ + + /* 5.3 draw each rectangle */ + for (int i = 0; i < NUM_RECTS; ++i) { + /* ---- centre X (kept fixed while tilting) ---- */ + int orig_x0 = x0_start + i * (rect_w + SPACING); + int cx = orig_x0 + half_w; /* centre X coordinate */ + + /* ---- angle in radians, sin and cos ---- */ + double angle_rad = rotAnglesDeg[i] * M_PI / 180.0; + double sin_a = sin(angle_rad); + double cos_a = cos(angle_rad); + + /* ---- vertical offset applied to the end‑points of the top/bottom lines ---- */ + double offset = sin_a * half_w; /* sin(angle) * (RECT_W/2) */ + + /* ---- X offsets for the slanted top/bottom edges ---- */ + double x_offset = cos_a * half_w; /* cos(angle) * (RECT_W/2) */ + + /* ---- compute the four end‑points (rounded to nearest integer) ---- */ + int x0_top = (int)round(cx - x_offset); + int y0_top = (int)round(y_top + offset); + int x1_top = (int)round(cx + x_offset); + int y1_top = (int)round(y_top - offset); + + int x0_bot = (int)round(cx - x_offset); + int y0_bot = (int)round(y_bottom - offset); + int x1_bot = (int)round(cx + x_offset); + int y1_bot = (int)round(y_bottom + offset); + + /* ---- draw the four sides (thick) ---- */ + draw_thick_line(fb, x0_top, y0_top, x1_top, y1_top, + COL_WHITE, LINE_THICKNESS); /* top */ + draw_thick_line(fb, x0_bot, y0_bot, x1_bot, y1_bot, + COL_WHITE, LINE_THICKNESS); /* bottom*/ + + /* vertical sides – use the X coordinates of the *top* points; + the Y‑coordinates are taken from the corresponding top/bottom + endpoint, therefore they are automatically different when the + angle ≠ 0 or 180. */ + draw_thick_line(fb, x0_top, y0_top, x0_bot, y0_bot, + COL_WHITE, LINE_THICKNESS); /* left */ + draw_thick_line(fb, x1_top, y1_top, x1_bot, y1_bot, + COL_WHITE, LINE_THICKNESS); /* right */ + } +} + +/*---------------------------------------------------------------*/ +/* 6. Send the framebuffer over TCP (length‑prefixed) */ +static int send_framebuffer(const uint8_t *fb, size_t len, + const char *host, uint16_t port) +{ + struct sockaddr_in srv; + int sock = socket(AF_INET, SOCK_STREAM, 0); + if (sock < 0) { + perror("socket"); + return -1; + } + + memset(&srv, 0, sizeof(srv)); + srv.sin_family = AF_INET; + srv.sin_port = htons(port); + if (inet_pton(AF_INET, host, &srv.sin_addr) <= 0) { + perror("inet_pton"); + close(sock); + return -1; + } + + if (connect(sock, (struct sockaddr *)&srv, sizeof(srv)) < 0) { + perror("connect"); + close(sock); + return -1; + } + + /* ---- optional 4‑byte length prefix (big‑endian) ---- */ + uint32_t be_len = htonl((uint32_t)len); + if (write(sock, &be_len, sizeof(be_len)) != sizeof(be_len)) { + perror("write length prefix"); + close(sock); + return -1; + } + + /* ---- send the raw buffer ---- */ + size_t sent = 0; + while (sent < len) { + ssize_t n = write(sock, fb + sent, len - sent); + if (n <= 0) { + perror("write framebuffer"); + close(sock); + return -1; + } + sent += n; + } + + close(sock); + return 0; +} + +/*---------------------------------------------------------------*/ +int main(void) +{ + uint8_t *framebuf = malloc(FRAMEBUF_SIZE); + if (!framebuf) { + fprintf(stderr, "Failed to allocate framebuffer (%zu bytes)\n", + (size_t)FRAMEBUF_SIZE); + return EXIT_FAILURE; + } + + while(1){ + for(uint8_t i=0; i