patrick
/
odin_chat_client
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

initial commit

main
Patrick Cleavelin 2024-05-23 14:34:15 -05:00
commit f47ad817f1
14 changed files with 2292 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
.gitignore vendored Normal file
View File

@ -0,0 +1,3 @@
.DS_Store
bin

180
flake.lock Normal file
View File

@ -0,0 +1,180 @@
{
"nodes": {
"flake-utils": {
"inputs": {
"systems": "systems"
},
"locked": {
"lastModified": 1710146030,
"narHash": "sha256-SZ5L6eA7HJ/nmkzGG7/ISclqe6oZdOZTNoesiInkXPQ=",
"owner": "numtide",
"repo": "flake-utils",
"rev": "b1d9ab70662946ef0850d488da1c9019f3a9752a",
"type": "github"
},
"original": {
"owner": "numtide",
"repo": "flake-utils",
"type": "github"
}
},
"flake-utils_2": {
"locked": {
"lastModified": 1659877975,
"narHash": "sha256-zllb8aq3YO3h8B/U0/J1WBgAL8EX5yWf5pMj3G0NAmc=",
"owner": "numtide",
"repo": "flake-utils",
"rev": "c0e246b9b83f637f4681389ecabcb2681b4f3af0",
"type": "github"
},
"original": {
"owner": "numtide",
"repo": "flake-utils",
"type": "github"
}
},
"flake-utils_3": {
"inputs": {
"systems": "systems_2"
},
"locked": {
"lastModified": 1705309234,
"narHash": "sha256-uNRRNRKmJyCRC/8y1RqBkqWBLM034y4qN7EprSdmgyA=",
"owner": "numtide",
"repo": "flake-utils",
"rev": "1ef2e671c3b0c19053962c07dbda38332dcebf26",
"type": "github"
},
"original": {
"owner": "numtide",
"repo": "flake-utils",
"type": "github"
}
},
"nixgl": {
"inputs": {
"flake-utils": "flake-utils_2",
"nixpkgs": "nixpkgs"
},
"locked": {
"lastModified": 1713543440,
"narHash": "sha256-lnzZQYG0+EXl/6NkGpyIz+FEOc/DSEG57AP1VsdeNrM=",
"owner": "guibou",
"repo": "nixGL",
"rev": "310f8e49a149e4c9ea52f1adf70cdc768ec53f8a",
"type": "github"
},
"original": {
"owner": "guibou",
"repo": "nixGL",
"type": "github"
}
},
"nixpkgs": {
"locked": {
"lastModified": 1660551188,
"narHash": "sha256-a1LARMMYQ8DPx1BgoI/UN4bXe12hhZkCNqdxNi6uS0g=",
"owner": "nixos",
"repo": "nixpkgs",
"rev": "441dc5d512153039f19ef198e662e4f3dbb9fd65",
"type": "github"
},
"original": {
"owner": "nixos",
"repo": "nixpkgs",
"type": "github"
}
},
"nixpkgs_2": {
"locked": {
"lastModified": 1715087517,
"narHash": "sha256-CLU5Tsg24Ke4+7sH8azHWXKd0CFd4mhLWfhYgUiDBpQ=",
"owner": "nixos",
"repo": "nixpkgs",
"rev": "b211b392b8486ee79df6cdfb1157ad2133427a29",
"type": "github"
},
"original": {
"owner": "nixos",
"ref": "nixos-unstable",
"repo": "nixpkgs",
"type": "github"
}
},
"nixpkgs_3": {
"locked": {
"lastModified": 1706487304,
"narHash": "sha256-LE8lVX28MV2jWJsidW13D2qrHU/RUUONendL2Q/WlJg=",
"owner": "NixOS",
"repo": "nixpkgs",
"rev": "90f456026d284c22b3e3497be980b2e47d0b28ac",
"type": "github"
},
"original": {
"owner": "NixOS",
"ref": "nixpkgs-unstable",
"repo": "nixpkgs",
"type": "github"
}
},
"root": {
"inputs": {
"flake-utils": "flake-utils",
"nixgl": "nixgl",
"nixpkgs": "nixpkgs_2",
"rust-overlay": "rust-overlay"
}
},
"rust-overlay": {
"inputs": {
"flake-utils": "flake-utils_3",
"nixpkgs": "nixpkgs_3"
},
"locked": {
"lastModified": 1715221036,
"narHash": "sha256-81EKOdlmT/4hZpImRlvMVPgmCcJYZjwlWbJese/XqUw=",
"owner": "oxalica",
"repo": "rust-overlay",
"rev": "5c4bc8a0a70093a31a12509c5653c147f2310bd2",
"type": "github"
},
"original": {
"owner": "oxalica",
"repo": "rust-overlay",
"type": "github"
}
},
"systems": {
"locked": {
"lastModified": 1681028828,
"narHash": "sha256-Vy1rq5AaRuLzOxct8nz4T6wlgyUR7zLU309k9mBC768=",
"owner": "nix-systems",
"repo": "default",
"rev": "da67096a3b9bf56a91d16901293e51ba5b49a27e",
"type": "github"
},
"original": {
"owner": "nix-systems",
"repo": "default",
"type": "github"
}
},
"systems_2": {
"locked": {
"lastModified": 1681028828,
"narHash": "sha256-Vy1rq5AaRuLzOxct8nz4T6wlgyUR7zLU309k9mBC768=",
"owner": "nix-systems",
"repo": "default",
"rev": "da67096a3b9bf56a91d16901293e51ba5b49a27e",
"type": "github"
},
"original": {
"owner": "nix-systems",
"repo": "default",
"type": "github"
}
}
},
"root": "root",
"version": 7
}

