diff options
| -rwxr-xr-x | graphics.c | 589 | ||||
| -rwxr-xr-x | reduced_system_layer.c | 40 |
2 files changed, 399 insertions, 230 deletions
@@ -81,41 +81,12 @@ typedef struct { vec4_f32 *pixels; } Pixel_Buffer; -vec3_f32 lab_from_rgb(vec3_f32 rgb); -vec3_f32 rgb_from_lab(vec3_f32 lab); -vec3_f32 lab_from_lch(vec3_f32 lch); -vec3_f32 lch_from_lab(vec3_f32 lab); -vec3_f32 rgb_from_lch(vec3_f32 lch); -vec3_f32 lch_from_rgb(vec3_f32 rgb); - -// NOTE: General rule to work with gamma is removing it, -// then doing computations like blending, interpolation, etc, -// then adding it back. - -vec3_f32 rgb_gamma_add (vec3_f32 rgb); -vec3_f32 rgb_gamma_remove (vec3_f32 rgb); -vec4_f32 rgba_gamma_add (vec4_f32 rgb); -vec4_f32 rgba_gamma_remove(vec4_f32 rgb); - -vec3_f32 rgb_gamma_lerp (vec3_f32 a, vec3_f32 b, f32 t); -vec4_f32 rgba_gamma_lerp(vec4_f32 a, vec4_f32 b, f32 t); -vec3_f32 rgb_mix (vec3_f32 a, vec3_f32 b, f32 t); -vec4_f32 rgba_mix (vec4_f32 a, vec4_f32 b, f32 t); -vec3_f32 lch_mix (vec3_f32 a, vec3_f32 b, f32 t); -vec3_f32 lch_lerp (vec3_f32 a, vec3_f32 b, f32 t); - -u32 rgb_u32_from_f32(vec3_f32 color); -vec3_f32 rgb_f32_from_u32(u32 color); -u32 rgba_u32_from_f32(vec4_f32 color); -vec4_f32 rgba_f32_from_u32(u32 color); - -b8 hit_rectangle(f64 x0, f64 y0, f64 width, f64 height, f64 px, f64 py); -b8 hit_triangle (f64 x0, f64 y0, f64 x1, f64 y1, f64 x2, f64 y2, f64 px, f64 py); -b8 hit_quad (f64 x0, f64 y0, f64 x1, f64 y1, f64 x2, f64 y2, f64 x3, f64 y3, f64 px, f64 py); -b8 hit_ellipse (f64 x0, f64 y0, f64 width, f64 height, f64 px, f64 py); -b8 hit_line (f64 x0, f64 y0, f64 x1, f64 y1, f64 width, f64 px, f64 py); - -// ================================================================ +typedef struct { + f64 x; + f64 y; + f64 width; + f64 height; +} Box; enum { GRAPHICS_OP_NONE = 0, @@ -130,13 +101,6 @@ enum { GRAPHICS_OP_TEXT_CURSOR, }; -typedef struct { - f64 x; - f64 y; - f64 width; - f64 height; -} Box; - typedef struct graphics_request_ { u16 op; union { @@ -180,22 +144,63 @@ typedef struct graphics_request_ { vec4_f32 color; Box area; vec2 max_size; - i64 cursor; - i64 selection; i64 num_chars; c32 * text; + i64 cursor; + i64 selection; } text_cursor; }; } Graphics_Request; typedef struct { - i64 sketch_size; - vec4_f32 * sketch; vec2 scale; Pixel_Buffer dst; } Graphics_Context; -void perform_graphics_reqeust(Graphics_Context context, Graphics_Request req); +vec3_f32 lab_from_rgb(vec3_f32 rgb); +vec3_f32 rgb_from_lab(vec3_f32 lab); +vec3_f32 lab_from_lch(vec3_f32 lch); +vec3_f32 lch_from_lab(vec3_f32 lab); +vec3_f32 rgb_from_lch(vec3_f32 lch); +vec3_f32 lch_from_rgb(vec3_f32 rgb); + +// NOTE: General rule to work with gamma is removing it, +// then doing computations like blending, interpolation, etc, +// then adding it back. + +vec3_f32 rgb_gamma_add (vec3_f32 rgb); +vec3_f32 rgb_gamma_remove (vec3_f32 rgb); +vec4_f32 rgba_gamma_add (vec4_f32 rgb); +vec4_f32 rgba_gamma_remove(vec4_f32 rgb); + +vec3_f32 rgb_gamma_lerp (vec3_f32 a, vec3_f32 b, f32 t); +vec4_f32 rgba_gamma_lerp(vec4_f32 a, vec4_f32 b, f32 t); +vec3_f32 rgb_mix (vec3_f32 a, vec3_f32 b, f32 t); +vec4_f32 rgba_mix (vec4_f32 a, vec4_f32 b, f32 t); +vec3_f32 lch_mix (vec3_f32 a, vec3_f32 b, f32 t); +vec3_f32 lch_lerp (vec3_f32 a, vec3_f32 b, f32 t); + +u32 rgb_u32_from_f32(vec3_f32 color); +vec3_f32 rgb_f32_from_u32(u32 color); +u32 rgba_u32_from_f32(vec4_f32 color); +vec4_f32 rgba_f32_from_u32(u32 color); + +b8 hit_rectangle(Box area, vec2 point); +b8 hit_triangle (vec2 vertices[3], vec2 point); +b8 hit_quad (vec2 vertices[4], vec2 point); +b8 hit_ellipse (Box area, vec2 point); +b8 hit_line (vec2 vertices[2], f64 width, vec2 point); + +void draw_pixels (Box area, Pixel_Buffer src); +void fill_rectangle (vec4_f32 color, Box area); +void fill_triangle (vec4_f32 color, vec2 vertices[3]); +void fill_quad (vec4_f32 color, vec2 vertices[4]); +void fill_ellipse (vec4_f32 color, Box area); +void fill_line (vec4_f32 color, vec2 vertices[2], f64 width); +void draw_text_area (vec4_f32 color, Box area, vec2 max_size, i64 num_chars, c32 *text); +void draw_text_cursor(vec4_f32 color, Box area, vec2 max_size, i64 num_chars, c32 *text, i64 cursor, i64 selection); + +void perform_graphics_request(Graphics_Context context, Graphics_Request req); #endif // GRAPHICS_HEADER_GUARD_ @@ -253,7 +258,7 @@ static f64 gamma_re_(f64 x) { return x / 12.92; } -static void put_pixel_alpha_(Pixel_Buffer dst, vec4_f32 color, i64 x, i64 y) { +static void put_pixel_(Pixel_Buffer dst, vec4_f32 color, i64 x, i64 y) { i64 n = y * dst.stride + x; if (color.w == 1.f) @@ -271,16 +276,16 @@ static void put_pixel_alpha_(Pixel_Buffer dst, vec4_f32 color, i64 x, i64 y) { } } -void draw_pixels_raw(Pixel_Buffer dst, f64 x0, f64 y0, f64 w, f64 h, Pixel_Buffer src) { - f64 x1 = x0 + w; - f64 y1 = y0 + h; +void draw_pixels_raw(Pixel_Buffer dst, Box area, Pixel_Buffer src) { + f64 x1 = area.x + area.width; + f64 y1 = area.y + area.height; - if (w < EPSILON || h < EPSILON) + if (area.width < EPSILON || area.height < EPSILON) return; - i64 i0 = (i64) floor(x0); + i64 i0 = (i64) floor(area.x); i64 i1 = (i64) floor(x1); - i64 j0 = (i64) floor(y0); + i64 j0 = (i64) floor(area.y); i64 j1 = (i64) floor(y1); if (i0 < 0) i0 = 0; @@ -288,19 +293,19 @@ void draw_pixels_raw(Pixel_Buffer dst, f64 x0, f64 y0, f64 w, f64 h, Pixel_Buffe if (j0 < 0) j0 = 0; if (j1 >= dst.height) j1 = dst.height - 1; - f64 w_inv = 1. / w; - f64 h_inv = 1. / h; + f64 w_inv = 1. / area.width; + f64 h_inv = 1. / area.height; for (i64 j = j0; j <= j1; ++j) { - i64 src_j0 = (i64) floor(((j - y0) * src.height) * h_inv + .5); - i64 src_j1 = (i64) floor(((j + 1 - y0) * src.height) * h_inv + .5); + i64 src_j0 = (i64) floor(((j - area.y) * src.height) * h_inv + .5); + i64 src_j1 = (i64) floor(((j + 1 - area.y) * src.height) * h_inv + .5); if (src_j0 == src_j1) src_j1 = src_j0 + 1; if (src_j1 <= 0 || src_j0 >= src.height) continue; if (src_j0 < 0) src_j0 = 0; if (src_j1 > src.height) src_j1 = src.height; for (i64 i = i0; i <= i1; ++i) { - i64 src_i0 = (i64) floor(((i - x0) * src.width) * w_inv + .5); - i64 src_i1 = (i64) floor(((i + 1 - x0) * src.width) * w_inv + .5); + i64 src_i0 = (i64) floor(((i - area.x) * src.width) * w_inv + .5); + i64 src_i1 = (i64) floor(((i + 1 - area.x) * src.width) * w_inv + .5); if (src_i0 == src_i1) src_i1 = src_i0 + 1; if (src_i1 <= 0 || src_i0 >= src.width) continue; if (src_i0 < 0) src_i0 = 0; @@ -322,18 +327,18 @@ void draw_pixels_raw(Pixel_Buffer dst, f64 x0, f64 y0, f64 w, f64 h, Pixel_Buffe color.y = gamma_(color.y * n_inv); color.z = gamma_(color.z * n_inv); color.w = gamma_(color.w * n_inv); - put_pixel_alpha_(dst, color, i, j); + put_pixel_(dst, color, i, j); } } } -void fill_rectangle_raw(Pixel_Buffer dst, vec4_f32 color, f64 x0, f64 y0, f64 w, f64 h) { - f64 x1 = x0 + w; - f64 y1 = y0 + h; +void fill_rectangle_raw(Pixel_Buffer dst, vec4_f32 color, Box area) { + f64 x1 = area.x + area.width; + f64 y1 = area.y + area.height; - i64 i0 = (i64) ceil (x0); + i64 i0 = (i64) ceil (area.x); i64 i1 = (i64) floor(x1); - i64 j0 = (i64) ceil (y0); + i64 j0 = (i64) ceil (area.y); i64 j1 = (i64) floor(y1); i64 i00 = i0; @@ -346,14 +351,14 @@ void fill_rectangle_raw(Pixel_Buffer dst, vec4_f32 color, f64 x0, f64 y0, f64 w, if (j0 < 0) j0 = 0; if (j1 > dst.height) j1 = dst.height; - f64 kx0 = i00 - x0; + f64 kx0 = i00 - area.x; f64 kx1 = x1 - i10; - f64 ky0 = j00 - y0; + f64 ky0 = j00 - area.y; f64 ky1 = y1 - j10; for (i64 j = j0; j < j1; ++j) for (i64 i = i0; i < i1; ++i) - put_pixel_alpha_(dst, color, i, j); + put_pixel_(dst, color, i, j); if (i00 > i10) { kx0 *= kx1; @@ -370,53 +375,60 @@ void fill_rectangle_raw(Pixel_Buffer dst, vec4_f32 color, f64 x0, f64 y0, f64 w, if (i00 - 1 >= 0 && i00 - 1 < dst.width) { color.w = gamma_(gamma_re_(alpha) * kx0); for (i64 j = j0; j < j1; ++j) - put_pixel_alpha_(dst, color, i00 - 1, j); + put_pixel_(dst, color, i00 - 1, j); } if (i10 >= 0 && i10 < dst.width) { color.w = gamma_(gamma_re_(alpha) * kx1); for (i64 j = j0; j < j1; ++j) - put_pixel_alpha_(dst, color, i10, j); + put_pixel_(dst, color, i10, j); } if (j00 - 1 >= 0 && j00 - 1 < dst.height) { color.w = gamma_(gamma_re_(alpha) * ky0); for (i64 i = i0; i < i1; ++i) - put_pixel_alpha_(dst, color, i, j00 - 1); + put_pixel_(dst, color, i, j00 - 1); } if (j10 >= 0 && j10 < dst.height) { color.w = gamma_(gamma_re_(alpha) * ky1); for (i64 i = i0; i < i1; ++i) - put_pixel_alpha_(dst, color, i, j10); + put_pixel_(dst, color, i, j10); } if ( i00 - 1 >= 0 && i00 - 1 < dst.width && j00 - 1 >= 0 && j00 - 1 < dst.height) { color.w = gamma_(gamma_re_(alpha) * kx0 * ky0); - put_pixel_alpha_(dst, color, i00 - 1, j00 - 1); + put_pixel_(dst, color, i00 - 1, j00 - 1); } if ( i10 >= 0 && i10 < dst.width && j00 - 1 >= 0 && j00 - 1 < dst.height) { color.w = gamma_(gamma_re_(alpha) * kx1 * ky0); - put_pixel_alpha_(dst, color, i10, j00 - 1); + put_pixel_(dst, color, i10, j00 - 1); } if ( i00 - 1 >= 0 && i00 - 1 < dst.width && j10 >= 0 && j10 < dst.height) { color.w = gamma_(gamma_re_(alpha) * kx0 * ky1); - put_pixel_alpha_(dst, color, i00 - 1, j10); + put_pixel_(dst, color, i00 - 1, j10); } if ( i10 >= 0 && i10 < dst.width && j10 >= 0 && j10 < dst.height) { color.w = gamma_(gamma_re_(alpha) * kx1 * ky1); - put_pixel_alpha_(dst, color, i10, j10); + put_pixel_(dst, color, i10, j10); } } -void fill_triangle_raw(Pixel_Buffer dst, vec4_f32 color, f64 x0, f64 y0, f64 x1, f64 y1, f64 x2, f64 y2) { +void fill_triangle_raw(Pixel_Buffer dst, vec4_f32 color, vec2 vertices[3]) { + f64 x0 = vertices[0].x; + f64 y0 = vertices[0].y; + f64 x1 = vertices[1].x; + f64 y1 = vertices[1].y; + f64 x2 = vertices[2].x; + f64 y2 = vertices[2].y; + i64 i0 = (i64) floor(min3_(x0, x1, x2)); i64 j0 = (i64) floor(min3_(y0, y1, y2)); i64 i1 = (i64) ceil (max3_(x0, x1, x2)); @@ -434,23 +446,33 @@ void fill_triangle_raw(Pixel_Buffer dst, vec4_f32 color, f64 x0, f64 y0, f64 x1, i64 right = i0; for (i64 i = i0; i <= i1; ++i) - if (hit_triangle(x0, y0, x1, y1, x2, y2, (f64) i, (f64) j)) { + if (hit_triangle(vertices, (vec2) { (f64) i, (f64) j, })) { left = i; break; } for (i64 i = i1; i >= i0; --i) - if (hit_triangle(x0, y0, x1, y1, x2, y2, (f64) i, (f64) j)) { + if (hit_triangle(vertices, (vec2) { (f64) i, (f64) j, })) { right = i; break; } for (i64 i = left; i <= right; ++i) - put_pixel_alpha_(dst, color, i, j); + put_pixel_(dst, color, i, j); } } -void fill_quad_raw(Pixel_Buffer dst, vec4_f32 color, f64 x0, f64 y0, f64 x1, f64 y1, f64 x2, f64 y2, f64 x3, f64 y3) { +void fill_quad_raw(Pixel_Buffer dst, vec4_f32 color, vec2 vertices[4]) { + f64 x0 = vertices[0].x; + f64 y0 = vertices[0].y; + f64 x1 = vertices[1].x; + f64 y1 = vertices[1].y; + f64 x2 = vertices[2].x; + f64 y2 = vertices[2].y; + f64 x3 = vertices[3].x; + f64 y3 = vertices[3].y; + + i64 i0 = (i64) floor(min3_(x0, x1, x2)); i64 j0 = (i64) floor(min3_(y0, y1, y2)); i64 i1 = (i64) ceil (max3_(x0, x1, x2)); @@ -468,40 +490,40 @@ void fill_quad_raw(Pixel_Buffer dst, vec4_f32 color, f64 x0, f64 y0, f64 x1, f64 i64 right = i0; for (i64 i = i0; i <= i1; ++i) - if (hit_quad(x0, y0, x1, y1, x2, y2, x3, y3, (f64) i, (f64) j)) { + if (hit_quad(vertices, (vec2) { (f64) i, (f64) j, })) { left = i; break; } for (i64 i = i1; i >= i0; --i) - if (hit_quad(x0, y0, x1, y1, x2, y2, x3, y3, (f64) i, (f64) j)) { + if (hit_quad(vertices, (vec2) { (f64) i, (f64) j, })) { right = i; break; } for (i64 i = left; i <= right; ++i) - put_pixel_alpha_(dst, color, i, j); + put_pixel_(dst, color, i, j); } } -void fill_ellipse_raw(Pixel_Buffer dst, vec4_f32 color, f64 x0, f64 y0, f64 w, f64 h) { - f64 y1 = y0 + h; +void fill_ellipse_raw(Pixel_Buffer dst, vec4_f32 color, Box area) { + f64 y1 = area.y + area.height; - i64 j0 = (i64) floor(y0); + i64 j0 = (i64) floor(area.y); i64 j1 = (i64) ceil (y1); if (j0 < 0) j0 = 0; if (j1 >= dst.height) j1 = dst.height - 1; - f64 half_w = w / 2.0; - f64 half_h = h / 2.0; + f64 half_w = area.width / 2.0; + f64 half_h = area.height / 2.0; if (half_h < EPSILON) return; f64 inv_half_h = 1.0 / half_h; - f64 cx = x0 + half_w; - f64 cy = y0 + half_h; + f64 cx = area.x + half_w; + f64 cy = area.y + half_h; for (i64 j = j0; j <= j1; ++j) { f64 ry = (j - cy) * inv_half_h; @@ -517,14 +539,19 @@ void fill_ellipse_raw(Pixel_Buffer dst, vec4_f32 color, f64 x0, f64 y0, f64 w, f if (right >= dst.width) right = dst.width - 1; for (i64 i = left; i <= right; ++i) - put_pixel_alpha_(dst, color, i, j); + put_pixel_(dst, color, i, j); } } -void fill_line_raw(Pixel_Buffer dst, vec4_f32 color, f64 x0, f64 y0, f64 x1, f64 y1, f64 width) { +void fill_line_raw(Pixel_Buffer dst, vec4_f32 color, vec2 vertices[2], f64 width) { if (width < EPSILON) return; + f64 x0 = vertices[0].x; + f64 y0 = vertices[0].y; + f64 x1 = vertices[1].x; + f64 y1 = vertices[1].y; + f64 dx = x1 - x0; f64 dy = y1 - y0; @@ -541,7 +568,12 @@ void fill_line_raw(Pixel_Buffer dst, vec4_f32 color, f64 x0, f64 y0, f64 x1, f64 tx *= width * k; ty *= width * k; - fill_quad_raw(dst, color, x0 - tx, y0 - ty, x0 + tx, y0 + ty, x1 + tx, y1 + ty, x1 - tx, y1 - ty); + fill_quad_raw(dst, color, (vec2[4]) { + { x0 - tx, y0 - ty }, + { x0 + tx, y0 + ty }, + { x1 + tx, y1 + ty }, + { x1 - tx, y1 - ty }, + }); } static i64 char_column_offset_(c32 c, i64 column_index) { @@ -743,7 +775,7 @@ static void draw_text_(Pixel_Buffer dst, vec4_f32 color, f64 x0, f64 y0, f64 sca for (i64 j = j0; j <= j1; ++j) { i64 row = (i64) floor(((j - y) * CHAR_NUM_BITS_Y_) * h_inv + .5); if (char_bit_(offset, row)) - put_pixel_alpha_(dst, color, i, j); + put_pixel_(dst, color, i, j); } } } @@ -752,29 +784,29 @@ static void draw_text_(Pixel_Buffer dst, vec4_f32 color, f64 x0, f64 y0, f64 sca } } -void draw_text_area_raw(Pixel_Buffer dst, vec4_f32 color, f64 x, f64 y, f64 width, f64 height, f64 max_width, f64 max_height, i64 num_chars, c32 *text) { - if (text == NULL || num_chars <= 0 || max_width < EPSILON || max_height < EPSILON) +void draw_text_area_raw(Pixel_Buffer dst, vec4_f32 color, Box area, vec2 max_size, i64 num_chars, c32 *text) { + if (text == NULL || num_chars <= 0 || max_size.x < EPSILON || max_size.y < EPSILON) return; i64 num_columns = enum_text_columns_(num_chars, text); i64 num_rows = enum_text_rows_(num_chars, text); - f64 scale_x = width / num_columns; - f64 scale_y = height / num_rows; + f64 scale_x = area.width / num_columns; + f64 scale_y = area.height / num_rows; - f64 kx = scale_x / max_width; - f64 ky = scale_y / max_height; + f64 kx = scale_x / max_size.x; + f64 ky = scale_y / max_size.y; f64 k = kx < ky ? kx : ky; - kx = k * max_width; - ky = k * max_height; + kx = k * max_size.x; + ky = k * max_size.y; - draw_text_(dst, color, x, y, kx, ky, num_chars, text); + draw_text_(dst, color, area.x, area.y, kx, ky, num_chars, text); } -void draw_text_cursor_raw(Pixel_Buffer dst, vec4_f32 color, f64 x, f64 y, f64 width, f64 height, f64 max_width, f64 max_height, i64 cursor, i64 selection, i64 num_chars, c32 *text) { - if (max_width < EPSILON || max_height < EPSILON) +void draw_text_cursor_raw(Pixel_Buffer dst, vec4_f32 color, Box area, vec2 max_size, i64 num_chars, c32 *text, i64 cursor, i64 selection) { + if (max_size.x< EPSILON || max_size.y < EPSILON) return; i64 num_columns = enum_text_columns_(num_chars, text); @@ -782,16 +814,16 @@ void draw_text_cursor_raw(Pixel_Buffer dst, vec4_f32 color, f64 x, f64 y, f64 wi i64 cursor_x = text_cursor_(cursor, text); i64 cursor_y = enum_text_rows_(cursor, text); - f64 scale_x = width / num_columns; - f64 scale_y = height / num_rows; + f64 scale_x = area.width / num_columns; + f64 scale_y = area.height / num_rows; - f64 kx = scale_x / max_width; - f64 ky = scale_y / max_height; + f64 kx = scale_x / max_size.x; + f64 ky = scale_y / max_size.y; f64 k = kx < ky ? kx : ky; - kx = k * max_width; - ky = k * max_height; + kx = k * max_size.x; + ky = k * max_size.y; if (selection != 0) { i64 selection_x, selection_y; @@ -810,46 +842,56 @@ void draw_text_cursor_raw(Pixel_Buffer dst, vec4_f32 color, f64 x, f64 y, f64 wi fill_rectangle_raw( dst, color, - x + kx * cursor_x, - y + ky * cursor_y - ky * (CHAR_NUM_BITS_Y_ + 1), - kx * (selection_x - cursor_x), - ky * (CHAR_NUM_BITS_Y_ + 1) + (Box) { + .x = area.x + kx * cursor_x, + .y = area.y + ky * cursor_y - ky * (CHAR_NUM_BITS_Y_ + 1), + .width = kx * (selection_x - cursor_x), + .height = ky * (CHAR_NUM_BITS_Y_ + 1), + } ); else { fill_rectangle_raw( dst, color, - x + kx * cursor_x, - y + ky * cursor_y - ky * (CHAR_NUM_BITS_Y_ + 1), - kx * (num_columns - cursor_x), - ky * (CHAR_NUM_BITS_Y_ + 1) + (Box) { + .x = area.x + kx * cursor_x, + .y = area.y + ky * cursor_y - ky * (CHAR_NUM_BITS_Y_ + 1), + .width = kx * (num_columns - cursor_x), + .height = ky * (CHAR_NUM_BITS_Y_ + 1), + } ); for (i64 j = cursor_y + CHAR_NUM_BITS_Y_ + 1; j < selection_y; j += CHAR_NUM_BITS_Y_ + 1) fill_rectangle_raw( dst, color, - x, - y + ky * j - ky * (CHAR_NUM_BITS_Y_ + 1), - kx * num_columns, - ky * (CHAR_NUM_BITS_Y_ + 1) + (Box) { + .x = area.x, + .y = area.y + ky * j - ky * (CHAR_NUM_BITS_Y_ + 1), + .width = kx * num_columns, + .height = ky * (CHAR_NUM_BITS_Y_ + 1), + } ); fill_rectangle_raw( dst, color, - x, - y + ky * selection_y - ky * (CHAR_NUM_BITS_Y_ + 1), - kx * selection_x, - ky * (CHAR_NUM_BITS_Y_ + 1) + (Box) { + .x = area.x, + .y = area.y + ky * selection_y - ky * (CHAR_NUM_BITS_Y_ + 1), + .width = kx * selection_x, + .height = ky * (CHAR_NUM_BITS_Y_ + 1), + } ); } } else fill_rectangle_raw( dst, color, - x + kx * cursor_x, - y + ky * cursor_y - ky * CHAR_NUM_BITS_Y_, - kx * .5, - ky * (CHAR_NUM_BITS_Y_ - 1) + (Box) { + .x = area.x + kx * cursor_x, + .y = area.y + ky * cursor_y - ky * CHAR_NUM_BITS_Y_, + .width = kx * .5, + .height = ky * (CHAR_NUM_BITS_Y_ - 1), + } ); } @@ -1086,14 +1128,23 @@ vec4_f32 rgba_f32_from_u32(u32 color) { }; } -b8 hit_rectangle(f64 x0, f64 y0, f64 width, f64 height, f64 px, f64 py) { - return px >= x0 && px < x0 + width && py >= y0 && py < y0 + height; +b8 hit_rectangle(Box area, vec2 point) { + return point.x >= area.x && point.x < area.x + area.width && point.y >= area.y && point.y < area.y + area.height; } -b8 hit_triangle(f64 x0, f64 y0, f64 x1, f64 y1, f64 x2, f64 y2, f64 px, f64 py) { +b8 hit_triangle(vec2 vertices[3], vec2 point) { // Z-components of cross-products // + f64 x0 = vertices[0].x; + f64 y0 = vertices[0].y; + f64 x1 = vertices[1].x; + f64 y1 = vertices[1].y; + f64 x2 = vertices[2].x; + f64 y2 = vertices[2].y; + f64 px = point.x; + f64 py = point.y; + f64 x10 = x1 - x0; f64 x21 = x2 - x1; f64 x02 = x0 - x2; @@ -1115,30 +1166,44 @@ b8 hit_triangle(f64 x0, f64 y0, f64 x1, f64 y1, f64 x2, f64 y2, f64 px, f64 py) && same_sign_(z2, pz2); } -b8 hit_quad(f64 x0, f64 y0, f64 x1, f64 y1, f64 x2, f64 y2, f64 x3, f64 y3, f64 px, f64 py) { - return hit_triangle(x0, y0, x1, y1, x2, y2, px, py) - || hit_triangle(x0, y0, x2, y2, x3, y3, px, py); +b8 hit_quad(vec2 vertices[4], vec2 point) { + f64 x0 = vertices[0].x; + f64 y0 = vertices[0].y; + f64 x1 = vertices[1].x; + f64 y1 = vertices[1].y; + f64 x2 = vertices[2].x; + f64 y2 = vertices[2].y; + f64 x3 = vertices[3].x; + f64 y3 = vertices[3].y; + + return hit_triangle((vec2[3]) { { x0, y0 }, { x1, y1 }, { x2, y2 }, }, point) + || hit_triangle((vec2[3]) { { x0, y0 }, { x2, y2 }, { x3, y3 }, }, point); } -b8 hit_ellipse(f64 x0, f64 y0, f64 width, f64 height, f64 px, f64 py) { - f64 dw = width / 2; - f64 dh = height / 2; +b8 hit_ellipse(Box area, vec2 point) { + f64 dw = area.width / 2; + f64 dh = area.height / 2; if (dw < EPSILON || dh < EPSILON) return 0; - f64 cx = x0 + dw; - f64 cy = y0 + dh; + f64 cx = area.x + dw; + f64 cy = area.y + dh; f64 kx = 1. / dw; f64 ky = 1. / dh; - f64 dx = (px - cx) * kx; - f64 dy = (py - cy) * ky; + f64 dx = (point.x - cx) * kx; + f64 dy = (point.y - cy) * ky; return dx * dx + dy * dy - 1.0 < EPSILON; } -b8 hit_line(f64 x0, f64 y0, f64 x1, f64 y1, f64 width, f64 px, f64 py) { +b8 hit_line(vec2 vertices[2], f64 width, vec2 point) { + f64 x0 = vertices[0].x; + f64 y0 = vertices[0].y; + f64 x1 = vertices[1].x; + f64 y1 = vertices[1].y; + f64 dx = x1 - x0; f64 dy = y1 - y0; @@ -1154,7 +1219,134 @@ b8 hit_line(f64 x0, f64 y0, f64 x1, f64 y1, f64 width, f64 px, f64 py) { tx *= width * .5; ty *= width * .5; - return hit_quad(x0 - tx, y0 - ty, x0 + tx, y0 + ty, x1 + tx, y1 + ty, x1 - tx, y1 - ty, px, py); + return hit_quad((vec2[4]) { + { x0 - tx, y0 - ty }, + { x0 + tx, y0 + ty }, + { x1 + tx, y1 + ty }, + { x1 - tx, y1 - ty }, + }, point); +} + +void draw_pixels(Box area, Pixel_Buffer src) { + perform_graphics_request( + (Graphics_Context) {0}, + (Graphics_Request) { + .op = GRAPHICS_OP_PIXELS, + .pixels = { + .area = area, + .src = src, + }, + } + ); +} + +void fill_rectangle(vec4_f32 color, Box area) { + perform_graphics_request( + (Graphics_Context) {0}, + (Graphics_Request) { + .op = GRAPHICS_OP_RECTANGLE, + .rectangle = { + .color = color, + .area = area, + }, + } + ); +} + +void fill_triangle(vec4_f32 color, vec2 vertices[3]) { + perform_graphics_request( + (Graphics_Context) {0}, + (Graphics_Request) { + .op = GRAPHICS_OP_TRIANGLE, + .triangle = { + .color = color, + .vertices = { + vertices[0], + vertices[1], + vertices[2], + }, + }, + } + ); +} + +void fill_quad(vec4_f32 color, vec2 vertices[4]) { + perform_graphics_request( + (Graphics_Context) {0}, + (Graphics_Request) { + .op = GRAPHICS_OP_QUAD, + .quad = { + .color = color, + .vertices = { + vertices[0], + vertices[1], + vertices[2], + vertices[3], + }, + }, + } + ); +} + +void fill_ellipse(vec4_f32 color, Box area) { + perform_graphics_request( + (Graphics_Context) {0}, + (Graphics_Request) { + .op = GRAPHICS_OP_ELLIPSE, + .ellipse = { + .color = color, + .area = area, + }, + } + ); +} + +void fill_line(vec4_f32 color, vec2 vertices[2], f64 width) { + perform_graphics_request( + (Graphics_Context) {0}, + (Graphics_Request) { + .op = GRAPHICS_OP_LINE, + .line = { + .color = color, + .vertices = { vertices[0], vertices[1], }, + .width = width, + }, + } + ); +} + +void draw_text_area(vec4_f32 color, Box area, vec2 max_size, i64 num_chars, c32 *text) { + perform_graphics_request( + (Graphics_Context) {0}, + (Graphics_Request) { + .op = GRAPHICS_OP_TEXT_AREA, + .text_area = { + .color = color, + .area = area, + .max_size = max_size, + .num_chars = num_chars, + .text = text, + }, + } + ); +} + +void draw_text_cursor(vec4_f32 color, Box area, vec2 max_size, i64 num_chars, c32 *text, i64 cursor, i64 selection) { + perform_graphics_request( + (Graphics_Context) {0}, + (Graphics_Request) { + .op = GRAPHICS_OP_TEXT_CURSOR, + .text_cursor = { + .color = color, + .area = area, + .max_size = max_size, + .num_chars = num_chars, + .text = text, + .cursor = cursor, + .selection = selection, + }, + } + ); } // ================================================================ @@ -1169,10 +1361,7 @@ void perform_raw_graphics_request_(Graphics_Context context, Graphics_Request re case GRAPHICS_OP_PIXELS: draw_pixels_raw( context.dst, - req.pixels.area.x, - req.pixels.area.y, - req.pixels.area.width, - req.pixels.area.height, + req.pixels.area, req.pixels.src ); break; @@ -1181,10 +1370,7 @@ void perform_raw_graphics_request_(Graphics_Context context, Graphics_Request re fill_rectangle_raw( context.dst, req.rectangle.color, - req.rectangle.area.x, - req.rectangle.area.y, - req.rectangle.area.width, - req.rectangle.area.height + req.rectangle.area ); break; @@ -1192,12 +1378,7 @@ void perform_raw_graphics_request_(Graphics_Context context, Graphics_Request re fill_triangle_raw( context.dst, req.triangle.color, - req.triangle.vertices[0].x, - req.triangle.vertices[0].y, - req.triangle.vertices[1].x, - req.triangle.vertices[1].y, - req.triangle.vertices[2].x, - req.triangle.vertices[2].y + req.triangle.vertices ); break; @@ -1205,14 +1386,7 @@ void perform_raw_graphics_request_(Graphics_Context context, Graphics_Request re fill_quad_raw( context.dst, req.quad.color, - req.quad.vertices[0].x, - req.quad.vertices[0].y, - req.quad.vertices[1].x, - req.quad.vertices[1].y, - req.quad.vertices[2].x, - req.quad.vertices[2].y, - req.quad.vertices[3].x, - req.quad.vertices[3].y + req.quad.vertices ); break; @@ -1220,10 +1394,7 @@ void perform_raw_graphics_request_(Graphics_Context context, Graphics_Request re fill_ellipse_raw( context.dst, req.ellipse.color, - req.ellipse.area.x, - req.ellipse.area.y, - req.ellipse.area.width, - req.ellipse.area.height + req.ellipse.area ); break; @@ -1231,10 +1402,7 @@ void perform_raw_graphics_request_(Graphics_Context context, Graphics_Request re fill_line_raw( context.dst, req.line.color, - req.line.vertices[0].x, - req.line.vertices[0].y, - req.line.vertices[1].x, - req.line.vertices[1].y, + req.line.vertices, req.line.width ); break; @@ -1243,12 +1411,8 @@ void perform_raw_graphics_request_(Graphics_Context context, Graphics_Request re draw_text_area_raw( context.dst, req.text_area.color, - req.text_area.area.x, - req.text_area.area.y, - req.text_area.area.width, - req.text_area.area.height, - req.text_area.max_size.x, - req.text_area.max_size.y, + req.text_area.area, + req.text_area.max_size, req.text_area.num_chars, req.text_area.text ); @@ -1258,16 +1422,12 @@ void perform_raw_graphics_request_(Graphics_Context context, Graphics_Request re draw_text_cursor_raw( context.dst, req.text_cursor.color, - req.text_cursor.area.x, - req.text_cursor.area.y, - req.text_cursor.area.width, - req.text_cursor.area.height, - req.text_cursor.max_size.x, - req.text_cursor.max_size.y, - req.text_cursor.cursor, - req.text_cursor.selection, + req.text_cursor.area, + req.text_cursor.max_size, req.text_cursor.num_chars, - req.text_cursor.text + req.text_cursor.text, + req.text_cursor.cursor, + req.text_cursor.selection ); break; @@ -1379,11 +1539,6 @@ void scale_and_perform_graphics_request_(Graphics_Context context, Graphics_Requ // ================================================================ void perform_graphics_request(Graphics_Context context, Graphics_Request req) { - if (context.sketch == NULL) { - context.sketch_size = MAX_NUM_PIXELS; - context.sketch = g_platform.sketch; - } - if (context.dst.pixels == NULL) { context.dst.width = g_platform.frame_width; context.dst.height = g_platform.frame_height; @@ -1495,56 +1650,68 @@ Pixel_Buffer pixels = { .width = 1280, .height = 720, .stride = 1280, - .pixels = g_platform.sketch, + .pixels = (vec4_f32[1280 * 720]) {0}, }; vec4_f32 color = { 1., 1., 1., 1., }; -BENCHMARK("fill rectangle") { +BENCHMARK("fill rectangle raw") { BENCHMARK_BEGIN; { - fill_rectangle_raw(pixels, color, 100, 100, 300, 200); + fill_rectangle_raw(pixels, color, (Box) { .x = 100, .y = 100, .width = 300, .height = 200, }); } BENCHMARK_END; } -BENCHMARK("fill triangle") { +BENCHMARK("fill triangle raw") { BENCHMARK_BEGIN; { - fill_triangle_raw(pixels, color, 100, 100, 300, 100, 200, 250); + fill_triangle_raw(pixels, color, (vec2[3]) { + { 100, 100 }, + { 300, 100 }, + { 200, 250 }, + }); } BENCHMARK_END; } -BENCHMARK("fill quad") { +BENCHMARK("fill quad raw") { BENCHMARK_BEGIN; { - fill_quad_raw(pixels, color, 100, 100, 300, 100, 300, 200, 100, 200); + fill_quad_raw(pixels, color, (vec2[4]) { + { 100, 100 }, + { 300, 100 }, + { 300, 200 }, + { 100, 200 }, + }); } BENCHMARK_END; } -BENCHMARK("fill ellipse") { +BENCHMARK("fill ellipse raw") { BENCHMARK_BEGIN; { - fill_ellipse_raw(pixels, color, 80, 80, 340, 240); + fill_ellipse_raw(pixels, color, (Box) { .x = 80, .y = 80, .width = 340, .height = 240, }); } BENCHMARK_END; } -BENCHMARK("fill line") { +BENCHMARK("fill line raw") { BENCHMARK_BEGIN; { - fill_line_raw(pixels, color, 100, 100, 300, 200, 40); + fill_line_raw(pixels, color, (vec2[2]) { + { 100, 100 }, + { 300, 200 }, + }, 40); } BENCHMARK_END; } -BENCHMARK("draw text area") { +BENCHMARK("draw text area raw") { BENCHMARK_BEGIN; { c32 text[] = { 'H', 'e', 'l', 'l', 'o', ',', ' ', 'S', 'a', 'i', 'l', 'o', 'r', '!', }; - draw_text_area_raw(pixels, color, 100, 100, 300, 200, 100, 200, sizeof text / sizeof *text, text); + draw_text_area_raw(pixels, color, (Box) { .x = 100, .y = 100, .width = 300, .height = 200, }, (vec2) { 100, 200 }, sizeof text / sizeof *text, text); } BENCHMARK_END; } diff --git a/reduced_system_layer.c b/reduced_system_layer.c index 50f676f..461155e 100755 --- a/reduced_system_layer.c +++ b/reduced_system_layer.c @@ -631,7 +631,7 @@ typedef struct { i64 input_capacity; vec4_f32 *pixels; - vec4_f32 *sketch; + f32 *sketch; Input_Key *input; Drop_File *drop_files; c8 *clipboard_text; @@ -667,7 +667,7 @@ void run_main_window_event_loop(void); // Clipboard void write_clipboard_text(i64 size, c8 *data); -void write_clipboard_image(i64 width, i64 heiht, vec4_f32 *pixels); +void write_clipboard_image(i64 width, i64 height, vec4_f32 *pixels); void write_clipboard_sound(i8 num_channels, i64 num_samples, f32 *frames); // Take a screenshot @@ -687,6 +687,8 @@ void shutdown_all_systems(void); // Memory void *memory_buffer_allocate(i64 size, i64 alignment, i64 previous_size, void *previous_data); +void resize_dynamic_array_exact(i64 *num, void **data, i64 element_size, i64 new_num); +void resize_dynamic_array_capacity(i64 *num, i64 *capacity, void **data, i64 element_size, i64 new_num); #ifdef REDUCED_SYSTEM_LAYER_HEADER extern Platform g_platform; @@ -886,7 +888,7 @@ void *memory_buffer_allocate(i64 size, i64 alignment, i64 previous_size, void *p return dst; } -void wrap_dynamic_array_exact(i64 *num, void **data, i64 element_size, i64 new_num) { +void resize_dynamic_array_exact(i64 *num, void **data, i64 element_size, i64 new_num) { if (num == NULL || data == NULL) { LOG_ERROR("Sanity"); return; @@ -906,14 +908,14 @@ void wrap_dynamic_array_exact(i64 *num, void **data, i64 element_size, i64 new_n *data = new_data; } -void wrap_dynamic_array_capacity(i64 *num, i64 *capacity, void **data, i64 element_size, i64 new_num) { +void resize_dynamic_array_capacity(i64 *num, i64 *capacity, void **data, i64 element_size, i64 new_num) { if (num == NULL || capacity == NULL || data == NULL) { LOG_ERROR("Sanity"); return; } if (new_num > *capacity) - wrap_dynamic_array_exact(capacity, data, element_size, new_num); + resize_dynamic_array_exact(capacity, data, element_size, new_num); *num = new_num; } @@ -1505,12 +1507,12 @@ static void drop_files_clean_(void) { g_platform.files_dropped = 0; for (i64 i = 0; i < g_platform.num_drop_files; ++i) { - wrap_dynamic_array_exact(&g_platform.drop_files[i].name_len, (void **) &g_platform.drop_files[i].name, 1, 0); - wrap_dynamic_array_exact(&g_platform.drop_files[i].data_size, (void **) &g_platform.drop_files[i].data, 1, 0); + resize_dynamic_array_exact(&g_platform.drop_files[i].name_len, (void **) &g_platform.drop_files[i].name, 1, 0); + resize_dynamic_array_exact(&g_platform.drop_files[i].data_size, (void **) &g_platform.drop_files[i].data, 1, 0); } - wrap_dynamic_array_exact(&g_platform.num_drop_files, (void **) &g_platform.drop_files, sizeof *g_platform.drop_files, 0); - wrap_dynamic_array_exact(&_drop_files_buffer_len, (void **) &_drop_files_buffer, 1, 0); + resize_dynamic_array_exact(&g_platform.num_drop_files, (void **) &g_platform.drop_files, sizeof *g_platform.drop_files, 0); + resize_dynamic_array_exact(&_drop_files_buffer_len, (void **) &_drop_files_buffer, 1, 0); } static i64 align_size_(i64 x) { @@ -1525,7 +1527,7 @@ static void drop_files_set_num_(i64 num) { i64 prev_num = g_platform.num_drop_files; - wrap_dynamic_array_exact(&g_platform.num_drop_files, (void **) &g_platform.drop_files, sizeof *g_platform.drop_files, num); + resize_dynamic_array_exact(&g_platform.num_drop_files, (void **) &g_platform.drop_files, sizeof *g_platform.drop_files, num); mem_set_(g_platform.drop_files + prev_num, 0, sizeof *g_platform.drop_files * (g_platform.num_drop_files - prev_num)); } @@ -1543,7 +1545,7 @@ static void drop_files_set_name_(i64 index, i64 name_len, c8 *name) { Drop_File *f = g_platform.drop_files + index; - wrap_dynamic_array_exact(&f->name_len, (void **) &f->name, 1, name_len); + resize_dynamic_array_exact(&f->name_len, (void **) &f->name, 1, name_len); mem_cpy_(f->name, name, f->name_len); } @@ -1560,7 +1562,7 @@ static void drop_files_set_data_(i64 index, i64 data_size) { Drop_File *f = g_platform.drop_files + index; - wrap_dynamic_array_exact(&f->data_size, (void **) &f->data, 1, data_size); + resize_dynamic_array_exact(&f->data_size, (void **) &f->data, 1, data_size); } static i8 pixel_size_update_(i32 real_width, i32 real_height) { @@ -1681,7 +1683,7 @@ static void network_init_(u16 slot) { i64 prev_num = _num_sockets; if (num > prev_num) { - wrap_dynamic_array_exact(&_num_sockets, (void **) &_sockets, sizeof *_sockets, num); + resize_dynamic_array_exact(&_num_sockets, (void **) &_sockets, sizeof *_sockets, num); mem_set_(_sockets + prev_num, 0, num - prev_num); } } @@ -2932,7 +2934,7 @@ i32 handle_main_window_events(void) { memset(g_platform.key_pressed, 0, sizeof g_platform.key_pressed); memset(_key_repeat, 0, sizeof _key_repeat); - wrap_dynamic_array_capacity(&g_platform.input_len, &g_platform.input_capacity, (void **) &g_platform.input, sizeof *g_platform.input, 0); + resize_dynamic_array_capacity(&g_platform.input_len, &g_platform.input_capacity, (void **) &g_platform.input, sizeof *g_platform.input, 0); g_platform.cursor_dx = 0; g_platform.cursor_dy = 0; @@ -3016,7 +3018,7 @@ i32 handle_main_window_events(void) { g_platform.key_down[MOD_META] = !!(ev.xkey.state & Mod4Mask); i64 n = g_platform.input_len; - wrap_dynamic_array_capacity(&g_platform.input_len, &g_platform.input_capacity, (void **) &g_platform.input, sizeof *g_platform.input, n + 1); + resize_dynamic_array_capacity(&g_platform.input_len, &g_platform.input_capacity, (void **) &g_platform.input, sizeof *g_platform.input, n + 1); if (n < g_platform.input_len) { if (k < 32 || k >= 128) @@ -3263,7 +3265,7 @@ i32 handle_main_window_events(void) { if (target_text == None && target_image == None && target_sound == None) _requested_clipboard = 0; } else if (ev.xselection.target == XA_STRING || ev.xselection.target == _text_plain || ev.xselection.target == _utf8_string) { - wrap_dynamic_array_exact(&g_platform.clipboard_text_len, (void **) &g_platform.clipboard_text, 1, len + 1); + resize_dynamic_array_exact(&g_platform.clipboard_text_len, (void **) &g_platform.clipboard_text, 1, len + 1); mem_cpy_(g_platform.clipboard_text, data, len); g_platform.clipboard_text[len] = '\0'; _requested_clipboard = 0; @@ -3467,9 +3469,9 @@ void render_main_window_frame(void) { i64 num_pixels = g_platform.frame_width * g_platform.frame_height; if (_pixels_scaled_len < num_pixels) - wrap_dynamic_array_exact(&_pixels_scaled_len, (void **) &_pixels_scaled, sizeof *_pixels_scaled, num_pixels); + resize_dynamic_array_exact(&_pixels_scaled_len, (void **) &_pixels_scaled, sizeof *_pixels_scaled, num_pixels); if (_pixels_internal_len < num_pixels) - wrap_dynamic_array_exact(&_pixels_internal_len, (void **) &_pixels_internal, sizeof *_pixels_internal, num_pixels); + resize_dynamic_array_exact(&_pixels_internal_len, (void **) &_pixels_internal, sizeof *_pixels_internal, num_pixels); if (g_platform.frame_width == _image.width && g_platform.frame_height == _image.height) { i64 size = g_platform.frame_width * g_platform.frame_height; @@ -3498,7 +3500,7 @@ void render_main_window_frame(void) { void write_clipboard_text(i64 size, c8 *data) { XSetSelectionOwner(_display, _clipboard, _window, CurrentTime); - wrap_dynamic_array_exact(&g_platform.clipboard_text_len, (void **) &g_platform.clipboard_text, 1, size + 1); + resize_dynamic_array_exact(&g_platform.clipboard_text_len, (void **) &g_platform.clipboard_text, 1, size + 1); i64 len = g_platform.clipboard_text_len - 1; if (len >= 0) { |