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

fork from an_editor

main
Patrick Cleavelin 2024-04-16 16:05:57 -05:00
commit 0d8b0b738a
18 changed files with 7336 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

BIN
.DS_Store vendored Normal file
View File

Binary file not shown.

1
.gitignore vendored Normal file
View File

@ -0,0 +1 @@
bin/

18
compile_commands.json Normal file
View File

@ -0,0 +1,18 @@
[
{
"arguments": [
"/nix/store/qhpw32pz39y6i30b3vrbw5fw6zv5549f-gcc-wrapper-13.2.0/bin/cc",
"-c",
"-Ivendor/",
"-g",
"-Wall",
"-Wextra",
"-o",
"bin/an_editor.o",
"src/main.c"
],
"directory": "/home/patrick/Documents/an_editor",
"file": "/home/patrick/Documents/an_editor/src/main.c",
"output": "/home/patrick/Documents/an_editor/bin/an_editor.o"
}
]

8
debug.plist Normal file
View File

@ -0,0 +1,8 @@
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "https://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
<key>com.apple.security.get-task-allow</key>
<true/>
</dict>
</plist>

111
flake.lock Normal file
View File

@ -0,0 +1,111 @@
{
"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"
}
},
"nixgl": {
"inputs": {
"flake-utils": "flake-utils_2",
"nixpkgs": "nixpkgs"
},
"locked": {
"lastModified": 1685908677,
"narHash": "sha256-E4zUPEUFyVWjVm45zICaHRpfGepfkE9Z2OECV9HXfA4=",
"owner": "guibou",
"repo": "nixGL",
"rev": "489d6b095ab9d289fe11af0219a9ff00fe87c7c5",
"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": 1710272261,
"narHash": "sha256-g0bDwXFmTE7uGDOs9HcJsfLFhH7fOsASbAuOzDC+fhQ=",
"owner": "nixos",
"repo": "nixpkgs",
"rev": "0ad13a6833440b8e238947e47bea7f11071dc2b2",
"type": "github"
},
"original": {
"owner": "nixos",
"ref": "nixos-unstable",
"repo": "nixpkgs",
"type": "github"
}
},
"root": {
"inputs": {
"flake-utils": "flake-utils",
"nixgl": "nixgl",
"nixpkgs": "nixpkgs_2"
}
},
"systems": {
"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
}

68
flake.nix Executable file
View File

@ -0,0 +1,68 @@
{
inputs = {
nixpkgs.url = "github:nixos/nixpkgs/nixos-unstable";
flake-utils.url = "github:numtide/flake-utils";
nixgl.url = "github:guibou/nixGL";
};
outputs = { self, nixpkgs, flake-utils, nixgl, ... }:
flake-utils.lib.eachDefaultSystem (system:
let
overlays = [ nixgl.overlay ];
pkgs = import nixpkgs {
inherit system overlays;
};
naga-cli = pkgs.rustPlatform.buildRustPackage rec {
pname = "naga-cli";
version = "v0.19.0";
src = pkgs.fetchFromGitHub {
name = "wgpu";
owner = "gfx-rs";
repo = "wgpu";
rev = "a63bec8cd67b4abe3b9717e1926a94d1035b830a"; # trunk as of 2024-03-15
hash = "sha256-AzsR24NAVYgrC/kWGXiWxyMERiLJ/Jink21P4oh8lOw=";
};
buildAndTestSubdir = "naga-cli";
cargoLock = {
lockFile = "${src}/Cargo.lock";
allowBuiltinFetchGit = true;
};
};
in
{
devShell = pkgs.mkShell {
buildInputs = with pkgs; (if pkgs.system == "aarch64-darwin" || pkgs.system == "x86_64-darwin" then [
pkg-config
binutils
clang
bear
naga-cli
darwin.apple_sdk.frameworks.Kernel
darwin.apple_sdk.frameworks.CoreVideo
darwin.apple_sdk.frameworks.Metal
darwin.apple_sdk.frameworks.MetalKit
darwin.apple_sdk.frameworks.Cocoa
] else if pkgs.system == "x86_64-linux" then [
pkg-config
binutils
clang
bear
naga-cli
libGL
mesa
gf
xorg.libX11
xorg.libXi
xorg.xinput
xorg.libXcursor
xorg.libXrandr
xorg.libXinerama
pkgs.nixgl.nixGLIntel
]
else throw "unsupported system" );
};
}
);
}

18
justfile Normal file
View File