80
flake.nix Executable file
View File

@ -0,0 +1,80 @@
{
inputs = {
nixpkgs.url = "github:nixos/nixpkgs/nixos-unstable";
flake-utils.url = "github:numtide/flake-utils";
nixgl.url = "github:guibou/nixGL";
rust-overlay.url = "github:oxalica/rust-overlay";
};
outputs = { self, nixpkgs, flake-utils, nixgl, rust-overlay, ... }:
flake-utils.lib.eachDefaultSystem (system:
let
overlays = [ nixgl.overlay (import rust-overlay) ];
pkgs = import nixpkgs {
inherit system overlays;
};
fixed-odin = pkgs.odin.overrideAttrs (finalAttrs: prevAttr: rec {
src = pkgs.fetchFromGitHub {
owner = "odin-lang";
repo = "Odin";
rev = "aab122ede8b04a9877e22c9013c0b020186bc9b4";
# hash = "sha256-pxvU5veB1NEYPfer5roiLp/od2Pv4l1jJah0OHwb5yo=";
};
LLVM_CONFIG = "${pkgs.llvmPackages_17.llvm.dev}/bin/llvm-config";
nativeBuildInputs = with pkgs; prevAttr.nativeBuildInputs ++ [ libcxx libcxxabi ];
postPatch = prevAttr.postPatch + ''
sed -i build_odin.sh \
-e 's|CXXFLAGS="$CXXFLAGS $($LLVM_CONFIG --cxxflags --ldflags)"|CXXFLAGS="$CXXFLAGS $($LLVM_CONFIG --cxxflags --ldflags) -I ${pkgs.libiconv.outPath}/include/"|' \
-e 's|LDFLAGS="$LDFLAGS -pthread -lm -lstdc++"|LDFLAGS="$LDFLAGS -pthread -lm -lstdc++ -L ${pkgs.libiconv.outPath}/lib/ -L ${pkgs.llvmPackages_17.libcxxabi.outPath}/lib/"|'
'';
installPhase = ''
runHook preInstall
mkdir -p $out/bin
cp odin $out/bin/odin
mkdir -p $out/share
cp -r core $out/share/core
cp -r vendor $out/share/vendor
wrapProgram $out/bin/odin \
--set PATH ${pkgs.lib.makeBinPath (with pkgs; [
coreutils
llvmPackages_17.bintools
llvmPackages_17.lld
llvmPackages_17.clang
])} \
--set-default ODIN_ROOT $out/share
runHook postInstall
'';
});
in
{
devShell = pkgs.mkShell {
buildInputs = with pkgs; (if pkgs.system == "aarch64-darwin" || pkgs.system == "x86_64-darwin" then [
odin
darwin.apple_sdk.frameworks.CoreData
darwin.apple_sdk.frameworks.Kernel
darwin.apple_sdk.frameworks.CoreVideo
darwin.apple_sdk.frameworks.GLUT
darwin.apple_sdk.frameworks.IOKit
darwin.apple_sdk.frameworks.OpenGL
darwin.apple_sdk.frameworks.Cocoa
] else if pkgs.system == "x86_64-linux" then [
pkg-config
binutils
odin
libGL
xorg.libX11
xorg.libXi
xorg.xinput
xorg.libXcursor
xorg.libXrandr
xorg.libXinerama
pkgs.nixgl.nixGLIntel
] else throw "unsupported system" );
};
}
);
}

27
justfile Normal file
View File

@ -0,0 +1,27 @@
alias b := build
alias r := run
c_flags := if os() == "macos" {
"$(curl-config --libs) -framework Cocoa -framework QuartzCore -framework CoreImage -framework Metal -framework MetalKit -ObjC"
} else if os_family() == "unix" {
"$(curl-config --libs) -lEGL -lGLESv2 -lGL -lm -lwayland-client -lwayland-egl -lX11 -lXi -lXcursor -Wno-implicit-function-declaration"
} else { "" }
build: build_gfx
odin build src/ -out:bin/chat_client -debug -lld -extra-linker-flags:"-framework Cocoa -framework QuartzCore -framework CoreImage -framework Metal -framework MetalKit"
[macos]
build_gfx: transpile_shaders_metal
mkdir -p bin
cc -O0 -g -c -ObjC -Wall -Wextra -D_FONT_WIDTH=12 -D_FONT_HEIGHT=24 -DED_GFX_IMPLEMENTATION vendor/pcleavelin/gfx.h -o bin/libgfx.a
[macos]
run: build
./bin/chat_client
[macos]
transpile_shaders_metal:
mkdir -p bin/transpiled_shaders
xcrun -sdk macosx metal -o bin/transpiled_shaders/text_atlas.ir -c shaders/text_atlas.metal
xcrun -sdk macosx metallib -o bin/shaders.metallib bin/transpiled_shaders/text_atlas.ir

145
shaders/text_atlas.metal Normal file
View File

@ -0,0 +1,145 @@
#include <metal_stdlib>
using namespace metal;
struct VertexInput {
float2 position;
float2 tex_coord;
};
struct VertexOutput {
float4 position [[position]];
float4 color;
float2 tex_coord;
};
struct Glyph {
float2 atlas_position;
float2 size;
float2 target_position;
float y_offset;
float _haha_alignment;
float4 color;
};
struct UniformParams {
float2 screen_size;
};
float4 to_device_position(float2 position, float2 size) {
return float4(((position / size) * 2.0) - float2(1.0), 1.0, 1.0);
}
vertex VertexOutput
vs_main(
uint vertex_id [[vertex_id]],
uint glyph_id [[instance_id]],
constant VertexInput *vertices [[buffer(0)]],
constant Glyph *glyphs [[buffer(1)]],
constant UniformParams &params [[buffer(2)]]
)
{
VertexOutput out;
Glyph glyph = glyphs[glyph_id];
float2 scaled_size = ((vertices[vertex_id].position + 1.0) / 2.0) * (glyph.size/2.0);
float2 scaled_size_2 = ((vertices[vertex_id].position + 1.0) / 2.0) * (glyph.size);
float2 glyph_pos = scaled_size + glyph.target_position + float2(0, glyph.y_offset/2.0+24);
float4 device_position = to_device_position(glyph_pos, params.screen_size);
float2 atlas_position = (scaled_size_2 + glyph.atlas_position) / 512.0;
device_position.y = -device_position.y;
out.position = device_position;
out.color = glyph.color;
out.tex_coord = atlas_position;
return out;
}
fragment float4 fs_main(VertexOutput in [[stage_in]],
texture2d<float, access::sample> texture [[texture(0)]])
{
constexpr sampler texture_sampler (mag_filter::linear, min_filter::linear);
float text_color = texture.sample(texture_sampler, in.tex_coord).r;
return float4(in.color.rgb, text_color);
}
struct UiRect {
float4 position;
float4 size;
float4 border_size;
float4 color;
};
struct UiRectFragment {
float4 device_position [[position]];
float2 position;
float2 size;
float2 border_size;
float2 screen_size;
float2 tex_coord;
float4 color;
};
vertex UiRectFragment
ui_rect_vs(
uint vertex_id [[vertex_id]],
uint rect_id [[instance_id]],
constant VertexInput *vertices [[buffer(0)]],
constant UiRect *rects [[buffer(1)]],
constant UniformParams &params [[buffer(2)]]
)
{
UiRect rect = rects[rect_id];
float2 scaled_size = ((vertices[vertex_id].position.xy + 1.0) / 2.0) * (rect.size.xy);
float2 rect_pos = scaled_size + rect.position.xy;
float4 device_position = to_device_position(rect_pos, params.screen_size);
device_position.y = -device_position.y;
return UiRectFragment {
device_position,
rect.position.xy,
rect.size.xy,
rect.border_size.xy,
params.screen_size,
vertices[vertex_id].tex_coord,
rect.color,
};
}
float rect_sdf(
float2 absolute_pixel_position,
float2 origin,
float2 size,
float corner_radius
) {
float2 half_size = size / 2;
float2 rect_center = origin + half_size;
float2 pixel_position = abs(absolute_pixel_position - rect_center);
float2 shrunk_corner_position = half_size - corner_radius;
float2 pixel_to_shrunk_corner = max(float2(0), pixel_position - shrunk_corner_position);
float distance_to_shrunk_corner = length(pixel_to_shrunk_corner);
float distance = distance_to_shrunk_corner - corner_radius;
return distance;
}
fragment float4 ui_rect_fs(UiRectFragment in [[stage_in]])
{
float2 pixel_pos = (in.device_position.xy + 1.0) / 2.0;
float distance = rect_sdf(pixel_pos, in.position, in.size, in.border_size.x);
if (distance <= 0.0) {
return in.color;
} else {
return float4(0);
}
}