@ -0,0 +1,18 @@
alias b := build
alias r := run
build: transpile_shaders_metal
mkdir -p bin
cc -Ivendor/ -O0 -g -Wall -Wextra -framework Cocoa -framework QuartzCore -framework CoreImage -framework Metal -framework MetalKit -ObjC src/*.c -o bin/an_editor
# cc -Ivendor/ -g -Wall -Wextra src/*.c -o bin/an_editor -lEGL -lGLESv2 -lGL -lm -lX11 -lXi -lXcursor
# cc bin/*.o -o bin/an_editor -lEGL -lGLESv2 -lGL -lm -lX11 -lXi -lXcursor
run: build
# nixGLIntel ./bin/an_editor
./bin/an_editor
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

136
shaders/text_atlas.metal Normal file
View File

@ -0,0 +1,136 @@
#include <metal_stdlib>
using namespace metal;
struct VertexInput {
float2 position;
float2 tex_coord;
};
struct VertexOutput {
float4 position [[position]];
float2 tex_coord;
};
struct Glyph {
float2 atlas_position;
float2 size;
float2 target_position;
float y_offset;
float _haha_alignment;
};
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.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(text_color * float3(1,1,1), 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];
return UiRectFragment {
float4(vertices[vertex_id].position, 1, 1),
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.tex_coord.xy * in.screen_size;
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);
}
}

8
src/compile_flags.txt Normal file
View File

@ -0,0 +1,8 @@
-DED_UI_IMPLEMENTATION
-DED_HT_IMPLEMENTATION
-DED_STRING_IMPLEMENTATION
-DED_GFX_IMPLEMENTATION
-DED_BUFFER_IMPLEMENTATION
-DED_FILE_IO_IMPLEMENTATION
-I../vendor/
-ObjC

80
src/ed_array.h Normal file
View File

@ -0,0 +1,80 @@
#ifndef ED_ARRAY_INCLUDED
#define ED_ARRAY_INCLUDED
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <memory.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+1 <= arr->capacity) {\
arr->data[arr->size] = value;\
arr->size += 1;\
} else {\
fprintf(stderr, "failed to push to u8 array, size+num > capacity\n");\
}\
};\
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);\
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);
#endif

138
src/file_io.h Normal file
View File

@ -0,0 +1,138 @@
#ifndef ED_FILE_IO_INCLUDED
#define ED_FILE_IO_INCLUDED
#include <stdint.h>
#include <stdbool.h>
#include "string.h"
uint64_t get_file_size(string file_path);
bool load_file(string file_path, size_t size, void *buffer);
#ifdef ED_FILE_IO_IMPLEMENTATION
#if defined(__unix__)
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
unsigned long get_file_size(const char *filePath) {
FILE *file = fopen(filePath, "r");
assert(file && "get_file_size: failed to open file");
fseek(file, 0, SEEK_END);
long fsize = ftell(file);
fseek(file, 0, SEEK_SET);
fclose(file);
return fsize;
}
bool load_file(const char *filePath, unsigned long size, void *buffer) {
FILE *file = fopen(filePath, "r");
assert(file && "load_file: failed to open file");
fseek(file, 0, SEEK_END);
long fsize = ftell(file);
fseek(file, 0, SEEK_SET);
fread(buffer, fsize, 1, file);
fclose(file);
return true;
}
#elif defined(_WIN32) || defined(WIN32)
#include <windows.h>
#define assertm(exp, msg) assert(((void)msg, exp))
VOID CALLBACK FileIOCompletionRoutine(
__in DWORD dwErrorCode,
__in DWORD dwNumberOfBytesTransfered,
__in LPOVERLAPPED lpOverlapped )
{
printf("Error code: %li", dwErrorCode);
printf("Number of bytes: %li", dwNumberOfBytesTransfered);
}
unsigned long get_file_size(const char *filePath) {
HANDLE hFile = CreateFile(filePath,
GENERIC_READ,
FILE_SHARE_READ,
NULL,
OPEN_EXISTING,
FILE_ATTRIBUTE_NORMAL | FILE_FLAG_OVERLAPPED,
NULL);
LARGE_INTEGER size;
assert(GetFileSizeEx(hFile, &size) && "get_file_size: failed to get file size");
return size.LowPart;
}
bool load_file(const char *filePath, unsigned long size, void *buffer) {
HANDLE hFile = CreateFile(filePath,
GENERIC_READ,
FILE_SHARE_READ,
NULL,
OPEN_EXISTING,
FILE_ATTRIBUTE_NORMAL,
NULL);
OVERLAPPED ol = {0};
unsigned long bytesRead = 0;
if (!ReadFile(hFile, buffer, size, &bytesRead, NULL)) {
unsigned long error = GetLastError();
unsigned long msg = FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM, NULL, error, 0, buffer, size, NULL);
printf("failed to load file: %s\n", (char *)buffer);
assert(false && "failed to read file");
}
assert(bytesRead == size && "load_file: didn't one-shot read the whole file");
return true;
}
#elif defined(__APPLE__)
#include <Foundation/Foundation.h>
uint64_t get_file_size(string file_path) {
NSFileManager* file_manager = [NSFileManager defaultManager];
NSString *path = [file_manager stringWithFileSystemRepresentation:(const char *)file_path.data length:file_path.len];
NSError *error = NULL;
NSDictionary<NSFileAttributeKey, id> *attributes = [file_manager attributesOfItemAtPath:path error:&error];
if (error) {
NSLog(@"error getting file attributes: %@\n", error.description);
return 0;
}
NSNumber *file_size = [attributes objectForKey:NSFileSize];
return file_size.unsignedLongLongValue;
}
bool load_file(string file_path, size_t size, void *buffer) {
NSFileManager* file_manager = [NSFileManager defaultManager];
NSString *path = [file_manager stringWithFileSystemRepresentation:(const char *)file_path.data length:file_path.len];
NSData *data = [file_manager contentsAtPath:path];
if (data == NULL) {
fprintf(stderr, "failed to load file: %.*s\n", (int)file_path.len, file_path.data);
return false;
}
if (data.length > size) {
fprintf(stderr, "buffer not large enough for file: %.*s\n", (int)file_path.len, file_path.data);
}
memcpy(buffer, data.bytes, data.length);
return true;
}
#endif
#endif
#endif

606
src/gfx.h Normal file
View File

@ -0,0 +1,606 @@
// Graphics layer abstraction.
#ifndef ED_GFX_INCLUDED
#define ED_GFX_INCLUDED
#include <AppKit/AppKit.h>
#include <CoreGraphics/CoreGraphics.h>
#include <Foundation/Foundation.h>
#include <Metal/Metal.h>
#include <QuartzCore/CoreAnimation.h>
#include <QuartzCore/QuartzCore.h>
#include <stdint.h>
#include "ed_array.h"
#include "string.h"
bool keep_running = true;
@interface EDGFXView : NSView
@end
@interface AppDelegate : NSObject <NSApplicationDelegate>
@end
@interface WindowDelegate : NSObject <NSWindowDelegate>
@end
#define wrapIdArray(T) \
typedef id<T> _##T; \
arrayTemplate(_##T);
wrapIdArray(MTLRenderPipelineState);
wrapIdArray(MTLBuffer);
wrapIdArray(MTLTexture);
typedef struct {
float position[4];
float size[4];
float border_size[4];
float color[4];
} GpuUiRect;
arrayTemplate(GpuUiRect);
typedef struct {
float atlas_position[2];
float size[2];
float position[2];
float y_offset;
float _haha_alignment;
} GpuGlyph;
arrayTemplate(GpuGlyph);
typedef struct {
float screen_size[2];
} GpuUniformParams;
#if defined(__APPLE__)
typedef struct {
NSApplication *application;
NSWindow *window;
EDGFXView *view;
bool keep_running;
// Metal objects
id<MTLDevice> device;
CAMetalLayer *metal_layer;
id<MTLLibrary> library;
id<MTLCommandQueue> command_queue;
array(_MTLRenderPipelineState) pipelines;
array(_MTLBuffer) buffers;
array(_MTLTexture) textures;
} _metal_gfx_context;
#endif
typedef void (*_gfx_frame_func)();
typedef struct {
#if defined(__APPLE__)
_metal_gfx_context backend;
#else
#error "Unsupported platform"
#endif
uint32_t frame_width;
uint32_t frame_height;
_gfx_frame_func frame_func;
array(GpuUiRect) gpu_ui_rects;
array(GpuGlyph) gpu_glyphs;
array(GpuGlyph) glyph_cache;
} gfx_context_t;
static gfx_context_t _gfx_context;
#ifdef ED_GFX_IMPLEMENTATION
#if defined(__APPLE__)
static void _metal_gfx_present(_metal_gfx_context *cx);
static void _metal_gfx_send_events(_metal_gfx_context *cx);
void gfx_update_buffer(gfx_context_t *cx, size_t buffer_index, const void *data,
size_t len);
@implementation AppDelegate
- (NSApplicationTerminateReply)applicationShouldTerminate:
(NSApplication *)sender {
keep_running = false;
return NSTerminateCancel;
}
- (BOOL)applicationShouldTerminateAfterLastWindowClosed:
(NSApplication *)sender {
keep_running = false;
return NO;
}
@end
@implementation WindowDelegate
- (BOOL)windowShouldClose:(NSApplication *)sender {
keep_running = false;
return YES;
}
- (void)windowDidResize:(NSNotification *)notification {
_gfx_context.frame_width =
_gfx_context.backend.window.contentView.frame.size.width;
_gfx_context.frame_height =
_gfx_context.backend.window.contentView.frame.size.height;
CGFloat scale = _gfx_context.backend.metal_layer.contentsScale;
[_gfx_context.backend.metal_layer
setDrawableSize:CGSizeMake(_gfx_context.frame_width * scale,
_gfx_context.frame_height * scale)];
_gfx_context.backend.view.needsDisplay = true;
}
@end
@implementation EDGFXView
- (BOOL)isOpaque {
return YES;
}
- (void)updateLayer {
_metal_gfx_present(&_gfx_context.backend);
}
- (BOOL)wantsLayer {
return YES;
}
- (BOOL)wantsUpdateLayer {
return YES;
}
- (NSViewLayerContentsRedrawPolicy)layerContentsRedrawPolicy {
return NSViewLayerContentsRedrawOnSetNeedsDisplay;
}
- (void)insertText:(id)insertString {
NSLog(@"inserting text: %@", insertString);
}
@end
static _metal_gfx_context _metal_gfx_init_context(uint32_t width,
uint32_t height) {
NSApplication *application = [NSApplication sharedApplication];
if (application == NULL) {
fprintf(stderr, "NSApplication:sharedApplication failed\n");
exit(1);
}
NSString *title = @"chat - [Slack Sux]";
NSRect rect = NSMakeRect(0, 0, width, height);
NSWindow *window = [[NSWindow alloc]
initWithContentRect:rect
styleMask:NSWindowStyleMaskTitled | NSWindowStyleMaskClosable |
NSWindowStyleMaskMiniaturizable |
NSWindowStyleMaskResizable
backing:NSBackingStoreBuffered
defer:NO];
EDGFXView *view = [[EDGFXView alloc] initWithFrame:rect];
[view updateTrackingAreas];
[window setTitle:title];
[window setContentView:view];
[window setDelegate:[[WindowDelegate alloc] init]];
[window makeKeyAndOrderFront:NULL];
// TODO: make this work
// if (application.mainMenu == NULL) {
// NSMenu *menu = [[NSMenu alloc] initWithTitle:@"an_editor"];
// if (menu == NULL) {
// fprintf(stderr, "failed to create application menu\n");
// exit(1);
// }
// application.mainMenu = menu;
// }
[application setDelegate:[[AppDelegate alloc] init]];
[application setActivationPolicy:NSApplicationActivationPolicyRegular];
[application setPresentationOptions:NSApplicationPresentationDefault];
[application finishLaunching];
id<MTLDevice> device = MTLCreateSystemDefaultDevice();
CAMetalLayer *metal_layer = [CAMetalLayer layer];
metal_layer.device = device;
metal_layer.pixelFormat = MTLPixelFormatRGBA8Unorm;
metal_layer.frame = CGRectMake(0, 0, width, height);
metal_layer.needsDisplayOnBoundsChange = YES;
metal_layer.presentsWithTransaction = YES;
metal_layer.autoresizingMask = kCALayerWidthSizable | kCALayerHeightSizable;
// TODO: set this to the display dpi scale
metal_layer.contentsScale = 2.0;
view.wantsLayer = YES;
[view.layer addSublayer:metal_layer];
view.layerContentsRedrawPolicy = NSViewLayerContentsRedrawOnSetNeedsDisplay;
NSError *libraryError = NULL;
NSURL *libraryURL = [[NSBundle mainBundle] URLForResource:@"./shaders"
withExtension:@"metallib"];
if (libraryURL == NULL) {
fprintf(stderr, "Couldn't find library file\n");
exit(1);
}
id<MTLLibrary> library = [device newLibraryWithURL:libraryURL
error:&libraryError];
if (library == NULL) {
if (libraryError.description != NULL) {
NSLog(@"Error description: %@\n", libraryError.description);
}
exit(1);
}
id<MTLCommandQueue> command_queue = [device newCommandQueue];
id<MTLFunction> vertex_func = [library newFunctionWithName:@"vs_main"];
id<MTLFunction> fragment_func = [library newFunctionWithName:@"fs_main"];
id<MTLFunction> ui_rect_vertex_func =
[library newFunctionWithName:@"ui_rect_vs"];
id<MTLFunction> ui_rect_fragment_func =
[library newFunctionWithName:@"ui_rect_fs"];
MTLRenderPipelineDescriptor *pipeline_descriptor =
[[MTLRenderPipelineDescriptor alloc] init];
[pipeline_descriptor setVertexFunction:vertex_func];
[pipeline_descriptor setFragmentFunction:fragment_func];
pipeline_descriptor.colorAttachments[0].pixelFormat =
MTLPixelFormatRGBA8Unorm;
pipeline_descriptor.colorAttachments[0].alphaBlendOperation =
MTLBlendOperationAdd;
pipeline_descriptor.colorAttachments[0].sourceAlphaBlendFactor =
MTLBlendFactorSourceAlpha;
pipeline_descriptor.colorAttachments[0].destinationAlphaBlendFactor =
MTLBlendFactorOneMinusSourceAlpha;
pipeline_descriptor.colorAttachments[0].sourceRGBBlendFactor =
MTLBlendFactorSourceAlpha;
pipeline_descriptor.colorAttachments[0].destinationRGBBlendFactor =
MTLBlendFactorOneMinusSourceAlpha;
pipeline_descriptor.colorAttachments[0].blendingEnabled = true;
MTLRenderPipelineDescriptor *ui_rect_pipeline_descriptor =
[[MTLRenderPipelineDescriptor alloc] init];
[ui_rect_pipeline_descriptor setVertexFunction:ui_rect_vertex_func];
[ui_rect_pipeline_descriptor setFragmentFunction:ui_rect_fragment_func];
ui_rect_pipeline_descriptor.colorAttachments[0].pixelFormat =
MTLPixelFormatRGBA8Unorm;
ui_rect_pipeline_descriptor.colorAttachments[0].alphaBlendOperation =
MTLBlendOperationAdd;
ui_rect_pipeline_descriptor.colorAttachments[0].sourceAlphaBlendFactor =
MTLBlendFactorSourceAlpha;
ui_rect_pipeline_descriptor.colorAttachments[0].destinationAlphaBlendFactor =
MTLBlendFactorOneMinusSourceAlpha;
ui_rect_pipeline_descriptor.colorAttachments[0].sourceRGBBlendFactor =
MTLBlendFactorSourceAlpha;
ui_rect_pipeline_descriptor.colorAttachments[0].destinationRGBBlendFactor =
MTLBlendFactorOneMinusSourceAlpha;
ui_rect_pipeline_descriptor.colorAttachments[0].blendingEnabled = true;
NSError *pipeline_error = NULL;
array(_MTLRenderPipelineState) pipelines =
newArray(_MTLRenderPipelineState, 2);
pushArray(_MTLRenderPipelineState, &pipelines,
[device newRenderPipelineStateWithDescriptor:pipeline_descriptor
error:&pipeline_error]);
if (pipeline_error != NULL) {
if (pipeline_error.description != NULL) {
NSLog(@"Error description: %@\n", pipeline_error.description);
}
exit(1);
}
pushArray(_MTLRenderPipelineState, &pipelines,
[device
newRenderPipelineStateWithDescriptor:ui_rect_pipeline_descriptor
error:&pipeline_error]);
array(_MTLBuffer) buffers = newArray(_MTLBuffer, 8);
array(_MTLTexture) textures = newArray(_MTLTexture, 8);
if (pipeline_error != NULL) {
if (pipeline_error.description != NULL) {
NSLog(@"Error description: %@\n", pipeline_error.description);
}
exit(1);
}
return (_metal_gfx_context){
.application = application,
.window = window,
.view = view,
.keep_running = true,
.device = device,
.metal_layer = metal_layer,
.library = library,
.command_queue = command_queue,
.pipelines = pipelines,
.buffers = buffers,
.textures = textures,
};
}
static void _metal_gfx_send_events(_metal_gfx_context *cx) {
NSEvent *event = [cx->application nextEventMatchingMask:NSEventMaskAny
untilDate:[NSDate distantPast]
inMode:NSDefaultRunLoopMode
dequeue:YES];
[cx->application sendEvent:event];
}
static void _metal_gfx_present(_metal_gfx_context *cx) {
_gfx_context.gpu_glyphs.size = 0;
_gfx_context.gpu_ui_rects.size = 0;
_gfx_context.frame_func();
if (_gfx_context.gpu_glyphs.size > 0) {
gfx_update_buffer(&_gfx_context, 2, _gfx_context.gpu_glyphs.data,
_gfx_context.gpu_glyphs.size * sizeof(GpuGlyph));
}
if (_gfx_context.gpu_ui_rects.size > 0) {
gfx_update_buffer(&_gfx_context, 4, _gfx_context.gpu_ui_rects.data,
_gfx_context.gpu_ui_rects.size * sizeof(GpuUiRect));
}
GpuUniformParams gpu_uniform_params = {
.screen_size =
{
(float)_gfx_context.frame_width,
(float)_gfx_context.frame_height,
},
};
gfx_update_buffer(&_gfx_context, 3, &gpu_uniform_params,
sizeof(GpuUniformParams));
id<CAMetalDrawable> drawable = [cx->metal_layer nextDrawable];
id<MTLCommandBuffer> command_buffer = [cx->command_queue commandBuffer];
MTLRenderPassDescriptor *render_pass_desc =
[MTLRenderPassDescriptor renderPassDescriptor];
render_pass_desc.colorAttachments[0].texture = drawable.texture;
render_pass_desc.colorAttachments[0].loadAction = MTLLoadActionClear;
render_pass_desc.colorAttachments[0].clearColor =
MTLClearColorMake(0, 0, 0, 1);
render_pass_desc.colorAttachments[0].storeAction = MTLStoreActionStore;
id<MTLRenderCommandEncoder> encoder =
[command_buffer renderCommandEncoderWithDescriptor:render_pass_desc];
if (_gfx_context.gpu_ui_rects.size > 0) {
// UI Rects
[encoder setRenderPipelineState:cx->pipelines.data[1]];
// FIXME: allow these to be described by the user instead of hardcoded
[encoder setVertexBuffer:cx->buffers.data[0]
offset:0
atIndex:0]; // vertices
[encoder setVertexBuffer:cx->buffers.data[4]
offset:0
atIndex:1]; // ui rects
[encoder setVertexBuffer:cx->buffers.data[3]
offset:0
atIndex:2]; // uniforms
// TODO: get instance count properly
[encoder drawIndexedPrimitives:MTLPrimitiveTypeTriangle
indexCount:6
indexType:MTLIndexTypeUInt16
indexBuffer:cx->buffers.data[1]
indexBufferOffset:0
instanceCount:_gfx_context.gpu_ui_rects.size];
}
if (_gfx_context.gpu_glyphs.size > 0) {
// UI Text
[encoder setRenderPipelineState:cx->pipelines.data[0]];
// FIXME: allow these to be described by the user instead of hardcoded
[encoder setVertexBuffer:cx->buffers.data[0]
offset:0
atIndex:0]; // vertices
[encoder setVertexBuffer:cx->buffers.data[2]
offset:0
atIndex:1]; // glyph data
[encoder setVertexBuffer:cx->buffers.data[3]
offset:0
atIndex:2]; // uniforms
[encoder setFragmentTexture:cx->textures.data[0] atIndex:0];
// TODO: get instance count properly
[encoder drawIndexedPrimitives:MTLPrimitiveTypeTriangle
indexCount:6
indexType:MTLIndexTypeUInt16
indexBuffer:cx->buffers.data[1]
indexBufferOffset:0
instanceCount:_gfx_context.gpu_glyphs.size];
}
[encoder endEncoding];
[command_buffer presentDrawable:drawable];
[command_buffer commit];
[command_buffer waitUntilScheduled];
}
static size_t _metal_gfx_push_texture_buffer(_metal_gfx_context *cx,
uint32_t width, uint32_t height,
const void *data, size_t len) {
MTLTextureDescriptor *texture_desc = [MTLTextureDescriptor
texture2DDescriptorWithPixelFormat:MTLPixelFormatR8Unorm
width:width
height:height
mipmapped:false];
_MTLTexture texture = [cx->device newTextureWithDescriptor:texture_desc];
MTLRegion region = MTLRegionMake2D(0, 0, width, height);
[texture replaceRegion:region
mipmapLevel:0
slice:0
withBytes:data
bytesPerRow:width * sizeof(uint8_t)
bytesPerImage:len];
pushArray(_MTLTexture, &cx->textures, texture);
return cx->textures.size - 1;
}
static void _metal_gfx_resize_texture_buffer(_metal_gfx_context *cx,
uint32_t width,
size_t texture_index,
uint32_t height) {
[cx->textures.data[texture_index] setPurgeableState:MTLPurgeableStateEmpty];
[cx->textures.data[texture_index] release];
MTLTextureDescriptor *texture_desc = [MTLTextureDescriptor
texture2DDescriptorWithPixelFormat:MTLPixelFormatR8Unorm
width:width
height:height
mipmapped:false];
cx->textures.data[texture_index] =
[cx->device newTextureWithDescriptor:texture_desc];
}
size_t _metal_gfx_push_vertex_buffer(_metal_gfx_context *cx, const void *data,
size_t len) {
pushArray(_MTLBuffer, &cx->buffers,
[cx->device newBufferWithBytes:data
length:len
options:MTLResourceStorageModeShared]);
return cx->buffers.size - 1;
}
static size_t _metal_gfx_allocate_vertex_buffer(_metal_gfx_context *cx,
size_t len) {
pushArray(_MTLBuffer, &cx->buffers,
[cx->device newBufferWithLength:len
options:MTLResourceStorageModeShared]);
return cx->buffers.size - 1;
}
static void _metal_gfx_update_buffer(_metal_gfx_context *cx,
size_t buffer_index, const void *data,
size_t len) {
void *buffer_contents = [cx->buffers.data[buffer_index] contents];
// FIXME: actually check to see if this will fit in the buffer
memcpy(buffer_contents, data, len);
}
#endif
void gfx_run_events(gfx_context_t *cx) {
#if defined(__APPLE__)
return _metal_gfx_send_events(&cx->backend);
#else
#error "Unsupported graphics backend"
#endif
}
size_t gfx_push_texture_buffer(gfx_context_t *cx, uint32_t width,
uint32_t height, const void *data, size_t len) {
#if defined(__APPLE__)
return _metal_gfx_push_texture_buffer(&cx->backend, width, height, data, len);
#else
#error "Unsupported graphics backend"
#endif
}
size_t gfx_push_vertex_buffer(gfx_context_t *cx, const void *data, size_t len) {
#if defined(__APPLE__)
return _metal_gfx_push_vertex_buffer(&cx->backend, data, len);
#else
#error "Unsupported graphics backend"
#endif
}
size_t gfx_allocate_vertex_buffer(gfx_context_t *cx, size_t len) {
#if defined(__APPLE__)
return _metal_gfx_allocate_vertex_buffer(&cx->backend, len);
#else
#error "Unsupported graphics backend"
#endif
}
// FIXME: abstract different backends
void gfx_update_buffer(gfx_context_t *cx, size_t buffer_index, const void *data,
size_t len) {
#if defined(__APPLE__)
return _metal_gfx_update_buffer(&cx->backend, buffer_index, data, len);
#else
#error "Unsupported graphics backend"
#endif
}
void gfx_queue_char(gfx_context_t *cx, uint8_t character, float position[2]) {
if (character >= 32) {
GpuGlyph glyph = cx->glyph_cache.data[character - 32];
glyph.position[0] = position[0];
glyph.position[1] = position[1];
pushArray(GpuGlyph, &cx->gpu_glyphs, glyph);
}
}
void gfx_queue_text(gfx_context_t *cx, string text, float position[2]) {
float x = 0;
for (size_t i = 0; i < text.len; ++i) {
if (text.data[i] >= 32) {
GpuGlyph glyph = cx->glyph_cache.data[text.data[i] - 32];
glyph.position[0] = x + position[0];
glyph.position[1] = position[1];
x += glyph.size[0] / 2 + 4;
pushArray(GpuGlyph, &cx->gpu_glyphs, glyph);
}
}
}
void gfx_queue_ui_rect(gfx_context_t *cx, float position[2], float size[2],
float border_size, float color[4]) {
GpuUiRect rect =
(GpuUiRect){.position = {position[0], position[1]},
.size = {size[0], size[1]},
.border_size = {border_size, border_size},
.color = {color[0], color[1], color[2], color[3]}};
pushArray(GpuUiRect, &cx->gpu_ui_rects, rect);
}
void *gfx_init_context(_gfx_frame_func frame_func, uint32_t width,
uint32_t height) {
__auto_type backend =
#if defined(__APPLE__)
_metal_gfx_init_context(width, height);
#else
#error "Unsupported graphics backend"
#endif
_gfx_context.backend = backend;
_gfx_context.frame_func = frame_func;
_gfx_context.frame_width = width;
_gfx_context.frame_height = height;
_gfx_context.gpu_ui_rects = newArray(GpuUiRect, 2000);
_gfx_context.gpu_glyphs = newArray(GpuGlyph, 8192 * 32);
_gfx_context.glyph_cache = newArray(GpuGlyph, 97);
float vertices[] = {
// positions texture coords
-1.0f, 1.0f, 0.0f, 0.0f, 1.0f, 1.0f, 1.0f, 0.0f,
1.0f, -1.0f, 1.0f, 1.0f, -1.0f, -1.0f, 0.0f, 1.0f,
};
const uint16_t indices[] = {0, 1, 2, 0, 2, 3};
// NOTE: the order of these matter
gfx_push_vertex_buffer(&_gfx_context, vertices, sizeof(vertices));
gfx_push_vertex_buffer(&_gfx_context, indices, sizeof(indices));
gfx_allocate_vertex_buffer(&_gfx_context, _gfx_context.gpu_glyphs.capacity *
sizeof(GpuGlyph));
gfx_allocate_vertex_buffer(&_gfx_context, sizeof(GpuUniformParams));
gfx_allocate_vertex_buffer(&_gfx_context, _gfx_context.gpu_ui_rects.capacity *
sizeof(GpuUiRect));
return &_gfx_context;
}
#endif
#endif

126
src/ht.h Normal file
View File

@ -0,0 +1,126 @@
// A simple/fast(?) hash table.
#ifndef ED_HT_INCLUDED
#define ED_HT_INCLUDED
#include <stdlib.h>
#include <stddef.h>
#include <stdbool.h>
#include <stdint.h>
#include <string.h>
#include "string.h"
// see <https://en.wikipedia.org/wiki/Fowler–Noll–Vo_hash_function>
#define FNV_OFFSET 14695981039346656037ULL
#define FNV_PRIME 1099511628211ULL
typedef struct {
string key;
} ed_ht_slot;
typedef struct {
ed_ht_slot *key_slots;
void *value_slots;
size_t value_size;
size_t capacity;
} ed_ht;
typedef uint64_t ht_hash_t;
#ifdef ED_HT_IMPLEMENTATION
static ht_hash_t ht_hash(string key, uint64_t mod) {
ht_hash_t hash = FNV_OFFSET;
for (size_t i=0; i<key.len; ++i) {
hash *= FNV_PRIME;
hash ^= key.data[i];
}
return hash % mod;
}
ed_ht ht_create(size_t max_entries, size_t value_size) {
ed_ht_slot *key_slots = (ed_ht_slot *)malloc(max_entries * sizeof(ed_ht_slot));
void *value_slots = malloc(max_entries * value_size);
memset(key_slots, 0, max_entries * sizeof(ed_ht_slot));
memset(value_slots, 0, max_entries * value_size);
return (ed_ht) {
.key_slots = key_slots,
.value_slots = value_slots,
.value_size = value_size,
.capacity = max_entries,
};
}
bool ht_set(ed_ht *ht, string key, void *value) {
ht_hash_t hash = ht_hash(key, ht->capacity);
for (size_t i=hash; i<ht->capacity; ++i) {
if (ht->key_slots[i].key.data == NULL || string_eq(ht->key_slots[i].key, key)) {
if (ht->key_slots[i].key.data != NULL) {
free(ht->key_slots[i].key.data);
}
ht->key_slots[i].key = string_copy(key);
memcpy(ht->value_slots+i*ht->value_size, value, ht->value_size);
return true;
}
}
return false;
}
void *ht_get_slot(ed_ht *ht, size_t slot) {
void *value = ht->value_slots+slot*ht->value_size;
if (slot >= ht->capacity || !value)
return NULL;
return value;
}
void *ht_get(ed_ht *ht, string key) {
ht_hash_t hash = ht_hash(key, ht->capacity);
for (size_t i=hash; i<ht->capacity; ++i) {
if (ht->key_slots[i].key.data == NULL) {
return NULL;
}
if (string_eq(ht->key_slots[i].key, key)) {
return ht_get_slot(ht, i);
}
}
return NULL;
}
void ht_remove(ed_ht *ht, string key) {
ht_hash_t hash = ht_hash(key, ht->capacity);
for (size_t i=hash; i<ht->capacity; ++i) {
if (ht->key_slots[i].key.data == NULL) {
return;
}
if (string_eq(ht->key_slots[i].key, key)) {
ht->key_slots[i] = (ed_ht_slot) { 0 };
}
}
}
void ht_destroy(ed_ht *ht) {
// TODO: destroy the hash table
free(ht->key_slots);
free(ht->value_slots);
ht->key_slots = NULL;
ht->value_slots = NULL;
}
#endif
#endif

155
src/main.c Normal file
View File

@ -0,0 +1,155 @@
#include <inttypes.h>
#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#define STB_TRUETYPE_IMPLEMENTATION
#include <stb/std_truetype.h>
#define ED_GFX_IMPLEMENTATION
#define ED_STRING_IMPLEMENTATION
#define ED_HT_IMPLEMENTATION
#define ED_UI_IMPLEMENTATION
#define ED_BUFFER_IMPLEMENTATION
#define ED_FILE_IO_IMPLEMENTATION
#include "ed_array.h"
#include "file_io.h"
#include "gfx.h"
#include "ht.h"
#include "string.h"
#include "ui.h"
// static Arena default_arena = {0};
// static Arena temporary_arena = {0};
// static Arena *context_arena = &default_arena;
void *context_alloc(size_t size) {
// assert(context_arena);
// return arena_alloc(context_arena, size);
return malloc(size);
}
static struct {
bool should_exit;
ui_context ui_cx;
gfx_context_t *gfx_cx;
} state;
void ed_init(_gfx_frame_func frame_func) {
state.gfx_cx = gfx_init_context(frame_func, 640, 480);
state.ui_cx = ui_init_context();
// TODO: grab default font from the system
uint8_t ttf_buffer[1 << 20];
assert("failed to load font" &&
load_file(_String("./bin/JetBrainsMono-Medium.ttf"), 1 << 20,
ttf_buffer));
stbtt_fontinfo font;
stbtt_InitFont(&font, ttf_buffer, stbtt_GetFontOffsetForIndex(ttf_buffer, 0));
const int font_bitmap_size = 512;
const int rasterized_font_height = _FONT_HEIGHT;
uint8_t *font_bitmap =
context_alloc(font_bitmap_size * font_bitmap_size * sizeof(uint8_t));
int ascent, descent, line_gap;
float scale = stbtt_ScaleForPixelHeight(&font, rasterized_font_height * 2);
stbtt_GetFontVMetrics(&font, &ascent, &descent, &line_gap);
for (size_t xx = 0; xx < rasterized_font_height / 2; ++xx) {
for (size_t yy = 0; yy < rasterized_font_height; ++yy) {
font_bitmap[xx + yy * font_bitmap_size] = 0;
}
}
// manually add glyph for SPACE
pushArray(GpuGlyph, &state.gfx_cx->glyph_cache,
((GpuGlyph){
.atlas_position = {0},
.size = {rasterized_font_height / 4, 1},
.position = {0},
.y_offset = -rasterized_font_height,
}));
int x = rasterized_font_height / 4;
int y = 0;
for (size_t i = 33; i < 33 + 96; ++i) {
int width, height, xoff, yoff;
uint8_t *bitmap = stbtt_GetCodepointBitmap(&font, scale, scale, (int)i,
&width, &height, &xoff, &yoff);
if (x + width >= font_bitmap_size) {
x = 0;
y += (int)((float)(ascent - descent + line_gap) * scale);
}
size_t xxx = x;
for (size_t xx = 0; xx < (size_t)width; ++xx) {
size_t yyy = y;
for (size_t yy = 0; yy < (size_t)height; ++yy) {
font_bitmap[xxx + yyy * font_bitmap_size] = bitmap[xx + yy * width];
yyy += 1;
}
xxx += 1;
}
pushArray(GpuGlyph, &state.gfx_cx->glyph_cache,
((GpuGlyph){
.atlas_position = {(float)(x), (float)(y)},
.size = {(float)width, (float)height},
.position = {(float)x, (float)y},
.y_offset = (float)(yoff),
}));
x += width;
}
gfx_push_texture_buffer(
state.gfx_cx, font_bitmap_size, font_bitmap_size, font_bitmap,
font_bitmap_size * font_bitmap_size * sizeof(uint8_t));
}
void render_ui_text(string text, float position[2]) {
gfx_queue_text(state.gfx_cx, text, position);
}
void render_ui_rect(float position[2], float size[2], float color[4]) {
gfx_queue_ui_rect(state.gfx_cx, position, size, 0, color);
}
void ed_frame() {
state.ui_cx.frame_elements.data[0].size.computed_size[0] =
state.gfx_cx->frame_width;
state.ui_cx.frame_elements.data[0].size.computed_size[1] =
state.gfx_cx->frame_height;
ui_element(&state.ui_cx, _String("channel sidebar"), UI_AXIS_VERTICAL,
ui_make_size(ui_children_sum, ui_fill), UI_FLAG_DRAW_BACKGROUND);
ui_push_parent(&state.ui_cx);
{
ui_element(&state.ui_cx, _String("#dev-general"), UI_AXIS_HORIZONTAL,
ui_make_size(ui_fit_text, ui_fit_text),
UI_FLAG_DRAW_BACKGROUND | UI_FLAG_DRAW_TEXT);
ui_element(&state.ui_cx, _String("#dev-help"), UI_AXIS_HORIZONTAL,
ui_make_size(ui_fit_text, ui_fit_text),
UI_FLAG_DRAW_BACKGROUND | UI_FLAG_DRAW_TEXT);
}
ui_pop_parent(&state.ui_cx);
ui_compute_layout(&state.ui_cx, 0);
ui_render(&state.ui_cx, render_ui_text, render_ui_rect);
ui_update_cache(&state.ui_cx, 0);
ui_prune(&state.ui_cx);
}
int main(int argc, char *argv[]) {
ed_init(ed_frame);
while (keep_running) {
gfx_run_events(state.gfx_cx);
}
}

42
src/string.h Normal file
View File

@ -0,0 +1,42 @@
#ifndef ED_STRING_INCLUDED
#define ED_STRING_INCLUDED
#include <stdlib.h>
#include <stddef.h>
#include <stdint.h>
#include <stdbool.h>
#define _String(text) ((string) { .data = (uint8_t*) text, .len = sizeof(text), .owned = false })
typedef struct {
uint8_t *data;
size_t len;
bool owned;
} string;
#ifdef ED_STRING_IMPLEMENTATION
bool string_eq(string a, string b) {
if (a.len != b.len) return false;
for (size_t i=0; i<a.len; ++i) {
if (a.data[i] != b.data[i]) return false;
}
return true;
}
string string_copy(string a) {
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;
}
#endif
#endif

507
src/ui.h Normal file
View File

@ -0,0 +1,507 @@
// A naive implementation of an immediate mode gui.
#ifndef ED_UI_INCLUDED
#define ED_UI_INCLUDED
#define MAX_UI_ELEMENTS 8192
// TODO: replace this with functions
#define _FONT_WIDTH 12
#define _FONT_HEIGHT 24
#define _elm(index) (cx->frame_elements.data + index)
#define _flags(index, flgs) ((_elm(index)->flags & (flgs)) == (flgs))
#define _first(index) (_elm(index)->first)
#define _last(index) (_elm(index)->last)
#define _next(index) (_elm(index)->next)
#define _prev(index) (_elm(index)->prev)
#define _parent(index) (_elm(index)->parent)
#define _first_ref(index) (_elm(_first(index)))
#define _last_ref(index) (_elm(_last(index)))
#define _next_ref(index) (_elm(_next(index)))
#define _prev_ref(index) (_elm(_prev(index)))
#define _parent_ref(index) (_elm(_parent(index)))
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
#include <stdio.h>
#include "ed_array.h"
#include "ht.h"
typedef enum {
UI_AXIS_HORIZONTAL,
UI_AXIS_VERTICAL,
} ui_axis;
typedef enum {
UI_SEMANTIC_SIZE_FIT_TEXT,
UI_SEMANTIC_SIZE_CHILDREN_SUM,
UI_SEMANTIC_SIZE_FILL,
UI_SEMANTIC_SIZE_EXACT,
UI_SEMANTIC_SIZE_PERCENT_OF_PARENT,
} ui_semantic_size_t;
typedef struct {
ui_semantic_size_t type;
union {
uint32_t integer;
};
} ui_semantic_size;
#define ui_make_size(horizontal, vertical) \
((ui_semantic_size[2]){horizontal, vertical})
#define ui_fit_text ((ui_semantic_size){.type = UI_SEMANTIC_SIZE_FIT_TEXT})
#define ui_fill ((ui_semantic_size){.type = UI_SEMANTIC_SIZE_FILL})
#define ui_children_sum \
((ui_semantic_size){.type = UI_SEMANTIC_SIZE_CHILDREN_SUM})
#define ui_exact(value) \
((ui_semantic_size){.type = UI_SEMANTIC_SIZE_EXACT, .integer = value})
typedef struct {
ui_axis axis;
ui_semantic_size semantic_size[2];
uint32_t computed_size[2];
uint32_t computed_pos[2];
} ui_size;
// UI Element data persisted across frames
typedef struct {
string label;
ui_size size;
size_t last_instantiated_index;
} ui_element_cache_data;
typedef enum {
UI_FLAG_CLICKABLE = 0b000000001,
UI_FLAG_HOVERABLE = 0b000000010,
UI_FLAG_SCROLLABLE = 0b000000100,
UI_FLAG_DRAW_TEXT = 0b000001000,
UI_FLAG_DRAW_BORDER = 0b000010000,
UI_FLAG_DRAW_BACKGROUND = 0b000100000,
UI_FLAG_ROUNDED_BORDER = 0b001000000,
UI_FLAG_FLOATING = 0b010000000,
UI_FLAG_CUSTOM_DRAW_FUNC = 0b100000000,
} ui_flags;
// Ephemeral frame only UI Element data
typedef struct {
size_t index;
string key;
string label;
ui_size size;
ui_flags flags;
// optional types
size_t first;
size_t last;
size_t next;
size_t prev;
size_t parent;
} ui_element_frame_data;
arrayTemplate(ui_element_frame_data);
typedef struct {
ed_ht cached_elements;
array(ui_element_frame_data) frame_elements;
array(ui_element_frame_data) frame_floating_elements;
size_t frame_index;
uint32_t canvas_size[2];
size_t current_parent;
} ui_context;
void ui_compute_layout(ui_context *cx, size_t element_index);
#ifdef ED_UI_IMPLEMENTATION
ui_context ui_init_context() {
ed_ht cached_elements =
ht_create(MAX_UI_ELEMENTS, sizeof(ui_element_cache_data));
array(ui_element_frame_data) frame_elements =
newArray(ui_element_frame_data, MAX_UI_ELEMENTS);
array(ui_element_frame_data) frame_floating_elements =
newArray(ui_element_frame_data, MAX_UI_ELEMENTS);
ui_element_frame_data frame_data = (ui_element_frame_data){
.index = 0,
// TODO: don't just set this to label, because then elements
// with the same label can't be created together
.key = _String("root"),
.label = _String("root"),
.first = -1,
.last = -1,
.next = -1,
.prev = -1,
.parent = -1,
.size = {
.axis = UI_AXIS_HORIZONTAL,
.computed_size = {640, 480},
}};
pushArray(ui_element_frame_data, &frame_elements, frame_data);
return (ui_context){
.cached_elements = cached_elements,
.frame_elements = frame_elements,
.frame_floating_elements = frame_floating_elements,
.frame_index = 0,
};
}
void ui_push_parent(ui_context *cx) {
if (cx->frame_elements.size > 0) {
cx->current_parent = cx->frame_elements.size - 1;
}
}
void ui_pop_parent(ui_context *cx) {
if (_parent(cx->current_parent) < SIZE_MAX) {
cx->current_parent = _parent(cx->current_parent);
}
}
size_t ui_element(ui_context *cx, string label, ui_axis axis,
ui_semantic_size size[2], ui_flags flags) {
ui_element_frame_data frame_data = (ui_element_frame_data){
.index = cx->frame_elements.size,
// TODO: don't just set this to label, because then elements
// with the same label can't be created together
.key = label,
.label = label,
.first = -1,
.last = -1,
.next = -1,
.prev = cx->frame_elements.data[cx->current_parent].last,
.parent = cx->current_parent,
.size.axis = axis,
.size.semantic_size[0] = size[0],
.size.semantic_size[1] = size[1],
.flags = flags,
};
// Get cached element data
ui_element_cache_data *cache_data = ht_get(&cx->cached_elements, label);
if (cache_data) {
cache_data->last_instantiated_index = cx->frame_index;
frame_data.size.computed_pos[0] = cache_data->size.computed_pos[0];
frame_data.size.computed_pos[1] = cache_data->size.computed_pos[1];
frame_data.size.computed_size[0] = cache_data->size.computed_size[0];
frame_data.size.computed_size[1] = cache_data->size.computed_size[1];
} else {
bool did_insert = ht_set(&cx->cached_elements, label,
&(ui_element_cache_data){
.label = label,
.size = {0},
.last_instantiated_index = cx->frame_index,
});
assert("couldn't insert into ui element cache" && did_insert);
}
pushArray(ui_element_frame_data, &cx->frame_elements, frame_data);
if (frame_data.prev < SIZE_MAX) {
_prev_ref(frame_data.index)->next = frame_data.index;
}
if (_elm(cx->current_parent)->first == SIZE_MAX) {
_elm(cx->current_parent)->first = frame_data.index;
}
_elm(cx->current_parent)->last = frame_data.index;
return frame_data.index;
}
static uint32_t _ui_ancestor_size(ui_context *cx, size_t element_index,
ui_axis axis) {
if (element_index == SIZE_MAX || _parent(element_index) == SIZE_MAX) {
return cx->frame_elements.data[0].size.computed_size[axis];
}
switch (_parent_ref(element_index)->size.semantic_size[axis].type) {
case UI_SEMANTIC_SIZE_FIT_TEXT:
case UI_SEMANTIC_SIZE_FILL:
case UI_SEMANTIC_SIZE_EXACT:
case UI_SEMANTIC_SIZE_PERCENT_OF_PARENT:
return _parent_ref(element_index)->size.computed_size[axis];
break;
case UI_SEMANTIC_SIZE_CHILDREN_SUM:
return _ui_ancestor_size(cx, _parent(element_index), axis);
break;
}
}
static void _ui_compute_simple_layout(ui_context *cx,
ui_element_frame_data *elm, ui_axis axis,
bool *post_compute) {
switch (elm->size.semantic_size[axis].type) {
case UI_SEMANTIC_SIZE_FIT_TEXT:
if (axis == UI_AXIS_HORIZONTAL) {
elm->size.computed_size[axis] = elm->label.len * _FONT_WIDTH;
} else if (axis == UI_AXIS_VERTICAL) {
elm->size.computed_size[axis] = _FONT_HEIGHT;
}
break;
case UI_SEMANTIC_SIZE_CHILDREN_SUM:
post_compute[axis] = true;
break;
case UI_SEMANTIC_SIZE_FILL:
// TODO: set to ancestor size for floating
break;
case UI_SEMANTIC_SIZE_EXACT:
elm->size.computed_size[axis] = elm->size.semantic_size[axis].integer;
break;
case UI_SEMANTIC_SIZE_PERCENT_OF_PARENT: {
float semantic_value = (float)elm->size.semantic_size[axis].integer;
elm->size.computed_size[axis] =
(uint32_t)((float)(_ui_ancestor_size(cx, elm->index, axis)) *
(semantic_value / 100.0));
} break;
}
}
static void _ui_compute_children_layout(ui_context *cx,
ui_element_frame_data *elm) {
uint32_t child_size[2] = {0, 0};
// NOTE: the number of fills for the opposite axis of this box needs to be 1
// because it will never get incremented in the loop below and cause a divide
// by zero and the number of fills for the axis of the box needs to start at
// zero or else it will be n+1 causing incorrect sizes
uint32_t num_fills[2] = {1, 1};
num_fills[elm->size.axis] = 0;
// TODO: maybe just use the actual data instead of copying?
uint32_t elm_size[2] = {elm->size.computed_size[0],
elm->size.computed_size[1]};
size_t child_index = elm->first;
if (child_index < SIZE_MAX) {
do {
ui_compute_layout(cx, child_index);
if (_elm(child_index)->size.semantic_size[elm->size.axis].type ==
UI_SEMANTIC_SIZE_FILL) {
num_fills[elm->size.axis] += 1;
} else {
child_size[elm->size.axis] +=
_elm(child_index)->size.computed_size[elm->size.axis];
}
} while ((child_index = _next(child_index)) < SIZE_MAX);
}
child_index = elm->first;
if (child_index < SIZE_MAX) {
do {
for (size_t axis = 0; axis < 2; ++axis) {
if (_elm(child_index)->size.semantic_size[axis].type ==
UI_SEMANTIC_SIZE_FILL) {
_elm(child_index)->size.computed_size[axis] =
(elm_size[axis] - child_size[axis]) / num_fills[axis];
}
}
ui_compute_layout(cx, child_index);
} while ((child_index = _next(child_index)) < SIZE_MAX);
}
}
void ui_compute_layout(ui_context *cx, size_t element_index) {
if (element_index == SIZE_MAX)
return;
ui_axis axis = UI_AXIS_HORIZONTAL;
__auto_type elm = _elm(element_index);
if (_parent(element_index) < SIZE_MAX &&
!_flags(element_index, UI_FLAG_FLOATING)) {
__auto_type parent = _parent_ref(element_index);
axis = parent->size.axis;
elm->size.computed_pos[0] = parent->size.computed_pos[0];
elm->size.computed_pos[1] = parent->size.computed_pos[1];
// TODO: implement scrolling
// elm->size.computed_pos[axis] += parent.scroll_offset;
}
if (!_flags(element_index, UI_FLAG_FLOATING) &&
_prev(element_index) < SIZE_MAX) {
__auto_type prev = _prev_ref(element_index);
if (prev >= 0) {
elm->size.computed_pos[axis] =
prev->size.computed_pos[axis] + prev->size.computed_size[axis];
}
}
bool post_compute[2] = {false, false};
// only compute layout for children of root
if (elm->index > 0) {
for (int i = 0; i < 2; ++i) {
_ui_compute_simple_layout(cx, elm, i, post_compute);
}
}
_ui_compute_children_layout(cx, elm);
// NOTE(pcleavelin): the only difference between these two blocks is the
// ordering of the switch block they can probably be merged
if (post_compute[UI_AXIS_HORIZONTAL]) {
elm->size.computed_size[UI_AXIS_HORIZONTAL] = 0;
size_t child_index = elm->first;
if (child_index < SIZE_MAX) {
do {
__auto_type child = _elm(child_index);
switch (elm->size.axis) {
case UI_AXIS_HORIZONTAL:
elm->size.computed_size[UI_AXIS_HORIZONTAL] +=
child->size.computed_size[UI_AXIS_HORIZONTAL];
break;
case UI_AXIS_VERTICAL:
if (child->size.computed_size[UI_AXIS_HORIZONTAL] >
elm->size.computed_size[UI_AXIS_HORIZONTAL]) {
elm->size.computed_size[UI_AXIS_HORIZONTAL] =
child->size.computed_size[UI_AXIS_HORIZONTAL];
}
break;
}
} while ((child_index = _next(child_index)) < SIZE_MAX);
}
}
if (post_compute[UI_AXIS_VERTICAL]) {
elm->size.computed_size[UI_AXIS_VERTICAL] = 0;
size_t child_index = elm->first;
if (child_index < SIZE_MAX) {
do {
__auto_type child = _elm(child_index);
switch (elm->size.axis) {
case UI_AXIS_HORIZONTAL:
if (child->size.computed_size[UI_AXIS_VERTICAL] >
elm->size.computed_size[UI_AXIS_VERTICAL]) {
elm->size.computed_size[UI_AXIS_VERTICAL] =
child->size.computed_size[UI_AXIS_VERTICAL];
}
break;
case UI_AXIS_VERTICAL:
elm->size.computed_size[UI_AXIS_VERTICAL] +=
child->size.computed_size[UI_AXIS_VERTICAL];
break;
}
} while ((child_index = _next(child_index)) < SIZE_MAX);
}
}
}
void ui_update_cache(ui_context *cx, size_t element_index) {
if (element_index == SIZE_MAX)
return;
size_t child_index = _elm(element_index)->first;
if (child_index < SIZE_MAX) {
do {
__auto_type child = _elm(child_index);
size_t last_instantiated_index = cx->frame_index;
ui_element_cache_data *cache;
if ((cache = ht_get(&cx->cached_elements, child->key))) {
last_instantiated_index = cache->last_instantiated_index;
}
ht_set(&cx->cached_elements, child->key,
&(ui_element_cache_data){
.label = child->label,
.size =
{
.axis = child->size.axis,
.semantic_size = {child->size.semantic_size[0],
child->size.semantic_size[1]},
.computed_size = {child->size.computed_size[0],
child->size.computed_size[1]},
.computed_pos = {child->size.computed_pos[0],
child->size.computed_pos[1]},
},
.last_instantiated_index = last_instantiated_index,
});
ui_update_cache(cx, child_index);
} while ((child_index = _next(child_index)) < SIZE_MAX);
}
}
typedef void (*_ui_render_text_func)(string text, float position[2]);
typedef void (*_ui_render_rect_func)(float position[2], float size[2],
float color[4]);
void ui_render(ui_context *cx, _ui_render_text_func text_func,
_ui_render_rect_func rect_func) {
for (size_t i = 1; i < cx->frame_elements.size; ++i) {
string text = cx->frame_elements.data[i].key;
ui_element_frame_data *elm = &cx->frame_elements.data[i];
if (_flags(i, UI_FLAG_DRAW_TEXT)) {
text_func(text, (float[]){(float)elm->size.computed_pos[0],
(float)elm->size.computed_pos[1]});
}
if (_flags(i, UI_FLAG_DRAW_BACKGROUND)) {
rect_func((float[]){(float)elm->size.computed_pos[0],
(float)elm->size.computed_pos[1]},
(float[]){(float)elm->size.computed_size[0],
(float)elm->size.computed_size[1]},
(float[]){1, 1, 1, 0.2});
}
}
}
void ui_prune(ui_context *cx) {
for (size_t i = 0; i < cx->cached_elements.capacity; ++i) {
if (cx->cached_elements.key_slots[i].key.data != NULL) {
string key = cx->cached_elements.key_slots[i].key;
// if this element hasn't been created in the past 5 frames, remove it
ui_element_cache_data *cached = ht_get(&cx->cached_elements, key);
if (cached && cached->last_instantiated_index < cx->frame_index - 5) {
// fprintf(stderr, "removing %.*s from cache, cache index: %zu, frame
// index: %zu\n", (int)key.len, key.data,
// cached->last_instantiated_index, cx->frame_index);
ht_remove(&cx->cached_elements, key);
}
}
}
size_t child_index = _elm(0)->first;
do {
__auto_type elm = _elm(child_index);
if (elm->label.owned) {
free(elm->label.data);
}
} while ((child_index = _next(child_index)) < SIZE_MAX);
cx->frame_index += 1;
cx->frame_elements.size = 1;
cx->frame_elements.data[0].first = SIZE_MAX;
cx->frame_elements.data[0].prev = SIZE_MAX;
cx->frame_elements.data[0].next = SIZE_MAX;
cx->frame_elements.data[0].last = SIZE_MAX;
cx->frame_elements.data[0].parent = SIZE_MAX;
cx->current_parent = 0;
}
#endif
#endif

5077
vendor/stb/std_truetype.h vendored Normal file
View File

File diff suppressed because it is too large Load Diff

237
vendor/tsoding/arena.h vendored Normal file
View File

@ -0,0 +1,237 @@
// Copyright 2022 Alexey Kutepov <reximkut@gmail.com>
// Permission is hereby granted, free of charge, to any person obtaining
// a copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to
// permit persons to whom the Software is furnished to do so, subject to
// the following conditions:
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
#ifndef ARENA_H_
#define ARENA_H_
#include <stddef.h>
#include <stdint.h>
#ifndef ARENA_ASSERT
#include <assert.h>
#define ARENA_ASSERT assert
#endif
#define ARENA_BACKEND_LIBC_MALLOC 0
#define ARENA_BACKEND_LINUX_MMAP 1
#define ARENA_BACKEND_WIN32_VIRTUALALLOC 2
#define ARENA_BACKEND_WASM_HEAPBASE 3
#ifndef ARENA_BACKEND
#define ARENA_BACKEND ARENA_BACKEND_LIBC_MALLOC
#endif // ARENA_BACKEND
typedef struct Region Region;
struct Region {
Region *next;
size_t count;
size_t capacity;
uintptr_t data[];
};
typedef struct {
Region *begin, *end;
} Arena;
#define REGION_DEFAULT_CAPACITY (8*1024)
Region *new_region(size_t capacity);
void free_region(Region *r);
// TODO: snapshot/rewind capability for the arena
// - Snapshot should be combination of a->end and a->end->count.
// - Rewinding should be restoring a->end and a->end->count from the snapshot and
// setting count-s of all the Region-s after the remembered a->end to 0.
void *arena_alloc(Arena *a, size_t size_bytes);
void *arena_realloc(Arena *a, void *oldptr, size_t oldsz, size_t newsz);
void arena_reset(Arena *a);
void arena_free(Arena *a);
#endif // ARENA_H_
#ifdef ARENA_IMPLEMENTATION
#if ARENA_BACKEND == ARENA_BACKEND_LIBC_MALLOC
#include <stdlib.h>
// TODO: instead of accepting specific capacity new_region() should accept the size of the object we want to fit into the region
// It should be up to new_region() to decide the actual capacity to allocate
Region *new_region(size_t capacity)
{
size_t size_bytes = sizeof(Region) + sizeof(uintptr_t)*capacity;
// TODO: it would be nice if we could guarantee that the regions are allocated by ARENA_BACKEND_LIBC_MALLOC are page aligned
Region *r = malloc(size_bytes);
ARENA_ASSERT(r);
r->next = NULL;
r->count = 0;
r->capacity = capacity;
return r;
}
void free_region(Region *r)
{
free(r);
}
#elif ARENA_BACKEND == ARENA_BACKEND_LINUX_MMAP
#include <unistd.h>
#include <sys/mman.h>
Region *new_region(size_t capacity)
{
size_t size_bytes = sizeof(Region) + sizeof(uintptr_t) * capacity;
Region *r = mmap(NULL, size_bytes, PROT_READ | PROT_WRITE, MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
ARENA_ASSERT(r != MAP_FAILED);
r->next = NULL;
r->count = 0;
r->capacity = capacity;
return r;
}
void free_region(Region *r)
{
size_t size_bytes = sizeof(Region) + sizeof(uintptr_t) * r->capacity;
int ret = munmap(r, size_bytes);
ARENA_ASSERT(ret == 0);
}
#elif ARENA_BACKEND == ARENA_BACKEND_WIN32_VIRTUALALLOC
#if !defined(_WIN32)
# error "Current platform is not Windows"
#endif
#define WIN32_LEAN_AND_MEAN
#include <windows.h>
#define INV_HANDLE(x) (((x) == NULL) || ((x) == INVALID_HANDLE_VALUE))
Region *new_region(size_t capacity)
{
SIZE_T size_bytes = sizeof(Region) + sizeof(uintptr_t) * capacity;
Region *r = VirtualAllocEx(
GetCurrentProcess(), /* Allocate in current process address space */
NULL, /* Unknown position */
size_bytes, /* Bytes to allocate */
MEM_COMMIT | MEM_RESERVE, /* Reserve and commit allocated page */
PAGE_READWRITE /* Permissions ( Read/Write )*/
);
if (INV_HANDLE(r))
ARENA_ASSERT(0 && "VirtualAllocEx() failed.");
r->next = NULL;
r->count = 0;
r->capacity = capacity;
return r;
}
void free_region(Region *r)
{
if (INV_HANDLE(r))
return;
BOOL free_result = VirtualFreeEx(
GetCurrentProcess(), /* Deallocate from current process address space */
(LPVOID)r, /* Address to deallocate */
0, /* Bytes to deallocate ( Unknown, deallocate entire page ) */
MEM_RELEASE /* Release the page ( And implicitly decommit it ) */
);
if (FALSE == free_result)
ARENA_ASSERT(0 && "VirtualFreeEx() failed.");
}
#elif ARENA_BACKEND == ARENA_BACKEND_WASM_HEAPBASE
# error "TODO: WASM __heap_base backend is not implemented yet"
#else
# error "Unknown Arena backend"
#endif
// TODO: add debug statistic collection mode for arena
// Should collect things like:
// - How many times new_region was called
// - How many times existing region was skipped
// - How many times allocation exceeded REGION_DEFAULT_CAPACITY
void *arena_alloc(Arena *a, size_t size_bytes)
{
size_t size = (size_bytes + sizeof(uintptr_t) - 1)/sizeof(uintptr_t);
if (a->end == NULL) {
ARENA_ASSERT(a->begin == NULL);
size_t capacity = REGION_DEFAULT_CAPACITY;
if (capacity < size) capacity = size;
a->end = new_region(capacity);
a->begin = a->end;
}
while (a->end->count + size > a->end->capacity && a->end->next != NULL) {
a->end = a->end->next;
}
if (a->end->count + size > a->end->capacity) {
ARENA_ASSERT(a->end->next == NULL);
size_t capacity = REGION_DEFAULT_CAPACITY;
if (capacity < size) capacity = size;
a->end->next = new_region(capacity);
a->end = a->end->next;
}
void *result = &a->end->data[a->end->count];
a->end->count += size;
return result;
}
void *arena_realloc(Arena *a, void *oldptr, size_t oldsz, size_t newsz)
{
if (newsz <= oldsz) return oldptr;
void *newptr = arena_alloc(a, newsz);
char *newptr_char = newptr;
char *oldptr_char = oldptr;
for (size_t i = 0; i < oldsz; ++i) {
newptr_char[i] = oldptr_char[i];
}
return newptr;
}
void arena_reset(Arena *a)
{
for (Region *r = a->begin; r != NULL; r = r->next) {
r->count = 0;
}
a->end = a->begin;
}
void arena_free(Arena *a)
{
Region *r = a->begin;
while (r) {
Region *r0 = r;
r = r->next;
free_region(r0);
}
a->begin = NULL;
a->end = NULL;
}
#endif // ARENA_IMPLEMENTATION