18
shaders/text_atlas_fragment.glsl Normal file
View File

@ -0,0 +1,18 @@
#version 440 core
struct VertexOutput {
vec4 position;
vec2 tex_coord;
};
layout(location = 0) in VertexOutput out_vertex;
layout(location = 1) uniform highp sampler2D atlas_texture;
out vec4 color;
void main() {
float text_color = texture(atlas_texture, out_vertex.tex_coord).r;
color = vec4(text_color * vec3(1,1,1), text_color);
}

56
shaders/text_atlas_vertex.glsl Normal file
View File

@ -0,0 +1,56 @@
#version 440 core
struct Vertex {
vec2 position;
vec2 tex_coord;
};
struct VertexOutput {
vec4 position;
vec2 tex_coord;
};
struct Glyph {
vec2 atlas_position;
vec2 size;
vec2 target_position;
float y_offset;
float _haha_alignment;
};
layout(std430, binding = 0) readonly buffer VertexBlock {
Vertex vertices[];
};
layout(std430, binding = 1) readonly buffer GlyphBlock {
Glyph glyphs[];
};
layout(std430, binding = 2) readonly buffer ParamsBlock {
vec2 screen_size;
vec2 font_size;
};
vec4 to_device_position(vec2 position, vec2 size) {
return vec4(((position / size) * 2.0) - vec2(1.0), 1.0, 1.0);
}
layout(location = 0) out VertexOutput out_vertex;
void main() {
Glyph glyph = glyphs[gl_InstanceID];
vec2 scaled_size = ((vertices[gl_VertexID].position + 1.0) / 2.0) * (glyph.size/2.0);
vec2 scaled_size_2 = ((vertices[gl_VertexID].position + 1.0) / 2.0) * (glyph.size);
vec2 glyph_pos = scaled_size + glyph.target_position + vec2(0, glyph.y_offset/2.0+font_size.y);
vec4 device_position = to_device_position(glyph_pos, screen_size);
vec2 atlas_position = (scaled_size_2 + glyph.atlas_position) / 512.0;
device_position.y = -device_position.y;
out_vertex.position = device_position;
out_vertex.tex_coord = atlas_position;
gl_Position = device_position;
}

45
shaders/ui_rect_fragment.glsl Normal file
View File

@ -0,0 +1,45 @@
#version 440 core
struct UiRectFragment {
highp vec4 device_position;
highp vec2 position;
highp vec2 size;
highp vec2 border_size;
highp vec2 screen_size;
highp vec2 tex_coord;
highp vec4 color;
};
in UiRectFragment out_rect;
layout(location = 0) out highp vec4 color;
highp float rect_sdf(
highp vec2 absolute_pixel_position,
highp vec2 origin,
highp vec2 size,
highp float corner_radius
) {
highp vec2 half_size = size / 2.0;
highp vec2 rect_center = origin + half_size;
highp vec2 pixel_position = abs(absolute_pixel_position - rect_center);
highp vec2 shrunk_corner_position = half_size - corner_radius;
highp vec2 pixel_to_shrunk_corner = max(vec2(0), pixel_position - shrunk_corner_position);
highp float distance_to_shrunk_corner = length(pixel_to_shrunk_corner);
highp float distance = distance_to_shrunk_corner - corner_radius;
return distance;
}
void main() {
highp vec2 pixel_pos = out_rect.tex_coord.xy * out_rect.screen_size;
highp float distance = rect_sdf(pixel_pos, out_rect.position, out_rect.size, out_rect.border_size.x);
if (distance <= 0.0) {
color = out_rect.color;
} else {
color = vec4(0);
}
}

50
shaders/ui_rect_vertex.glsl Normal file
View File

@ -0,0 +1,50 @@
#version 440 core
struct Vertex {
vec2 position;
vec2 tex_coord;
};
struct UiRect {
vec4 position;
vec4 size;
vec4 border_size;
vec4 color;
};
struct UiRectFragment {
highp vec4 device_position;
highp vec2 position;
highp vec2 size;
highp vec2 border_size;
highp vec2 screen_size;
highp vec2 tex_coord;
highp vec4 color;
};
layout(std430, binding = 0) readonly buffer VertexBlock {
Vertex vertices[];
};
layout(std430, binding = 1) readonly buffer RectBlock {
UiRect rects[];
};
layout(std430, binding = 2) readonly buffer ParamsBlock {
vec2 screen_size;
};
out UiRectFragment out_rect;
void main() {
UiRect rect = rects[gl_InstanceID];
out_rect.device_position = vec4(vertices[gl_VertexID].position, 1, 1);
out_rect.position = rect.position.xy;
out_rect.size = rect.size.xy;
out_rect.border_size = rect.border_size.xy;
out_rect.screen_size = screen_size;
out_rect.tex_coord = vertices[gl_VertexID].tex_coord;
out_rect.color = rect.color;
gl_Position = vec4(vertices[gl_VertexID].position, 1, 1);
}

53
src/gfx/gfx.odin Normal file
View File

@ -0,0 +1,53 @@
package gfx;
import "core:strings"
import c "core:c"
foreign import gfx "../../bin/libgfx.a"
GfxFrameFunc :: proc "c" (mouse_x: int, mouse_y: int, mouse_left_down: bool, mouse_right_down: bool)
cx :: struct {}
GpuGlyph :: struct {
atlas_position: [2]f32,
size: [2]f32,
position: [2]f32,
y_offset: f32,
_haha_alignment: f32,
color: [2]f32,
}
@(private)
gfx_string :: struct {
data: [^]u8,
len: c.size_t,
// unused
owned: c.bool,
}
foreign gfx {
keep_running: bool
@(link_name="gfx_init_context") init_context :: proc "c" (frame_func: GfxFrameFunc, width: u32, height: u32) -> ^cx ---
@(link_name="gfx_run_events") run_events :: proc "c" (gfx_cx: ^cx) ---
@(link_name="gfx_add_glyph") add_glyph :: proc "c" (gfx_cx: ^cx, glyph: GpuGlyph) ---
@(link_name="gfx_push_texture_buffer") push_texture_buffer :: proc "c" (gfx_cx: ^cx, width: u32, height: u32, data: [^]u8, len: u32) ---
@(private)
gfx_queue_text :: proc "c" (gfx_cx: ^cx, text: gfx_string, position: [^]f32, max_x: f32, max_y: f32, color: [^]f32) ---
}
queue_text :: proc(gfx_cx: ^cx, text: string, position: [2]f32, max_x: f32, max_y: f32, color: [4]f32) {
text_ := gfx_string {
data = raw_data(text),
len = len(text),
};
p := []f32 { position[0], position[1] }
c := []f32 { color[0], color[1], color[2], color[3] }
gfx_queue_text(gfx_cx, text_, raw_data(p), max_x, max_y, raw_data(c))
}

92
src/main.odin Normal file
View File

@ -0,0 +1,92 @@
package main
import "core:runtime";
import "core:fmt";
import "core:os";
import stbtt "vendor:stb/truetype";
import "gfx";
gfx_cx: ^gfx.cx = nil
frame_func :: proc "c" (mouse_x: int, mouse_y: int, mouse_left_down: bool, mouse_right_down: bool) {
context = runtime.default_context();
for y in 0..<100 {
for x in 0..<100 {
gfx.queue_text(gfx_cx, "Helope!", { f32(x)*100, f32(x)*24 + f32(y)*26}, 1000, 1000, { 1, 1, 1, 1 });
}
}
}
main :: proc() {
gfx_cx = gfx.init_context(frame_func, 800, 600)
font_data, success := os.read_entire_file_from_filename("./bin/JetBrainsMono-Medium.ttf");
if !success {
fmt.eprintln("failed to read font file");
os.exit(1);
}
font: stbtt.fontinfo;
if stbtt.InitFont(&font, raw_data(font_data), 0) == false {
fmt.eprintln("failed to init font");
os.exit(1);
}
bitmap_size: i32 = 512;
bitmap := make([]u8, bitmap_size * bitmap_size);
rasterized_font_height: i32 = 24;
ascent, descent, line_gap: i32;
scale := stbtt.ScaleForPixelHeight(&font, f32(rasterized_font_height * 2));
stbtt.GetFontVMetrics(&font, &ascent, &descent, &line_gap);
gfx.add_glyph(gfx_cx, gfx.GpuGlyph {
size = {f32(rasterized_font_height/4), 1},
y_offset = f32(-rasterized_font_height),
});
x := rasterized_font_height / 4;
y: i32 = 0;
for i in 33..<33+96 {
width, height, xoff, yoff: i32;
glyph_bitmap := stbtt.GetCodepointBitmap(
&font, scale, scale, rune(i), &width, &height, &xoff, &yoff);
if (x + width) >= bitmap_size {
x = 0;
y += i32(f32(ascent - descent + line_gap) * scale);
}
xxx: i32 = x;
for xx in 0..<width {
yyy: i32 = y;
for yy in 0..<height {
bitmap[xxx + yyy * bitmap_size] =
glyph_bitmap[xx + yy * width];
yyy += 1;
}
xxx += 1;
}
gfx.add_glyph(gfx_cx,
gfx.GpuGlyph {
atlas_position = {f32(x), f32(y)},
size = {f32(width), f32(height)},
position = {f32(x), f32(y)},
y_offset = f32(yoff),
}
);
x += width;
}
gfx.push_texture_buffer(gfx_cx, u32(bitmap_size), u32(bitmap_size), raw_data(bitmap), u32(bitmap_size * bitmap_size));
for(gfx.keep_running) {
gfx.run_events(gfx_cx)
}
}

90
vendor/pcleavelin/ed_array.h vendored Normal file
View File

@ -0,0 +1,90 @@
#ifndef ED_ARRAY_INCLUDED
#define ED_ARRAY_INCLUDED
#include <assert.h>
#include <memory.h>
#include <stdio.h>
#include <stdlib.h>
#define array(T) struct T##_Array
#define arrayTemplate(T) \
array(T) { \
size_t size, capacity; \
T *data; \
}; \
array(T) T##_ArrayConstruct(size_t size) { \
array(T) this; \
this.size = 0; \
this.capacity = size; \
this.data = malloc(size * sizeof(T)); \
if (!this.data) { \
assert("failed to allocate memory for array"); \
} \
return this; \
}; \
void T##_PushArray(array(T) * arr, T value) { \
if (arr->size == arr->capacity) { \
arr->capacity *= 2; \
void *new_data = realloc(arr->data, arr->capacity * sizeof(T)); \
if (new_data == NULL) { \
fprintf(stderr, "out of memory when reallocating array\n"); \
} \
arr->data = new_data; \
} \
if (arr->size + 1 <= arr->capacity) { \
arr->data[arr->size] = value; \
arr->size += 1; \
} \
}; \
void T##_PushArrayMulti(array(T) * arr, T * values, size_t len) { \
for (size_t i = 0; i < len; ++i) { \
T##_PushArray(arr, values[i]); \
} \
}; \
void T##_InsertArrayAt(array(T) * arr, size_t loc, T value) { \
if (arr->size == arr->capacity) { \
arr->capacity *= 2; \
void *new_data = realloc(arr->data, arr->capacity * sizeof(T)); \
if (new_data == NULL) { \
fprintf(stderr, "out of memory when reallocating array\n"); \
} \
arr->data = new_data; \
} \
memcpy(&arr->data[loc + 1], &arr->data[loc], arr->size * sizeof(T)); \
arr->data[loc] = value; \
arr->size += 1; \
};
#define slice(T) struct T##_Slice
#define sliceTemplate(T) \
slice(T) { \
size_t len; \
T *data; \
}; \
array(T) T##_FromSlice(slice(T) s) { \
array(T) arr = T##_ArrayConstruct(s.len); \
memcpy(arr.data, s.data, sizeof(T) * s.len); \
arr.size = s.len; \
return arr; \
} \
slice(T) T##_SliceConstruct(void *data, size_t len) { \
slice(T) this; \
this.len = len; \
this.data = data; \
return this; \
}
#define newArray(T, size) T##_ArrayConstruct(size)
#define newArrayFromSlice(T, s) T##_FromSlice(s)
#define pushArray(T, arr, value) T##_PushArray(arr, (value))
#define pushArrayMulti(T, arr, values, len) T##_PushArrayMulti(arr, values, len)
#define insertArrayAt(T, arr, loc, value) T##_InsertArrayAt(arr, loc, (value))
#define newSlice(T, data, len) T##_SliceConstruct(data, len)
arrayTemplate(uint8_t);
sliceTemplate(uint8_t);
arrayTemplate(uint32_t);
sliceTemplate(uint32_t);
#endif

1347
vendor/pcleavelin/gfx.h vendored Normal file
View File

File diff suppressed because it is too large Load Diff

106
vendor/pcleavelin/string.h vendored Normal file
View File

@ -0,0 +1,106 @@
#ifndef ED_STRING_INCLUDED
#define ED_STRING_INCLUDED
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
#include <stdlib.h>
#include <string.h>
#define _String(text) \
((string){.data = (uint8_t *)text, .len = sizeof(text) - 1, .owned = false})
#define _CString_To_String(text) \
((string){.data = (uint8_t *)text, .len = strlen(text), .owned = false})
typedef struct {
uint8_t *data;
size_t len;
// FIXME: this is so terribly bad please don't do this
bool owned;
} string;
bool string_eq(string a, string b);
bool string_eq_cstring(string a, const char *b);
string string_copy(string s);
string string_copy_cstring(const char *str);
char *cstring_copy_string(string str);
#ifdef ED_STRING_IMPLEMENTATION
bool string_eq(string a, string b) {
if (a.len != b.len || a.data == NULL || b.data == NULL)
return false;
for (size_t i = 0; i < a.len; ++i) {
if (a.data[i] != b.data[i])
return false;
}
return true;
}
bool string_eq_cstring(string a, const char *b) {
if (b == NULL) {
if (a.len == 0) {
return true;
}
return false;
}
size_t b_len = strlen(b);
if (a.len != b_len)
return false;
for (size_t i = 0; i < a.len; ++i) {
if (a.data[i] != b[i])
return false;
}
return true;
}
string string_copy(string a) {
if (a.data == NULL || a.len == 0) {
return (string){.data = NULL, .len = 0, .owned = false};
}
string new_string;
new_string.data = malloc(a.len * sizeof(uint8_t));
new_string.len = a.len;
new_string.owned = true;
memcpy(new_string.data, a.data, new_string.len * sizeof(uint8_t));
return new_string;
}
string string_copy_cstring(const char *str) {
if (str == NULL) {
return (string){.data = NULL, .len = 0, .owned = false};
}
string new_string;
size_t len = strlen(str);
new_string.data = malloc(len * sizeof(uint8_t));
new_string.len = len;
new_string.owned = true;
memcpy(new_string.data, str, new_string.len * sizeof(uint8_t));
return new_string;
}
char *cstring_copy_string(string str) {
char *new_str = malloc(str.len + 1);
memcpy(new_str, str.data, str.len);
new_str[str.len] = 0;
return new_str;
}
#endif
#endif