Baseline: Ludic compiler + toolchain, Phase 1 syntax fixes complete
Self-hosted compiler (selfhost/*.ludic), runtime, examples, editor tooling, and docs. Phase 1 of the syntax-redesign cohesion pass has landed: edge-system fix, signature-query, when-alias, and the documentation truth-pass. Suite green (14/14), C-free bootstrap fixpoint holds. Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
This commit is contained in:
commit
985f9ad8f2
418 changed files with 39065 additions and 0 deletions
327
runtime/native/cocoa.ll
Normal file
327
runtime/native/cocoa.ll
Normal file
|
|
@ -0,0 +1,327 @@
|
|||
; ============================================================================
|
||||
; cocoa.ll — the macOS window, written in LLVM IR.
|
||||
;
|
||||
; This is what replaced plat_cocoa.m. There is no Objective-C source and no C
|
||||
; source in a Ludic build: the window is opened by talking to the Objective-C
|
||||
; runtime through its C ABI (objc_getClass / sel_registerName / objc_msgSend)
|
||||
; and to Quartz through CoreGraphics, exactly as a compiled .m file would, only
|
||||
; written at the level ludicc itself emits. ludicc splices this module in when
|
||||
; it links a windowed macOS binary.
|
||||
;
|
||||
; The one piece that genuinely needs a class is the view: AppKit paints through
|
||||
; -drawRect:, so a class is built at runtime with objc_allocateClassPair and
|
||||
; @ludic_drawRect is installed as its IMP. On arm64 the unused NSRect argument
|
||||
; simply stays in registers we never read, so the IMP needs no struct in its
|
||||
; signature.
|
||||
;
|
||||
; Exposed to Ludic (through the win_* intrinsics):
|
||||
; win_open(w, h, scale, title) win_poll() -> key win_present(fb, w, h)
|
||||
; win_running() -> bool win_close()
|
||||
; ============================================================================
|
||||
|
||||
%CGRect = type { double, double, double, double }
|
||||
|
||||
declare ptr @objc_getClass(ptr)
|
||||
declare ptr @sel_registerName(ptr)
|
||||
declare ptr @objc_msgSend(ptr, ptr, ...)
|
||||
declare ptr @objc_allocateClassPair(ptr, ptr, i64)
|
||||
declare void @objc_registerClassPair(ptr)
|
||||
declare i8 @class_addMethod(ptr, ptr, ptr, ptr)
|
||||
declare ptr @CGColorSpaceCreateDeviceRGB()
|
||||
declare ptr @CGBitmapContextCreate(ptr, i64, i64, i64, i64, ptr, i32)
|
||||
declare ptr @CGBitmapContextCreateImage(ptr)
|
||||
declare void @CGContextDrawImage(ptr, %CGRect, ptr)
|
||||
declare void @CGContextSetInterpolationQuality(ptr, i32)
|
||||
declare void @CGContextTranslateCTM(ptr, double, double)
|
||||
declare void @CGContextScaleCTM(ptr, double, double)
|
||||
declare void @CGContextSaveGState(ptr)
|
||||
declare void @CGContextRestoreGState(ptr)
|
||||
declare void @CGImageRelease(ptr)
|
||||
declare void @CGContextRelease(ptr)
|
||||
declare void @CGColorSpaceRelease(ptr)
|
||||
declare i32 @usleep(i32)
|
||||
|
||||
@.c_app = private unnamed_addr constant [14 x i8] c"NSApplication\00"
|
||||
@.c_win = private unnamed_addr constant [9 x i8] c"NSWindow\00"
|
||||
@.c_str = private unnamed_addr constant [9 x i8] c"NSString\00"
|
||||
@.c_date = private unnamed_addr constant [7 x i8] c"NSDate\00"
|
||||
@.c_view = private unnamed_addr constant [7 x i8] c"NSView\00"
|
||||
@.c_gctx = private unnamed_addr constant [18 x i8] c"NSGraphicsContext\00"
|
||||
@.c_ludic = private unnamed_addr constant [10 x i8] c"LudicView\00"
|
||||
|
||||
@.s_shared = private unnamed_addr constant [18 x i8] c"sharedApplication\00"
|
||||
@.s_policy = private unnamed_addr constant [21 x i8] c"setActivationPolicy:\00"
|
||||
@.s_alloc = private unnamed_addr constant [6 x i8] c"alloc\00"
|
||||
@.s_initw = private unnamed_addr constant [45 x i8] c"initWithContentRect:styleMask:backing:defer:\00"
|
||||
@.s_initf = private unnamed_addr constant [15 x i8] c"initWithFrame:\00"
|
||||
@.s_title = private unnamed_addr constant [10 x i8] c"setTitle:\00"
|
||||
@.s_utf8 = private unnamed_addr constant [22 x i8] c"stringWithUTF8String:\00"
|
||||
@.s_setcv = private unnamed_addr constant [16 x i8] c"setContentView:\00"
|
||||
@.s_center = private unnamed_addr constant [7 x i8] c"center\00"
|
||||
@.s_mkey = private unnamed_addr constant [22 x i8] c"makeKeyAndOrderFront:\00"
|
||||
@.s_mfirst = private unnamed_addr constant [20 x i8] c"makeFirstResponder:\00"
|
||||
@.s_act = private unnamed_addr constant [27 x i8] c"activateIgnoringOtherApps:\00"
|
||||
@.s_next = private unnamed_addr constant [48 x i8] c"nextEventMatchingMask:untilDate:inMode:dequeue:\00"
|
||||
@.s_send = private unnamed_addr constant [11 x i8] c"sendEvent:\00"
|
||||
@.s_dpast = private unnamed_addr constant [12 x i8] c"distantPast\00"
|
||||
@.s_type = private unnamed_addr constant [5 x i8] c"type\00"
|
||||
@.s_keycd = private unnamed_addr constant [8 x i8] c"keyCode\00"
|
||||
@.s_chars = private unnamed_addr constant [28 x i8] c"charactersIgnoringModifiers\00"
|
||||
@.s_length = private unnamed_addr constant [7 x i8] c"length\00"
|
||||
@.s_charat = private unnamed_addr constant [18 x i8] c"characterAtIndex:\00"
|
||||
@.s_disp = private unnamed_addr constant [8 x i8] c"display\00"
|
||||
@.s_visib = private unnamed_addr constant [10 x i8] c"isVisible\00"
|
||||
@.s_curctx = private unnamed_addr constant [15 x i8] c"currentContext\00"
|
||||
@.s_cgctx = private unnamed_addr constant [10 x i8] c"CGContext\00"
|
||||
@.s_drawr = private unnamed_addr constant [10 x i8] c"drawRect:\00"
|
||||
@.s_afr = private unnamed_addr constant [23 x i8] c"acceptsFirstResponder\00\00"
|
||||
@.mode = private unnamed_addr constant [22 x i8] c"kCFRunLoopDefaultMode\00"
|
||||
@.enc_draw = private unnamed_addr constant [36 x i8] c"v@:{CGRect={CGPoint=dd}{CGSize=dd}}\00"
|
||||
@.enc_bool = private unnamed_addr constant [4 x i8] c"c@:\00"
|
||||
|
||||
@W_app = internal global ptr null
|
||||
@W_win = internal global ptr null
|
||||
@W_view = internal global ptr null
|
||||
@W_fb = internal global ptr null
|
||||
@W_fbw = internal global i32 320
|
||||
@W_fbh = internal global i32 240
|
||||
@W_scale = internal global i32 3
|
||||
@W_key = internal global i32 0
|
||||
@W_running = internal global i32 1
|
||||
|
||||
; -drawRect: — blit the framebuffer into the view.
|
||||
; The NSRect argument is ignored, so it never appears in this signature.
|
||||
define internal void @ludic_drawRect(ptr %self, ptr %sel) {
|
||||
entry:
|
||||
%fb = load ptr, ptr @W_fb
|
||||
%null = icmp eq ptr %fb, null
|
||||
br i1 %null, label %out, label %draw
|
||||
draw:
|
||||
%w32 = load i32, ptr @W_fbw
|
||||
%h32 = load i32, ptr @W_fbh
|
||||
%sc32 = load i32, ptr @W_scale
|
||||
%w = sext i32 %w32 to i64
|
||||
%h = sext i32 %h32 to i64
|
||||
%stride = mul i64 %w, 4
|
||||
|
||||
%cs = call ptr @CGColorSpaceCreateDeviceRGB()
|
||||
; kCGImageAlphaNoneSkipFirst (6) | kCGBitmapByteOrder32Little (8192)
|
||||
%bmp = call ptr @CGBitmapContextCreate(ptr %fb, i64 %w, i64 %h, i64 8, i64 %stride, ptr %cs, i32 8198)
|
||||
%img = call ptr @CGBitmapContextCreateImage(ptr %bmp)
|
||||
|
||||
%gcls = call ptr @objc_getClass(ptr @.c_gctx)
|
||||
%sel_cur = call ptr @sel_registerName(ptr @.s_curctx)
|
||||
%gctx = call ptr @objc_msgSend(ptr %gcls, ptr %sel_cur)
|
||||
%sel_cg = call ptr @sel_registerName(ptr @.s_cgctx)
|
||||
%ctx = call ptr @objc_msgSend(ptr %gctx, ptr %sel_cg)
|
||||
|
||||
call void @CGContextSetInterpolationQuality(ptr %ctx, i32 1) ; kCGInterpolationNone
|
||||
%scd = sitofp i32 %sc32 to double
|
||||
%wd = sitofp i32 %w32 to double
|
||||
%hd = sitofp i32 %h32 to double
|
||||
%dw = fmul double %wd, %scd
|
||||
%dh = fmul double %hd, %scd
|
||||
|
||||
; The framebuffer's row 0 is the top row, and a CGImage built over it carries
|
||||
; that orientation, so drawing it into the view's context lands right-side-up
|
||||
; with no CTM flip. (Adding one here mirrors the game vertically — verified by
|
||||
; drawing four different corners and looking at the window.)
|
||||
%r0 = insertvalue %CGRect undef, double 0.0, 0
|
||||
%r1 = insertvalue %CGRect %r0, double 0.0, 1
|
||||
%r2 = insertvalue %CGRect %r1, double %dw, 2
|
||||
%r3 = insertvalue %CGRect %r2, double %dh, 3
|
||||
call void @CGContextDrawImage(ptr %ctx, %CGRect %r3, ptr %img)
|
||||
|
||||
call void @CGImageRelease(ptr %img)
|
||||
call void @CGContextRelease(ptr %bmp)
|
||||
call void @CGColorSpaceRelease(ptr %cs)
|
||||
br label %out
|
||||
out:
|
||||
ret void
|
||||
}
|
||||
|
||||
; -acceptsFirstResponder — so the view receives key events
|
||||
define internal i8 @ludic_yes(ptr %self, ptr %sel) {
|
||||
entry:
|
||||
ret i8 1
|
||||
}
|
||||
|
||||
define void @win_open(i32 %w, i32 %h, i32 %scale, ptr %title) {
|
||||
entry:
|
||||
store i32 %w, ptr @W_fbw
|
||||
store i32 %h, ptr @W_fbh
|
||||
store i32 %scale, ptr @W_scale
|
||||
|
||||
%appcls = call ptr @objc_getClass(ptr @.c_app)
|
||||
%sel_sh = call ptr @sel_registerName(ptr @.s_shared)
|
||||
%app = call ptr @objc_msgSend(ptr %appcls, ptr %sel_sh)
|
||||
store ptr %app, ptr @W_app
|
||||
%sel_pol = call ptr @sel_registerName(ptr @.s_policy)
|
||||
%a1 = call ptr (ptr, ptr, i64) @objc_msgSend(ptr %app, ptr %sel_pol, i64 0)
|
||||
|
||||
; build the view class once: NSView + drawRect: + acceptsFirstResponder
|
||||
%viewsuper = call ptr @objc_getClass(ptr @.c_view)
|
||||
%cls = call ptr @objc_allocateClassPair(ptr %viewsuper, ptr @.c_ludic, i64 0)
|
||||
%sel_draw = call ptr @sel_registerName(ptr @.s_drawr)
|
||||
%m1 = call i8 @class_addMethod(ptr %cls, ptr %sel_draw, ptr @ludic_drawRect, ptr @.enc_draw)
|
||||
%sel_afr = call ptr @sel_registerName(ptr @.s_afr)
|
||||
%m2 = call i8 @class_addMethod(ptr %cls, ptr %sel_afr, ptr @ludic_yes, ptr @.enc_bool)
|
||||
call void @objc_registerClassPair(ptr %cls)
|
||||
|
||||
%wd = sitofp i32 %w to double
|
||||
%hd = sitofp i32 %h to double
|
||||
%scd = sitofp i32 %scale to double
|
||||
%pw = fmul double %wd, %scd
|
||||
%ph = fmul double %hd, %scd
|
||||
%r0 = insertvalue %CGRect undef, double 0.0, 0
|
||||
%r1 = insertvalue %CGRect %r0, double 0.0, 1
|
||||
%r2 = insertvalue %CGRect %r1, double %pw, 2
|
||||
%rect = insertvalue %CGRect %r2, double %ph, 3
|
||||
|
||||
%wincls = call ptr @objc_getClass(ptr @.c_win)
|
||||
%sel_alloc = call ptr @sel_registerName(ptr @.s_alloc)
|
||||
%w0 = call ptr @objc_msgSend(ptr %wincls, ptr %sel_alloc)
|
||||
%sel_initw = call ptr @sel_registerName(ptr @.s_initw)
|
||||
; NSWindowStyleMaskTitled|Closable = 3, NSBackingStoreBuffered = 2
|
||||
%win = call ptr (ptr, ptr, %CGRect, i64, i64, i8) @objc_msgSend(ptr %w0, ptr %sel_initw, %CGRect %rect, i64 3, i64 2, i8 0)
|
||||
store ptr %win, ptr @W_win
|
||||
|
||||
%strcls = call ptr @objc_getClass(ptr @.c_str)
|
||||
%sel_utf8 = call ptr @sel_registerName(ptr @.s_utf8)
|
||||
%nstitle = call ptr (ptr, ptr, ptr) @objc_msgSend(ptr %strcls, ptr %sel_utf8, ptr %title)
|
||||
%sel_title = call ptr @sel_registerName(ptr @.s_title)
|
||||
%a2 = call ptr (ptr, ptr, ptr) @objc_msgSend(ptr %win, ptr %sel_title, ptr %nstitle)
|
||||
|
||||
%v0 = call ptr @objc_msgSend(ptr %cls, ptr %sel_alloc)
|
||||
%sel_initf = call ptr @sel_registerName(ptr @.s_initf)
|
||||
%view = call ptr (ptr, ptr, %CGRect) @objc_msgSend(ptr %v0, ptr %sel_initf, %CGRect %rect)
|
||||
store ptr %view, ptr @W_view
|
||||
%sel_setcv = call ptr @sel_registerName(ptr @.s_setcv)
|
||||
%a3 = call ptr (ptr, ptr, ptr) @objc_msgSend(ptr %win, ptr %sel_setcv, ptr %view)
|
||||
%sel_center = call ptr @sel_registerName(ptr @.s_center)
|
||||
%a4 = call ptr @objc_msgSend(ptr %win, ptr %sel_center)
|
||||
%sel_mkey = call ptr @sel_registerName(ptr @.s_mkey)
|
||||
%a5 = call ptr (ptr, ptr, ptr) @objc_msgSend(ptr %win, ptr %sel_mkey, ptr null)
|
||||
%sel_mfirst = call ptr @sel_registerName(ptr @.s_mfirst)
|
||||
%a6 = call ptr (ptr, ptr, ptr) @objc_msgSend(ptr %win, ptr %sel_mfirst, ptr %view)
|
||||
%sel_act = call ptr @sel_registerName(ptr @.s_act)
|
||||
%a7 = call ptr (ptr, ptr, i8) @objc_msgSend(ptr %app, ptr %sel_act, i8 1)
|
||||
ret void
|
||||
}
|
||||
|
||||
; Drain the event queue, remembering the last key pressed. Arrow keys map onto
|
||||
; WASD and escape onto 'q', matching what the C backend did.
|
||||
define i32 @win_poll() {
|
||||
entry:
|
||||
store i32 0, ptr @W_key
|
||||
%app = load ptr, ptr @W_app
|
||||
%none = icmp eq ptr %app, null
|
||||
br i1 %none, label %done, label %setup
|
||||
setup:
|
||||
%sel_next = call ptr @sel_registerName(ptr @.s_next)
|
||||
%sel_send = call ptr @sel_registerName(ptr @.s_send)
|
||||
%sel_dp = call ptr @sel_registerName(ptr @.s_dpast)
|
||||
%sel_type = call ptr @sel_registerName(ptr @.s_type)
|
||||
%sel_kc = call ptr @sel_registerName(ptr @.s_keycd)
|
||||
%sel_ch = call ptr @sel_registerName(ptr @.s_chars)
|
||||
%sel_len = call ptr @sel_registerName(ptr @.s_length)
|
||||
%sel_cat = call ptr @sel_registerName(ptr @.s_charat)
|
||||
%sel_utf8 = call ptr @sel_registerName(ptr @.s_utf8)
|
||||
%datecls = call ptr @objc_getClass(ptr @.c_date)
|
||||
%strcls = call ptr @objc_getClass(ptr @.c_str)
|
||||
%mode = call ptr (ptr, ptr, ptr) @objc_msgSend(ptr %strcls, ptr %sel_utf8, ptr @.mode)
|
||||
br label %pump
|
||||
pump:
|
||||
%date = call ptr @objc_msgSend(ptr %datecls, ptr %sel_dp)
|
||||
%ev = call ptr (ptr, ptr, i64, ptr, ptr, i8) @objc_msgSend(ptr %app, ptr %sel_next, i64 -1, ptr %date, ptr %mode, i8 1)
|
||||
%got = icmp ne ptr %ev, null
|
||||
br i1 %got, label %handle, label %finish
|
||||
handle:
|
||||
%ty = call i64 (ptr, ptr) @objc_msgSend(ptr %ev, ptr %sel_type)
|
||||
%iskey = icmp eq i64 %ty, 10 ; NSEventTypeKeyDown
|
||||
br i1 %iskey, label %key, label %forward
|
||||
key:
|
||||
%kc = call i16 (ptr, ptr) @objc_msgSend(ptr %ev, ptr %sel_kc)
|
||||
%kc32 = zext i16 %kc to i32
|
||||
switch i32 %kc32, label %fromchars [
|
||||
i32 126, label %k_w
|
||||
i32 125, label %k_s
|
||||
i32 123, label %k_a
|
||||
i32 124, label %k_d
|
||||
i32 49, label %k_space
|
||||
i32 36, label %k_ret
|
||||
i32 53, label %k_esc
|
||||
]
|
||||
k_w: store i32 119, ptr @W_key br label %forward
|
||||
k_s: store i32 115, ptr @W_key br label %forward
|
||||
k_a: store i32 97, ptr @W_key br label %forward
|
||||
k_d: store i32 100, ptr @W_key br label %forward
|
||||
k_space: store i32 32, ptr @W_key br label %forward
|
||||
k_ret: store i32 10, ptr @W_key br label %forward
|
||||
k_esc:
|
||||
store i32 113, ptr @W_key
|
||||
store i32 0, ptr @W_running
|
||||
br label %forward
|
||||
fromchars:
|
||||
%chars = call ptr (ptr, ptr) @objc_msgSend(ptr %ev, ptr %sel_ch)
|
||||
%clen = call i64 (ptr, ptr) @objc_msgSend(ptr %chars, ptr %sel_len)
|
||||
%hasch = icmp sgt i64 %clen, 0
|
||||
br i1 %hasch, label %takechar, label %forward
|
||||
takechar:
|
||||
%ch = call i16 (ptr, ptr, i64) @objc_msgSend(ptr %chars, ptr %sel_cat, i64 0)
|
||||
%ch32 = zext i16 %ch to i32
|
||||
store i32 %ch32, ptr @W_key
|
||||
%isq = icmp eq i32 %ch32, 113
|
||||
br i1 %isq, label %quit, label %forward
|
||||
quit:
|
||||
store i32 0, ptr @W_running
|
||||
br label %forward
|
||||
forward:
|
||||
%fwd = call ptr (ptr, ptr, ptr) @objc_msgSend(ptr %app, ptr %sel_send, ptr %ev)
|
||||
br label %pump
|
||||
finish:
|
||||
; a closed window ends the run
|
||||
%win = load ptr, ptr @W_win
|
||||
%hw = icmp ne ptr %win, null
|
||||
br i1 %hw, label %checkvis, label %done
|
||||
checkvis:
|
||||
%sel_vis = call ptr @sel_registerName(ptr @.s_visib)
|
||||
%vis = call i8 (ptr, ptr) @objc_msgSend(ptr %win, ptr %sel_vis)
|
||||
%gone = icmp eq i8 %vis, 0
|
||||
br i1 %gone, label %closed, label %done
|
||||
closed:
|
||||
store i32 0, ptr @W_running
|
||||
br label %done
|
||||
done:
|
||||
%k = load i32, ptr @W_key
|
||||
ret i32 %k
|
||||
}
|
||||
|
||||
define void @win_present(ptr %fb, i32 %w, i32 %h) {
|
||||
entry:
|
||||
store ptr %fb, ptr @W_fb
|
||||
store i32 %w, ptr @W_fbw
|
||||
store i32 %h, ptr @W_fbh
|
||||
%view = load ptr, ptr @W_view
|
||||
%none = icmp eq ptr %view, null
|
||||
br i1 %none, label %out, label %show
|
||||
show:
|
||||
%sel_disp = call ptr @sel_registerName(ptr @.s_disp)
|
||||
%d = call ptr @objc_msgSend(ptr %view, ptr %sel_disp)
|
||||
%u = call i32 @usleep(i32 16000) ; ~60 fps
|
||||
br label %out
|
||||
out:
|
||||
ret void
|
||||
}
|
||||
|
||||
define i32 @win_running() {
|
||||
entry:
|
||||
%r = load i32, ptr @W_running
|
||||
ret i32 %r
|
||||
}
|
||||
|
||||
define void @win_close() {
|
||||
entry:
|
||||
store i32 0, ptr @W_running
|
||||
ret void
|
||||
}
|
||||
394
runtime/native/core.ludic
Normal file
394
runtime/native/core.ludic
Normal file
|
|
@ -0,0 +1,394 @@
|
|||
# ============================================================================
|
||||
# runtime/native/core.ludic — the Ludic runtime, written in Ludic.
|
||||
#
|
||||
# This is what the native backend links instead of a C runtime. Everything a
|
||||
# game touches through a builtin — the framebuffer, rectangles, text, the
|
||||
# registers, the RNG, input, the frame dump — is implemented right here in
|
||||
# Ludic and compiled to machine code by ludicc like any other Ludic source.
|
||||
#
|
||||
# Underneath it there is exactly one layer, and it is not C: the compiler
|
||||
# intrinsics (mem_alloc, peek8/poke8, peek32/poke32, file_open/file_write,
|
||||
# read_byte, …) lower to direct calls into the platform's C ABI — malloc,
|
||||
# fwrite, getchar. That ABI is the operating system's interface, the same floor
|
||||
# Rust and Swift stand on. No C source is compiled at any point in the build.
|
||||
#
|
||||
# A builtin `clear(c)` in a game resolves to `rt_clear(c)` here; that is the
|
||||
# whole protocol. Swap this file and you have swapped the runtime.
|
||||
#
|
||||
# This file is a fragment: ludicc splices it into every native build. It is not
|
||||
# a `game`/`module` block of its own.
|
||||
# ============================================================================
|
||||
|
||||
# ---- state ----------------------------------------------------------------
|
||||
var rt_fb: ptr = ptr_null() # framebuffer, one i32 (0x00RRGGBB) per pixel
|
||||
var rt_fbw: int = 320
|
||||
var rt_fbh: int = 240
|
||||
var rt_regs: ptr = ptr_null() # the 64 general-purpose game registers
|
||||
var rt_rng: int = 305419896 # xorshift32 state
|
||||
var rt_alive: int = 1 # platform still running?
|
||||
|
||||
# 5x7 glyphs for ASCII 32..90, 7 rows per glyph, each row a 5-bit mask stored
|
||||
# biased by '0' so the whole font is one printable string literal.
|
||||
fn rt_font() -> str {
|
||||
return "00000004444404000000000000000000000IJ4:FC000000000000000000000000000000E>O>E0044O4400000448000O000000004012448@@>ACEIA>4<4444>>A168@ON11>11N26:BO22O@N11A>>@@NAA>O124888>AA>AA>>AA?11>04004000000000024842000O0O000842480>A164040000000>AAOAAANAANAAN>A@@@A>LBAAABLO@@L@@OO@@L@@@>A@GAA>AAAOAAA>44444>7222BB<ABDHDBA@@@@@@OAKEEAAAAIEECAA>AAAAA>NAAN@@@>AAAEB=NAANDBA>A@>1A>O444444AAAAAA>AAAAA:4AAAEEKAAA:4:AAAA:4444O1248@O"
|
||||
}
|
||||
|
||||
fn rt_init() -> void {
|
||||
rt_fb = mem_alloc(320 * 240 * 4)
|
||||
rt_regs = mem_alloc(64 * 4)
|
||||
mem_set(rt_regs, 0, 64 * 4)
|
||||
rt_map = mem_alloc(96 * 64)
|
||||
mem_set(rt_map, 32, 96 * 64)
|
||||
rt_statusbuf = mem_alloc(96)
|
||||
poke8(rt_statusbuf, 0, 0)
|
||||
rt_image_init()
|
||||
rt_tt_init()
|
||||
rt_ui_init()
|
||||
rt_clear(0)
|
||||
if is_windowed() {
|
||||
win_open(rt_fbw, rt_fbh, 3, game_title())
|
||||
}
|
||||
}
|
||||
|
||||
fn rt_shutdown() -> void {
|
||||
if is_windowed() {
|
||||
win_close()
|
||||
return
|
||||
}
|
||||
rt_dump_ppm("out.ppm")
|
||||
}
|
||||
|
||||
# ---- framebuffer ----------------------------------------------------------
|
||||
fn rt_clear(c: int) -> void {
|
||||
let n = rt_fbw * rt_fbh
|
||||
for i in 0 .. n {
|
||||
poke32(rt_fb, i, c)
|
||||
}
|
||||
}
|
||||
|
||||
fn rt_put_px(x: int, y: int, c: int) -> void {
|
||||
if x < 0 { return }
|
||||
if y < 0 { return }
|
||||
if x >= rt_fbw { return }
|
||||
if y >= rt_fbh { return }
|
||||
poke32(rt_fb, y * rt_fbw + x, c)
|
||||
}
|
||||
|
||||
fn rt_fill_rect(x: int, y: int, w: int, h: int, c: int) -> void {
|
||||
let x0 = max(0, x)
|
||||
let y0 = max(0, y)
|
||||
let x1 = min(rt_fbw, x + w)
|
||||
let y1 = min(rt_fbh, y + h)
|
||||
let j = y0
|
||||
while j < y1 {
|
||||
let row = j * rt_fbw
|
||||
let i = x0
|
||||
while i < x1 {
|
||||
poke32(rt_fb, row + i, c)
|
||||
i = i + 1
|
||||
}
|
||||
j = j + 1
|
||||
}
|
||||
}
|
||||
|
||||
fn rt_frame_rect(x: int, y: int, w: int, h: int, c: int) -> void {
|
||||
rt_fill_rect(x, y, w, 1, c)
|
||||
rt_fill_rect(x, y + h - 1, w, 1, c)
|
||||
rt_fill_rect(x, y, 1, h, c)
|
||||
rt_fill_rect(x + w - 1, y, 1, h, c)
|
||||
}
|
||||
|
||||
# Windowed: hand the framebuffer to the platform layer, which blits it into
|
||||
# the view. Headless: nothing to do until shutdown writes the last frame out.
|
||||
fn rt_present() -> void {
|
||||
if is_windowed() {
|
||||
win_present(rt_fb, rt_fbw, rt_fbh)
|
||||
}
|
||||
}
|
||||
|
||||
# ---- text -----------------------------------------------------------------
|
||||
fn rt_glyph(x: int, y: int, ch: int, colour: int, sc: int) -> void {
|
||||
let c = ch
|
||||
if c >= 97 {
|
||||
if c <= 122 { c = c - 32 }
|
||||
}
|
||||
if c < 32 { return }
|
||||
if c > 90 { return }
|
||||
let base = (c - 32) * 7
|
||||
let font = rt_font()
|
||||
for row in 0 .. 7 {
|
||||
let bits = peek8(font, base + row) - 48
|
||||
let b = bits
|
||||
for cc in 0 .. 5 {
|
||||
let on = b / 16
|
||||
if on == 1 {
|
||||
rt_fill_rect(x + cc * sc, y + row * sc, sc, sc, colour)
|
||||
}
|
||||
b = (b - on * 16) * 2
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn rt_text(x: int, y: int, s: str, colour: int, sc: int) -> void {
|
||||
let i = 0
|
||||
let cx = x
|
||||
let ch = peek8(s, 0)
|
||||
while ch != 0 {
|
||||
rt_glyph(cx, y, ch, colour, sc)
|
||||
cx = cx + 6 * sc
|
||||
i = i + 1
|
||||
ch = peek8(s, i)
|
||||
}
|
||||
}
|
||||
|
||||
fn rt_text_int(x: int, y: int, n: int, colour: int, sc: int) -> void {
|
||||
if n == 0 {
|
||||
rt_glyph(x, y, 48, colour, sc)
|
||||
return
|
||||
}
|
||||
let v = n
|
||||
let cx = x
|
||||
if v < 0 {
|
||||
rt_glyph(cx, y, 45, colour, sc)
|
||||
cx = cx + 6 * sc
|
||||
v = 0 - v
|
||||
}
|
||||
let digits = 0
|
||||
let t = v
|
||||
while t > 0 {
|
||||
digits = digits + 1
|
||||
t = t / 10
|
||||
}
|
||||
let p = digits
|
||||
while p > 0 {
|
||||
let div = 1
|
||||
for k in 1 .. p {
|
||||
div = div * 10
|
||||
}
|
||||
rt_glyph(cx, y, 48 + (v / div) % 10, colour, sc)
|
||||
cx = cx + 6 * sc
|
||||
p = p - 1
|
||||
}
|
||||
}
|
||||
|
||||
# ---- registers ------------------------------------------------------------
|
||||
fn rt_reg(i: int) -> int {
|
||||
if i < 0 { return 0 }
|
||||
if i >= 64 { return 0 }
|
||||
return peek32(rt_regs, i)
|
||||
}
|
||||
|
||||
fn rt_setreg(i: int, v: int) -> void {
|
||||
if i < 0 { return }
|
||||
if i >= 64 { return }
|
||||
poke32(rt_regs, i, v)
|
||||
}
|
||||
|
||||
# ---- rng (xorshift32) -----------------------------------------------------
|
||||
fn rt_seed(s: int) -> void {
|
||||
if s == 0 {
|
||||
rt_rng = 305419896
|
||||
return
|
||||
}
|
||||
rt_rng = s
|
||||
}
|
||||
|
||||
# xorshift32 (Marsaglia). Runs on the raw 32-bit pattern, so the sign bit is
|
||||
# masked off only when a caller asks for a number.
|
||||
fn rt_next_rand() -> int {
|
||||
let x = rt_rng
|
||||
x = bxor(x, shl(x, 13))
|
||||
x = bxor(x, shr(x, 17))
|
||||
x = bxor(x, shl(x, 5))
|
||||
rt_rng = x
|
||||
return band(x, 2147483647)
|
||||
}
|
||||
|
||||
fn rt_rng_range(lo: int, hi: int) -> int {
|
||||
if hi <= lo { return lo }
|
||||
return lo + rt_next_rand() % (hi - lo + 1)
|
||||
}
|
||||
|
||||
fn rt_rng_chance(pct: int) -> bool {
|
||||
return rt_next_rand() % 100 < pct
|
||||
}
|
||||
|
||||
# ---- platform: input ------------------------------------------------------
|
||||
fn rt_poll() -> int {
|
||||
if is_windowed() {
|
||||
return win_poll()
|
||||
}
|
||||
let c = read_byte()
|
||||
if c < 0 {
|
||||
rt_alive = 0
|
||||
return 0
|
||||
}
|
||||
if c == 113 { # 'q' quits, as in the headless C platform
|
||||
rt_alive = 0
|
||||
}
|
||||
return c
|
||||
}
|
||||
|
||||
fn rt_running() -> bool {
|
||||
if is_windowed() {
|
||||
return win_running()
|
||||
}
|
||||
return rt_alive
|
||||
}
|
||||
|
||||
# ---- writing the frame out ------------------------------------------------
|
||||
fn rt_put_str(buf: ptr, at: int, s: str) -> int {
|
||||
let i = 0
|
||||
let n = at
|
||||
let ch = peek8(s, 0)
|
||||
while ch != 0 {
|
||||
poke8(buf, n, ch)
|
||||
n = n + 1
|
||||
i = i + 1
|
||||
ch = peek8(s, i)
|
||||
}
|
||||
return n
|
||||
}
|
||||
|
||||
fn rt_put_int(buf: ptr, at: int, v: int) -> int {
|
||||
if v == 0 {
|
||||
poke8(buf, at, 48)
|
||||
return at + 1
|
||||
}
|
||||
let digits = 0
|
||||
let t = v
|
||||
while t > 0 {
|
||||
digits = digits + 1
|
||||
t = t / 10
|
||||
}
|
||||
let n = at
|
||||
let p = digits
|
||||
while p > 0 {
|
||||
let div = 1
|
||||
for k in 1 .. p {
|
||||
div = div * 10
|
||||
}
|
||||
poke8(buf, n, 48 + (v / div) % 10)
|
||||
n = n + 1
|
||||
p = p - 1
|
||||
}
|
||||
return n
|
||||
}
|
||||
|
||||
fn rt_dump_ppm(path: str) -> void {
|
||||
let f = file_open(path, "wb")
|
||||
if ptr_is_null(f) { return }
|
||||
|
||||
let hdr = mem_alloc(64)
|
||||
let n = rt_put_str(hdr, 0, "P6\n")
|
||||
n = rt_put_int(hdr, n, rt_fbw)
|
||||
n = rt_put_str(hdr, n, " ")
|
||||
n = rt_put_int(hdr, n, rt_fbh)
|
||||
n = rt_put_str(hdr, n, "\n255\n")
|
||||
file_write(f, hdr, n)
|
||||
|
||||
let px = rt_fbw * rt_fbh
|
||||
let buf = mem_alloc(px * 3)
|
||||
for i in 0 .. px {
|
||||
let c = peek32(rt_fb, i)
|
||||
poke8(buf, i * 3, (c / 65536) % 256)
|
||||
poke8(buf, i * 3 + 1, (c / 256) % 256)
|
||||
poke8(buf, i * 3 + 2, c % 256)
|
||||
}
|
||||
file_write(f, buf, px * 3)
|
||||
file_close(f)
|
||||
mem_free(buf)
|
||||
mem_free(hdr)
|
||||
}
|
||||
|
||||
import "inflate.ludic"
|
||||
import "image.ludic"
|
||||
import "truetype.ludic"
|
||||
import "ui.ludic"
|
||||
|
||||
# ---- tilemap --------------------------------------------------------------
|
||||
# A character grid the game paints with map_row() and reads with tile(). Stored
|
||||
# as one byte per cell in a flat buffer; out-of-bounds reads answer '#' so a
|
||||
# caller can treat the edge of the world as wall without special-casing it.
|
||||
var rt_map: ptr = ptr_null()
|
||||
var rt_mapw: int = 0
|
||||
var rt_maph: int = 0
|
||||
|
||||
fn rt_map_size(w: int, h: int) -> void {
|
||||
rt_mapw = clamp(w, 0, 96)
|
||||
rt_maph = clamp(h, 0, 64)
|
||||
mem_set(rt_map, 32, 96 * 64)
|
||||
}
|
||||
|
||||
fn rt_map_row(y: int, s: str) -> void {
|
||||
if y < 0 { return }
|
||||
if y >= 64 { return }
|
||||
let x = 0
|
||||
let ch = peek8(s, 0)
|
||||
while ch != 0 {
|
||||
if x >= 96 { return }
|
||||
poke8(rt_map, y * 96 + x, ch)
|
||||
x = x + 1
|
||||
ch = peek8(s, x)
|
||||
}
|
||||
}
|
||||
|
||||
fn rt_tile(x: int, y: int) -> int {
|
||||
if x < 0 { return 35 }
|
||||
if y < 0 { return 35 }
|
||||
if x >= rt_mapw { return 35 }
|
||||
if y >= rt_maph { return 35 }
|
||||
return peek8(rt_map, y * 96 + x)
|
||||
}
|
||||
|
||||
# ---- status line ----------------------------------------------------------
|
||||
# One persistent string of feedback/dialogue, copied into runtime-owned memory
|
||||
# so it survives whatever the caller does with the original.
|
||||
var rt_statusbuf: ptr = ptr_null()
|
||||
|
||||
fn rt_status(s: str) -> void {
|
||||
let i = 0
|
||||
let ch = peek8(s, 0)
|
||||
while ch != 0 {
|
||||
if i >= 95 { ch = 0 }
|
||||
if ch != 0 {
|
||||
poke8(rt_statusbuf, i, ch)
|
||||
i = i + 1
|
||||
ch = peek8(s, i)
|
||||
}
|
||||
}
|
||||
poke8(rt_statusbuf, i, 0)
|
||||
}
|
||||
|
||||
fn rt_status_text() -> ptr {
|
||||
return rt_statusbuf
|
||||
}
|
||||
|
||||
# ---- snapshot: the runtime serialises its own half ------------------------
|
||||
# The compiler writes the ECS (entities, components, archetype kinds) because
|
||||
# only it knows their shape. Everything below belongs to the runtime, so the
|
||||
# runtime writes it — same order both ways.
|
||||
fn rt_save_state(f: ptr) -> void {
|
||||
let w = mem_alloc(16)
|
||||
poke32(w, 0, rt_rng)
|
||||
poke32(w, 1, rt_mapw)
|
||||
poke32(w, 2, rt_maph)
|
||||
poke32(w, 3, rt_alive)
|
||||
file_write(f, w, 16)
|
||||
file_write(f, rt_regs, 64 * 4)
|
||||
file_write(f, rt_map, 96 * 64)
|
||||
file_write(f, rt_statusbuf, 96)
|
||||
mem_free(w)
|
||||
}
|
||||
|
||||
fn rt_load_state(f: ptr) -> void {
|
||||
let w = mem_alloc(16)
|
||||
file_read(f, w, 16)
|
||||
rt_rng = peek32(w, 0)
|
||||
rt_mapw = peek32(w, 1)
|
||||
rt_maph = peek32(w, 2)
|
||||
file_read(f, rt_regs, 64 * 4)
|
||||
file_read(f, rt_map, 96 * 64)
|
||||
file_read(f, rt_statusbuf, 96)
|
||||
mem_free(w)
|
||||
}
|
||||
436
runtime/native/image.ludic
Normal file
436
runtime/native/image.ludic
Normal file
|
|
@ -0,0 +1,436 @@
|
|||
# ============================================================================
|
||||
# image.ludic — PNG decoding, images and sprites, written in Ludic.
|
||||
#
|
||||
# Replaces the C runtime's image half. Reads a real .png off disk, inflates the
|
||||
# IDAT stream with the Ludic DEFLATE decoder next door, reverses the per-scanline
|
||||
# filters, and expands whatever colour type the file uses into 0xAARRGGBB.
|
||||
#
|
||||
# Supported: 8/4/2/1-bit greyscale, 8-bit truecolour, indexed with PLTE/tRNS,
|
||||
# greyscale+alpha and RGBA — the same set the C runtime handled.
|
||||
# ============================================================================
|
||||
|
||||
const IMG_MAX: int = 32
|
||||
const SPR_MAX: int = 160
|
||||
const SPR_SZ: int = 16
|
||||
|
||||
var img_px: ptr = ptr_null() # IMG_MAX pointers to RGBA buffers
|
||||
var img_w: ptr = ptr_null()
|
||||
var img_h: ptr = ptr_null()
|
||||
var img_n: int = 0
|
||||
|
||||
var spr_px: ptr = ptr_null() # SPR_MAX * 16 * 16 RGBA pixels, one block
|
||||
var spr_n: int = 0
|
||||
|
||||
fn rt_image_init() -> void {
|
||||
img_px = mem_alloc(IMG_MAX * 8)
|
||||
img_w = mem_alloc(IMG_MAX * 4)
|
||||
img_h = mem_alloc(IMG_MAX * 4)
|
||||
spr_px = mem_alloc(SPR_MAX * SPR_SZ * SPR_SZ * 4)
|
||||
mem_set(spr_px, 0, SPR_MAX * SPR_SZ * SPR_SZ * 4)
|
||||
}
|
||||
|
||||
# ---- decoding -------------------------------------------------------------
|
||||
fn png_be32(b: ptr, at: int) -> int {
|
||||
return bor(bor(shl(peek8(b, at), 24), shl(peek8(b, at + 1), 16)),
|
||||
bor(shl(peek8(b, at + 2), 8), peek8(b, at + 3)))
|
||||
}
|
||||
|
||||
fn png_tag(b: ptr, at: int, a: int, c: int, d: int, e: int) -> bool {
|
||||
if peek8(b, at) != a { return false }
|
||||
if peek8(b, at + 1) != c { return false }
|
||||
if peek8(b, at + 2) != d { return false }
|
||||
if peek8(b, at + 3) != e { return false }
|
||||
return true
|
||||
}
|
||||
|
||||
fn rt_read_file(path: str) -> ptr {
|
||||
let f = file_open(path, "rb")
|
||||
if ptr_is_null(f) { return ptr_null() }
|
||||
file_seek(f, 0, 2)
|
||||
let n = file_tell(f)
|
||||
file_seek(f, 0, 0)
|
||||
if n <= 0 { file_close(f) return ptr_null() }
|
||||
let buf = mem_alloc(n + 8)
|
||||
file_read(f, buf, n)
|
||||
file_close(f)
|
||||
rt_file_len = n
|
||||
return buf
|
||||
}
|
||||
var rt_file_len: int = 0
|
||||
|
||||
# decoded image is left in these; -1 width means failure
|
||||
var png_w: int = 0
|
||||
var png_h: int = 0
|
||||
var png_px: ptr = ptr_null()
|
||||
|
||||
fn rt_decode_png(path: str) -> bool {
|
||||
png_w = 0
|
||||
png_h = 0
|
||||
png_px = ptr_null()
|
||||
let d = rt_read_file(path)
|
||||
if ptr_is_null(d) { return false }
|
||||
let size = rt_file_len
|
||||
if size < 8 { mem_free(d) return false }
|
||||
if peek8(d, 0) != 137 { mem_free(d) return false }
|
||||
if peek8(d, 1) != 80 { mem_free(d) return false }
|
||||
|
||||
let w = 0
|
||||
let h = 0
|
||||
let bd = 0
|
||||
let ct = 0
|
||||
let plte = mem_alloc(768)
|
||||
let trns = mem_alloc(256)
|
||||
let ntrns = 0
|
||||
let idat = mem_alloc(size)
|
||||
let idlen = 0
|
||||
let i = 8
|
||||
let done = 0
|
||||
|
||||
while done == 0 {
|
||||
if i + 8 > size { done = 1 }
|
||||
if done == 0 {
|
||||
let ln = png_be32(d, i)
|
||||
let typ = i + 4
|
||||
let body = i + 8
|
||||
if ln < 0 { done = 1 }
|
||||
if body + ln > size { done = 1 }
|
||||
if done == 0 {
|
||||
if png_tag(d, typ, 73, 72, 68, 82) { # IHDR
|
||||
w = png_be32(d, body)
|
||||
h = png_be32(d, body + 4)
|
||||
bd = peek8(d, body + 8)
|
||||
ct = peek8(d, body + 9)
|
||||
}
|
||||
if png_tag(d, typ, 80, 76, 84, 69) { # PLTE
|
||||
let m = min(ln, 768)
|
||||
for k in 0 .. m { poke8(plte, k, peek8(d, body + k)) }
|
||||
}
|
||||
if png_tag(d, typ, 116, 82, 78, 83) { # tRNS
|
||||
ntrns = min(ln, 256)
|
||||
for k in 0 .. ntrns { poke8(trns, k, peek8(d, body + k)) }
|
||||
}
|
||||
if png_tag(d, typ, 73, 68, 65, 84) { # IDAT
|
||||
for k in 0 .. ln { poke8(idat, idlen + k, peek8(d, body + k)) }
|
||||
idlen = idlen + ln
|
||||
}
|
||||
if png_tag(d, typ, 73, 69, 78, 68) { done = 1 } # IEND
|
||||
i = i + 12 + ln
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if w <= 0 { mem_free(d) return false }
|
||||
if h <= 0 { mem_free(d) return false }
|
||||
|
||||
let channels = 1
|
||||
if ct == 2 { channels = 3 }
|
||||
if ct == 6 { channels = 4 }
|
||||
if ct == 4 { channels = 2 }
|
||||
let bppbits = bd * channels
|
||||
let fbpp = (bppbits + 7) / 8
|
||||
if fbpp < 1 { fbpp = 1 }
|
||||
let stride = (w * bppbits + 7) / 8
|
||||
let rawlen = h * (stride + 1)
|
||||
let raw = mem_alloc(rawlen + 8)
|
||||
if z_uncompress(idat, idlen, raw, rawlen) < 0 {
|
||||
mem_free(d) mem_free(raw) mem_free(idat)
|
||||
return false
|
||||
}
|
||||
|
||||
# reverse the per-scanline filters, in place
|
||||
for y in 0 .. h {
|
||||
let line = y * (stride + 1)
|
||||
let ft = peek8(raw, line)
|
||||
let cur = line + 1
|
||||
let prev = cur - (stride + 1)
|
||||
for x in 0 .. stride {
|
||||
let a = 0
|
||||
let b = 0
|
||||
let c = 0
|
||||
if x >= fbpp { a = peek8(raw, cur + x - fbpp) }
|
||||
if y > 0 { b = peek8(raw, prev + x) }
|
||||
if x >= fbpp { if y > 0 { c = peek8(raw, prev + x - fbpp) } }
|
||||
let v = peek8(raw, cur + x)
|
||||
if ft == 1 { v = v + a }
|
||||
if ft == 2 { v = v + b }
|
||||
if ft == 3 { v = v + (a + b) / 2 }
|
||||
if ft == 4 {
|
||||
let p = a + b - c
|
||||
let pa = abs(p - a)
|
||||
let pb = abs(p - b)
|
||||
let pc = abs(p - c)
|
||||
let pick = c
|
||||
if pb <= pc { pick = b }
|
||||
if pa <= pb { if pa <= pc { pick = a } }
|
||||
v = v + pick
|
||||
}
|
||||
poke8(raw, cur + x, band(v, 255))
|
||||
}
|
||||
}
|
||||
|
||||
# expand to 0xAARRGGBB
|
||||
let out = mem_alloc(w * h * 4)
|
||||
let maxv = shl(1, bd) - 1
|
||||
for y in 0 .. h {
|
||||
let row = y * (stride + 1) + 1
|
||||
for x in 0 .. w {
|
||||
let R = 0
|
||||
let G = 0
|
||||
let B = 0
|
||||
let A = 255
|
||||
if ct == 6 {
|
||||
R = peek8(raw, row + x * 4)
|
||||
G = peek8(raw, row + x * 4 + 1)
|
||||
B = peek8(raw, row + x * 4 + 2)
|
||||
A = peek8(raw, row + x * 4 + 3)
|
||||
}
|
||||
if ct == 2 {
|
||||
R = peek8(raw, row + x * 3)
|
||||
G = peek8(raw, row + x * 3 + 1)
|
||||
B = peek8(raw, row + x * 3 + 2)
|
||||
}
|
||||
if ct == 4 {
|
||||
R = peek8(raw, row + x * 2)
|
||||
G = R
|
||||
B = R
|
||||
A = peek8(raw, row + x * 2 + 1)
|
||||
}
|
||||
if ct == 3 {
|
||||
let bp = x * bd
|
||||
let idx = band(shr(peek8(raw, row + bp / 8), 8 - bd - bp % 8), maxv)
|
||||
R = peek8(plte, idx * 3)
|
||||
G = peek8(plte, idx * 3 + 1)
|
||||
B = peek8(plte, idx * 3 + 2)
|
||||
if idx < ntrns { A = peek8(trns, idx) }
|
||||
}
|
||||
if ct == 0 {
|
||||
let bp = x * bd
|
||||
let s = band(shr(peek8(raw, row + bp / 8), 8 - bd - bp % 8), maxv)
|
||||
let g = s
|
||||
if bd != 8 { g = s * 255 / maxv }
|
||||
R = g
|
||||
G = g
|
||||
B = g
|
||||
}
|
||||
poke32(out, y * w + x, bor(bor(shl(A, 24), shl(R, 16)), bor(shl(G, 8), B)))
|
||||
}
|
||||
}
|
||||
|
||||
mem_free(d)
|
||||
mem_free(idat)
|
||||
mem_free(raw)
|
||||
mem_free(plte)
|
||||
mem_free(trns)
|
||||
png_w = w
|
||||
png_h = h
|
||||
png_px = out
|
||||
return true
|
||||
}
|
||||
|
||||
# ---- images ---------------------------------------------------------------
|
||||
fn rt_image_load(path: str) -> int {
|
||||
if img_n >= IMG_MAX { return 0 - 1 }
|
||||
if rt_decode_png(path) == false { return 0 - 1 }
|
||||
let id = img_n
|
||||
img_n = img_n + 1
|
||||
pokep(img_px, id, png_px)
|
||||
poke32(img_w, id, png_w)
|
||||
poke32(img_h, id, png_h)
|
||||
return id
|
||||
}
|
||||
|
||||
fn rt_blend_px(x: int, y: int, argb: int) -> void {
|
||||
let a = band(shr(argb, 24), 255)
|
||||
if a == 0 { return }
|
||||
if x < 0 { return }
|
||||
if y < 0 { return }
|
||||
if x >= rt_fbw { return }
|
||||
if y >= rt_fbh { return }
|
||||
let r = band(shr(argb, 16), 255)
|
||||
let g = band(shr(argb, 8), 255)
|
||||
let b = band(argb, 255)
|
||||
if a != 255 {
|
||||
let dst = peek32(rt_fb, y * rt_fbw + x)
|
||||
let dr = band(shr(dst, 16), 255)
|
||||
let dg = band(shr(dst, 8), 255)
|
||||
let db = band(dst, 255)
|
||||
r = (r * a + dr * (255 - a)) / 255
|
||||
g = (g * a + dg * (255 - a)) / 255
|
||||
b = (b * a + db * (255 - a)) / 255
|
||||
}
|
||||
poke32(rt_fb, y * rt_fbw + x, bor(bor(shl(r, 16), shl(g, 8)), b))
|
||||
}
|
||||
|
||||
fn rt_draw_image(id: int, dx: int, dy: int) -> void {
|
||||
if id < 0 { return }
|
||||
if id >= img_n { return }
|
||||
let w = peek32(img_w, id)
|
||||
let h = peek32(img_h, id)
|
||||
let s = peekp(img_px, id)
|
||||
for y in 0 .. h {
|
||||
for x in 0 .. w {
|
||||
rt_blend_px(dx + x, dy + y, peek32(s, y * w + x))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn rt_draw_image_scaled(id: int, dx: int, dy: int, dw: int, dh: int) -> void {
|
||||
if id < 0 { return }
|
||||
if id >= img_n { return }
|
||||
if dw <= 0 { return }
|
||||
if dh <= 0 { return }
|
||||
let w = peek32(img_w, id)
|
||||
let h = peek32(img_h, id)
|
||||
let s = peekp(img_px, id)
|
||||
for y in 0 .. dh {
|
||||
for x in 0 .. dw {
|
||||
rt_blend_px(dx + x, dy + y, peek32(s, (y * h / dh) * w + x * w / dw))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
# map one destination axis onto the source for a 9-slice: the two insets are
|
||||
# copied 1:1 and only the middle stretches
|
||||
fn rt_9map(d: int, dsz: int, ssz: int, inset: int) -> int {
|
||||
if inset * 2 >= dsz { return d * ssz / max(dsz, 1) }
|
||||
if inset * 2 >= ssz { return d * ssz / max(dsz, 1) }
|
||||
if d < inset { return d }
|
||||
if d >= dsz - inset { return ssz - (dsz - d) }
|
||||
return inset + (d - inset) * (ssz - 2 * inset) / (dsz - 2 * inset)
|
||||
}
|
||||
|
||||
fn rt_draw_9slice(id: int, dx: int, dy: int, dw: int, dh: int, inset: int) -> void {
|
||||
if id < 0 { return }
|
||||
if id >= img_n { return }
|
||||
if dw <= 0 { return }
|
||||
if dh <= 0 { return }
|
||||
let w = peek32(img_w, id)
|
||||
let h = peek32(img_h, id)
|
||||
let s = peekp(img_px, id)
|
||||
for y in 0 .. dh {
|
||||
let sy = rt_9map(y, dh, h, inset)
|
||||
for x in 0 .. dw {
|
||||
rt_blend_px(dx + x, dy + y, peek32(s, sy * w + rt_9map(x, dw, w, inset)))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
# ---- sprites (16x16 art) --------------------------------------------------
|
||||
fn rt_load_png(path: str) -> int {
|
||||
if spr_n >= SPR_MAX { return 0 - 1 }
|
||||
if rt_decode_png(path) == false { return 0 - 1 }
|
||||
let id = spr_n
|
||||
spr_n = spr_n + 1
|
||||
let base = id * SPR_SZ * SPR_SZ
|
||||
for y in 0 .. SPR_SZ {
|
||||
for x in 0 .. SPR_SZ {
|
||||
let px = 0
|
||||
if x < png_w {
|
||||
if y < png_h {
|
||||
let c = peek32(png_px, y * png_w + x)
|
||||
if band(shr(c, 24), 255) >= 128 { px = bor(shl(255, 24), band(c, 16777215)) }
|
||||
}
|
||||
}
|
||||
poke32(spr_px, base + y * SPR_SZ + x, px)
|
||||
}
|
||||
}
|
||||
mem_free(png_px)
|
||||
png_px = ptr_null()
|
||||
return id
|
||||
}
|
||||
|
||||
fn rt_draw_sprite(id: int, px: int, py: int) -> void {
|
||||
if id < 0 { return }
|
||||
if id >= spr_n { return }
|
||||
let base = id * SPR_SZ * SPR_SZ
|
||||
for y in 0 .. SPR_SZ {
|
||||
for x in 0 .. SPR_SZ {
|
||||
let p = peek32(spr_px, base + y * SPR_SZ + x)
|
||||
if band(shr(p, 24), 255) != 0 {
|
||||
rt_put_px(px + x, py + y, band(p, 16777215))
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn rt_draw_sprite_scaled(id: int, px: int, py: int, sc: int) -> void {
|
||||
if id < 0 { return }
|
||||
if id >= spr_n { return }
|
||||
if sc < 1 { return }
|
||||
let base = id * SPR_SZ * SPR_SZ
|
||||
for y in 0 .. SPR_SZ {
|
||||
for x in 0 .. SPR_SZ {
|
||||
let p = peek32(spr_px, base + y * SPR_SZ + x)
|
||||
if band(shr(p, 24), 255) != 0 {
|
||||
rt_fill_rect(px + x * sc, py + y * sc, sc, sc, band(p, 16777215))
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
# ---- .lspr sprite sheets (palette + ASCII rows) ---------------------------
|
||||
fn rt_hexval(c: int) -> int {
|
||||
if c >= 48 { if c <= 57 { return c - 48 } }
|
||||
if c >= 97 { if c <= 102 { return c - 87 } }
|
||||
if c >= 65 { if c <= 70 { return c - 55 } }
|
||||
return 0 - 1
|
||||
}
|
||||
|
||||
fn rt_load_sprites(path: str) -> void {
|
||||
let d = rt_read_file(path)
|
||||
if ptr_is_null(d) { spr_n = 0 return }
|
||||
let size = rt_file_len
|
||||
let pal = mem_alloc(128 * 4)
|
||||
mem_set(pal, 0, 128 * 4)
|
||||
let cur = 0 - 1
|
||||
let row = 0
|
||||
let i = 0
|
||||
while i < size {
|
||||
let start = i
|
||||
let len = 0
|
||||
let j = start
|
||||
while j < size {
|
||||
let ch = peek8(d, j)
|
||||
if ch == 10 { j = size } else { len = len + 1 j = j + 1 }
|
||||
}
|
||||
let c0 = peek8(d, start)
|
||||
if c0 == 112 { # 'p' — "pal <char> <rrggbb>"
|
||||
let ch = peek8(d, start + 4)
|
||||
let v = 0
|
||||
for k in 0 .. 6 {
|
||||
let hv = rt_hexval(peek8(d, start + 6 + k))
|
||||
if hv >= 0 { v = v * 16 + hv }
|
||||
}
|
||||
if ch < 128 { poke32(pal, ch, bor(shl(255, 24), v)) }
|
||||
}
|
||||
if c0 == 115 { # 's' — "spr" starts a new sprite
|
||||
cur = 0 - 1
|
||||
if spr_n < SPR_MAX {
|
||||
cur = spr_n
|
||||
spr_n = spr_n + 1
|
||||
mem_set(ptr_add(spr_px, cur * SPR_SZ * SPR_SZ * 4), 0, SPR_SZ * SPR_SZ * 4)
|
||||
}
|
||||
row = 0
|
||||
}
|
||||
if c0 != 112 {
|
||||
if c0 != 115 {
|
||||
if c0 != 35 { # '#' comment
|
||||
if cur >= 0 {
|
||||
if row < SPR_SZ {
|
||||
for x in 0 .. SPR_SZ {
|
||||
if x < len {
|
||||
poke32(spr_px, cur * SPR_SZ * SPR_SZ + row * SPR_SZ + x,
|
||||
peek32(pal, band(peek8(d, start + x), 127)))
|
||||
}
|
||||
}
|
||||
row = row + 1
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
i = start + len + 1
|
||||
}
|
||||
mem_free(pal)
|
||||
mem_free(d)
|
||||
}
|
||||
276
runtime/native/inflate.ludic
Normal file
276
runtime/native/inflate.ludic
Normal file
|
|
@ -0,0 +1,276 @@
|
|||
# ============================================================================
|
||||
# inflate.ludic — DEFLATE decompression (RFC 1951), written in Ludic.
|
||||
#
|
||||
# PNG stores its pixels zlib-compressed, so decoding one means implementing
|
||||
# inflate. The C runtime linked zlib for this. We don't: zlib is not present by
|
||||
# default on every target Ludic compiles for (Windows especially), and shipping
|
||||
# a dependency to read a sprite is a poor trade when the algorithm is this
|
||||
# small. So it lives here, in the language.
|
||||
#
|
||||
# The decoder is the canonical-Huffman formulation from Mark Adler's `puff`:
|
||||
# a symbol table plus per-length counts, walked one bit at a time. Slower than
|
||||
# a lookup-table decoder, and entirely fast enough to load sprites at startup.
|
||||
# ============================================================================
|
||||
|
||||
# ---- bit reader (DEFLATE packs bits least-significant-first) ---------------
|
||||
var z_src: ptr = ptr_null()
|
||||
var z_len: int = 0
|
||||
var z_pos: int = 0
|
||||
var z_bitbuf: int = 0
|
||||
var z_bitcnt: int = 0
|
||||
var z_err: int = 0
|
||||
|
||||
fn z_start(src: ptr, len: int) -> void {
|
||||
z_src = src
|
||||
z_len = len
|
||||
z_pos = 0
|
||||
z_bitbuf = 0
|
||||
z_bitcnt = 0
|
||||
z_err = 0
|
||||
}
|
||||
|
||||
fn z_bits(need: int) -> int {
|
||||
let val = z_bitbuf
|
||||
while z_bitcnt < need {
|
||||
if z_pos >= z_len {
|
||||
z_err = 1
|
||||
return 0
|
||||
}
|
||||
val = bor(val, shl(peek8(z_src, z_pos), z_bitcnt))
|
||||
z_pos = z_pos + 1
|
||||
z_bitcnt = z_bitcnt + 8
|
||||
}
|
||||
z_bitbuf = shr(val, need)
|
||||
z_bitcnt = z_bitcnt - need
|
||||
return band(val, shl(1, need) - 1)
|
||||
}
|
||||
|
||||
# ---- Huffman tables -------------------------------------------------------
|
||||
# A table is a single buffer: 16 length-counts followed by the symbols in
|
||||
# canonical order. One allocation, no structs.
|
||||
fn z_table_new(nsym: int) -> ptr {
|
||||
return mem_alloc((16 + nsym) * 4)
|
||||
}
|
||||
|
||||
# lengths[i] = code length of symbol i (0 = symbol unused)
|
||||
fn z_table_build(table: ptr, lengths: ptr, n: int) -> void {
|
||||
for i in 0 .. 16 {
|
||||
poke32(table, i, 0)
|
||||
}
|
||||
for s in 0 .. n {
|
||||
let l = peek32(lengths, s)
|
||||
poke32(table, l, peek32(table, l) + 1)
|
||||
}
|
||||
poke32(table, 0, 0) # length 0 means "not present"
|
||||
# offset of each length's first symbol
|
||||
let offs = mem_alloc(16 * 4)
|
||||
poke32(offs, 1, 0)
|
||||
for l in 1 .. 15 {
|
||||
poke32(offs, l + 1, peek32(offs, l) + peek32(table, l))
|
||||
}
|
||||
for s in 0 .. n {
|
||||
let l = peek32(lengths, s)
|
||||
if l != 0 {
|
||||
poke32(table, 16 + peek32(offs, l), s)
|
||||
poke32(offs, l, peek32(offs, l) + 1)
|
||||
}
|
||||
}
|
||||
mem_free(offs)
|
||||
}
|
||||
|
||||
fn z_decode(table: ptr) -> int {
|
||||
let code = 0
|
||||
let first = 0
|
||||
let index = 0
|
||||
for len in 1 .. 16 {
|
||||
code = bor(code, z_bits(1))
|
||||
let count = peek32(table, len)
|
||||
if code - first < count {
|
||||
return peek32(table, 16 + index + (code - first))
|
||||
}
|
||||
index = index + count
|
||||
first = shl(first + count, 1)
|
||||
code = shl(code, 1)
|
||||
}
|
||||
z_err = 1
|
||||
return -1
|
||||
}
|
||||
|
||||
# ---- length / distance code tables (RFC 1951 section 3.2.5) ---------------
|
||||
fn z_len_base(sym: int) -> int {
|
||||
if sym < 8 { return 3 + sym }
|
||||
if sym == 28 { return 258 }
|
||||
let extra = (sym - 4) / 4
|
||||
let group = shl(1, extra)
|
||||
return 3 + shl(group - 1, 2) + 4 + (sym - 4 - extra * 4) * group
|
||||
}
|
||||
|
||||
fn z_len_extra(sym: int) -> int {
|
||||
if sym < 8 { return 0 }
|
||||
if sym == 28 { return 0 }
|
||||
return (sym - 4) / 4
|
||||
}
|
||||
|
||||
fn z_dist_base(sym: int) -> int {
|
||||
if sym < 4 { return 1 + sym }
|
||||
let extra = (sym - 2) / 2
|
||||
let group = shl(1, extra)
|
||||
return 1 + shl(group, 1) + (sym - 2 - extra * 2) * group
|
||||
}
|
||||
|
||||
fn z_dist_extra(sym: int) -> int {
|
||||
if sym < 4 { return 0 }
|
||||
return (sym - 2) / 2
|
||||
}
|
||||
|
||||
# ---- block decoders -------------------------------------------------------
|
||||
# `out` is the destination window; returns the new write position, or -1.
|
||||
fn z_stored(out: ptr, at: int, cap: int) -> int {
|
||||
z_bitbuf = 0
|
||||
z_bitcnt = 0 # stored blocks are byte-aligned
|
||||
if z_pos + 4 > z_len { return -1 }
|
||||
let n = peek8(z_src, z_pos) + shl(peek8(z_src, z_pos + 1), 8)
|
||||
z_pos = z_pos + 4 # LEN then its one's complement
|
||||
let w = at
|
||||
for i in 0 .. n {
|
||||
if z_pos >= z_len { return -1 }
|
||||
if w >= cap { return -1 }
|
||||
poke8(out, w, peek8(z_src, z_pos))
|
||||
w = w + 1
|
||||
z_pos = z_pos + 1
|
||||
}
|
||||
return w
|
||||
}
|
||||
|
||||
fn z_codes(out: ptr, at: int, cap: int, lit: ptr, dist: ptr) -> int {
|
||||
let w = at
|
||||
let sym = z_decode(lit)
|
||||
while sym != 256 {
|
||||
if z_err != 0 { return -1 }
|
||||
if sym < 0 { return -1 }
|
||||
if sym < 256 {
|
||||
if w >= cap { return -1 }
|
||||
poke8(out, w, sym)
|
||||
w = w + 1
|
||||
}
|
||||
if sym > 256 {
|
||||
let s = sym - 257
|
||||
if s >= 29 { return -1 }
|
||||
let length = z_len_base(s) + z_bits(z_len_extra(s))
|
||||
let d = z_decode(dist)
|
||||
if d < 0 { return -1 }
|
||||
let distance = z_dist_base(d) + z_bits(z_dist_extra(d))
|
||||
if distance > w { return -1 }
|
||||
for k in 0 .. length {
|
||||
if w >= cap { return -1 }
|
||||
poke8(out, w, peek8(out, w - distance))
|
||||
w = w + 1
|
||||
}
|
||||
}
|
||||
sym = z_decode(lit)
|
||||
}
|
||||
return w
|
||||
}
|
||||
|
||||
fn z_fixed_tables(lit: ptr, dist: ptr) -> void {
|
||||
let lengths = mem_alloc(288 * 4)
|
||||
for i in 0 .. 144 { poke32(lengths, i, 8) }
|
||||
for i in 144 .. 256 { poke32(lengths, i, 9) }
|
||||
for i in 256 .. 280 { poke32(lengths, i, 7) }
|
||||
for i in 280 .. 288 { poke32(lengths, i, 8) }
|
||||
z_table_build(lit, lengths, 288)
|
||||
for i in 0 .. 30 { poke32(lengths, i, 5) }
|
||||
z_table_build(dist, lengths, 30)
|
||||
mem_free(lengths)
|
||||
}
|
||||
|
||||
fn z_dynamic_tables(lit: ptr, dist: ptr) -> int {
|
||||
let nlen = z_bits(5) + 257
|
||||
let ndist = z_bits(5) + 1
|
||||
let ncode = z_bits(4) + 4
|
||||
if nlen > 286 { return 0 }
|
||||
if ndist > 30 { return 0 }
|
||||
|
||||
let lengths = mem_alloc(320 * 4)
|
||||
for i in 0 .. 19 { poke32(lengths, i, 0) }
|
||||
# the code-length alphabet is transmitted in this fixed permutation
|
||||
# 16,17,18,0,8,7,9,6,10,5,11,4,12,3,13,2,14,1,15 — biased by '0' so it is one literal
|
||||
let order = "@AB08796:5;4<3=2>1?"
|
||||
for i in 0 .. ncode {
|
||||
poke32(lengths, peek8(order, i) - 48, z_bits(3))
|
||||
}
|
||||
let clen = z_table_new(19)
|
||||
z_table_build(clen, lengths, 19)
|
||||
|
||||
let n = 0
|
||||
while n < nlen + ndist {
|
||||
let sym = z_decode(clen)
|
||||
if sym < 0 { return 0 }
|
||||
if sym < 16 {
|
||||
poke32(lengths, n, sym)
|
||||
n = n + 1
|
||||
}
|
||||
if sym >= 16 {
|
||||
let prev = 0
|
||||
let rep = 0
|
||||
if sym == 16 {
|
||||
if n == 0 { return 0 }
|
||||
prev = peek32(lengths, n - 1)
|
||||
rep = 3 + z_bits(2)
|
||||
}
|
||||
if sym == 17 { rep = 3 + z_bits(3) }
|
||||
if sym == 18 { rep = 11 + z_bits(7) }
|
||||
for k in 0 .. rep {
|
||||
if n < 320 {
|
||||
poke32(lengths, n, prev)
|
||||
n = n + 1
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
z_table_build(lit, lengths, nlen)
|
||||
# the distance lengths follow the literal ones in the same buffer
|
||||
let dl = mem_alloc(32 * 4)
|
||||
for i in 0 .. ndist { poke32(dl, i, peek32(lengths, nlen + i)) }
|
||||
z_table_build(dist, dl, ndist)
|
||||
mem_free(dl)
|
||||
mem_free(lengths)
|
||||
mem_free(clen)
|
||||
return 1
|
||||
}
|
||||
|
||||
# Inflate a raw DEFLATE stream. Returns bytes written, or -1.
|
||||
fn z_inflate(src: ptr, len: int, out: ptr, cap: int) -> int {
|
||||
z_start(src, len)
|
||||
let lit = z_table_new(288)
|
||||
let dist = z_table_new(30)
|
||||
let w = 0
|
||||
let final = 0
|
||||
while final == 0 {
|
||||
final = z_bits(1)
|
||||
let btype = z_bits(2)
|
||||
if z_err != 0 { return -1 }
|
||||
if btype == 0 { w = z_stored(out, w, cap) }
|
||||
if btype == 1 {
|
||||
z_fixed_tables(lit, dist)
|
||||
w = z_codes(out, w, cap, lit, dist)
|
||||
}
|
||||
if btype == 2 {
|
||||
if z_dynamic_tables(lit, dist) == 0 { return -1 }
|
||||
w = z_codes(out, w, cap, lit, dist)
|
||||
}
|
||||
if btype == 3 { return -1 }
|
||||
if w < 0 { return -1 }
|
||||
}
|
||||
mem_free(lit)
|
||||
mem_free(dist)
|
||||
return w
|
||||
}
|
||||
|
||||
# zlib wrapper (RFC 1950): two header bytes, then DEFLATE, then Adler-32.
|
||||
fn z_uncompress(src: ptr, len: int, out: ptr, cap: int) -> int {
|
||||
if len < 2 { return -1 }
|
||||
let cmf = peek8(src, 0)
|
||||
if band(cmf, 15) != 8 { return -1 }
|
||||
return z_inflate(ptr_add(src, 2), len - 2, out, cap)
|
||||
}
|
||||
428
runtime/native/truetype.ludic
Normal file
428
runtime/native/truetype.ludic
Normal file
|
|
@ -0,0 +1,428 @@
|
|||
# ============================================================================
|
||||
# truetype.ludic — a TrueType font loader and glyph rasterizer, in Ludic.
|
||||
#
|
||||
# Parses the sfnt container, maps codepoints through cmap (formats 0/4/6/12),
|
||||
# decodes simple and composite `glyf` outlines, flattens the quadratic Béziers,
|
||||
# and fills them with the nonzero winding rule at 4x4 supersampling to get an
|
||||
# 8-bit coverage mask. Then a glyph cache and a UTF-8 text layer on top.
|
||||
#
|
||||
# The C original used floats. Ludic has Q16.16 `fixed`, which is enough: at 16
|
||||
# fractional bits a glyph coordinate is exact to 1/65536 of a pixel, far below
|
||||
# the 1/4-pixel supersample grid the rasterizer actually quantises to.
|
||||
# ============================================================================
|
||||
|
||||
const TT_MAX: int = 8 # fonts loaded at once
|
||||
const TT_SS: int = 4 # supersample factor per axis
|
||||
const TT_PTS: int = 4096 # points in one outline
|
||||
const TT_EDGES: int = 16384 # line segments in one glyph
|
||||
const TT_GC: int = 512 # glyph cache entries
|
||||
|
||||
# ---- per-font tables (parallel arrays; index = font id) -------------------
|
||||
var tt_data: ptr = ptr_null()
|
||||
var tt_size: ptr = ptr_null()
|
||||
var tt_upem: ptr = ptr_null()
|
||||
var tt_nglyf: ptr = ptr_null()
|
||||
var tt_locfm: ptr = ptr_null()
|
||||
var tt_nhm: ptr = ptr_null()
|
||||
var tt_asc: ptr = ptr_null()
|
||||
var tt_desc: ptr = ptr_null()
|
||||
var tt_gap: ptr = ptr_null()
|
||||
var tt_glyf: ptr = ptr_null()
|
||||
var tt_loca: ptr = ptr_null()
|
||||
var tt_hmtx: ptr = ptr_null()
|
||||
var tt_cmap: ptr = ptr_null()
|
||||
var tt_cfmt: ptr = ptr_null()
|
||||
var tt_n: int = 0
|
||||
|
||||
# ---- outline + edge scratch (reused for every glyph) ----------------------
|
||||
var ol_x: ptr = ptr_null()
|
||||
var ol_y: ptr = ptr_null()
|
||||
var ol_on: ptr = ptr_null()
|
||||
var ol_ends: ptr = ptr_null()
|
||||
var ol_n: int = 0
|
||||
var ol_ne: int = 0
|
||||
|
||||
var ed_x0: ptr = ptr_null()
|
||||
var ed_y0: ptr = ptr_null()
|
||||
var ed_x1: ptr = ptr_null()
|
||||
var ed_y1: ptr = ptr_null()
|
||||
var ed_n: int = 0
|
||||
|
||||
var sc_x: ptr = ptr_null() # scanline crossings
|
||||
var sc_d: ptr = ptr_null()
|
||||
|
||||
# ---- glyph cache ----------------------------------------------------------
|
||||
var gc_used: ptr = ptr_null()
|
||||
var gc_font: ptr = ptr_null()
|
||||
var gc_cp: ptr = ptr_null()
|
||||
var gc_px: ptr = ptr_null()
|
||||
var gc_w: ptr = ptr_null()
|
||||
var gc_h: ptr = ptr_null()
|
||||
var gc_ox: ptr = ptr_null()
|
||||
var gc_oy: ptr = ptr_null()
|
||||
var gc_adv: ptr = ptr_null()
|
||||
var gc_bmp: ptr = ptr_null()
|
||||
|
||||
fn rt_tt_init() -> void {
|
||||
tt_data = mem_alloc(TT_MAX * 8)
|
||||
tt_size = mem_alloc(TT_MAX * 4)
|
||||
tt_upem = mem_alloc(TT_MAX * 4)
|
||||
tt_nglyf = mem_alloc(TT_MAX * 4)
|
||||
tt_locfm = mem_alloc(TT_MAX * 4)
|
||||
tt_nhm = mem_alloc(TT_MAX * 4)
|
||||
tt_asc = mem_alloc(TT_MAX * 4)
|
||||
tt_desc = mem_alloc(TT_MAX * 4)
|
||||
tt_gap = mem_alloc(TT_MAX * 4)
|
||||
tt_glyf = mem_alloc(TT_MAX * 4)
|
||||
tt_loca = mem_alloc(TT_MAX * 4)
|
||||
tt_hmtx = mem_alloc(TT_MAX * 4)
|
||||
tt_cmap = mem_alloc(TT_MAX * 4)
|
||||
tt_cfmt = mem_alloc(TT_MAX * 4)
|
||||
|
||||
ol_x = mem_alloc(TT_PTS * 4)
|
||||
ol_y = mem_alloc(TT_PTS * 4)
|
||||
ol_on = mem_alloc(TT_PTS * 4)
|
||||
ol_ends = mem_alloc(256 * 4)
|
||||
|
||||
ed_x0 = mem_alloc(TT_EDGES * 4)
|
||||
ed_y0 = mem_alloc(TT_EDGES * 4)
|
||||
ed_x1 = mem_alloc(TT_EDGES * 4)
|
||||
ed_y1 = mem_alloc(TT_EDGES * 4)
|
||||
sc_x = mem_alloc(TT_EDGES * 4)
|
||||
sc_d = mem_alloc(TT_EDGES * 4)
|
||||
|
||||
gc_used = mem_alloc(TT_GC * 4)
|
||||
gc_font = mem_alloc(TT_GC * 4)
|
||||
gc_cp = mem_alloc(TT_GC * 4)
|
||||
gc_px = mem_alloc(TT_GC * 4)
|
||||
gc_w = mem_alloc(TT_GC * 4)
|
||||
gc_h = mem_alloc(TT_GC * 4)
|
||||
gc_ox = mem_alloc(TT_GC * 4)
|
||||
gc_oy = mem_alloc(TT_GC * 4)
|
||||
gc_adv = mem_alloc(TT_GC * 4)
|
||||
gc_bmp = mem_alloc(TT_GC * 8)
|
||||
mem_set(gc_used, 0, TT_GC * 4)
|
||||
}
|
||||
|
||||
# ---- big-endian readers ---------------------------------------------------
|
||||
fn tt_u16(d: ptr, at: int) -> int {
|
||||
return bor(shl(peek8(d, at), 8), peek8(d, at + 1))
|
||||
}
|
||||
fn tt_i16(d: ptr, at: int) -> int {
|
||||
let v = tt_u16(d, at)
|
||||
if v >= 32768 { return v - 65536 }
|
||||
return v
|
||||
}
|
||||
fn tt_u32(d: ptr, at: int) -> int {
|
||||
return bor(bor(shl(peek8(d, at), 24), shl(peek8(d, at + 1), 16)),
|
||||
bor(shl(peek8(d, at + 2), 8), peek8(d, at + 3)))
|
||||
}
|
||||
fn tt_i8(d: ptr, at: int) -> int {
|
||||
let v = peek8(d, at)
|
||||
if v >= 128 { return v - 256 }
|
||||
return v
|
||||
}
|
||||
|
||||
fn tt_find_table(d: ptr, base: int, a: int, b: int, c: int, e: int) -> int {
|
||||
let n = tt_u16(d, base + 4)
|
||||
for i in 0 .. n {
|
||||
let rec = base + 12 + i * 16
|
||||
if peek8(d, rec) == a {
|
||||
if peek8(d, rec + 1) == b {
|
||||
if peek8(d, rec + 2) == c {
|
||||
if peek8(d, rec + 3) == e { return tt_u32(d, rec + 8) }
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return 0 - 1
|
||||
}
|
||||
|
||||
# pick the most capable Unicode subtable, as the C loader did
|
||||
fn tt_pick_cmap(id: int, d: ptr, co: int) -> void {
|
||||
poke32(tt_cmap, id, 0 - 1)
|
||||
poke32(tt_cfmt, id, 0)
|
||||
if co < 0 { return }
|
||||
let n = tt_u16(d, co + 2)
|
||||
let best = 0 - 1
|
||||
let bestscore = 0 - 1
|
||||
for i in 0 .. n {
|
||||
let rec = co + 4 + i * 8
|
||||
let plat = tt_u16(d, rec)
|
||||
let enc = tt_u16(d, rec + 2)
|
||||
let off = tt_u32(d, rec + 4)
|
||||
let score = 0 - 1
|
||||
if plat == 0 { score = 2 }
|
||||
if plat == 0 { if enc == 4 { score = 4 } }
|
||||
if plat == 0 { if enc == 6 { score = 4 } }
|
||||
if plat == 3 { if enc == 1 { score = 3 } }
|
||||
if plat == 3 { if enc == 10 { score = 5 } }
|
||||
if score > bestscore {
|
||||
bestscore = score
|
||||
best = co + off
|
||||
}
|
||||
}
|
||||
if best < 0 { return }
|
||||
poke32(tt_cmap, id, best)
|
||||
poke32(tt_cfmt, id, tt_u16(d, best))
|
||||
}
|
||||
|
||||
fn rt_font_load(path: str) -> int {
|
||||
if tt_n >= TT_MAX { return 0 - 1 }
|
||||
let d = rt_read_file(path)
|
||||
if ptr_is_null(d) { return 0 - 1 }
|
||||
let size = rt_file_len
|
||||
let base = 0
|
||||
# a .ttc collection points at its first font
|
||||
if size >= 16 {
|
||||
if peek8(d, 0) == 116 { if peek8(d, 1) == 116 { if peek8(d, 2) == 99 { if peek8(d, 3) == 102 {
|
||||
base = tt_u32(d, 12)
|
||||
} } } }
|
||||
}
|
||||
let head = tt_find_table(d, base, 104, 101, 97, 100)
|
||||
let maxp = tt_find_table(d, base, 109, 97, 120, 112)
|
||||
let hhea = tt_find_table(d, base, 104, 104, 101, 97)
|
||||
let loca = tt_find_table(d, base, 108, 111, 99, 97)
|
||||
let glyf = tt_find_table(d, base, 103, 108, 121, 102)
|
||||
let hmtx = tt_find_table(d, base, 104, 109, 116, 120)
|
||||
if head < 0 { return 0 - 1 }
|
||||
if maxp < 0 { return 0 - 1 }
|
||||
if hhea < 0 { return 0 - 1 }
|
||||
if loca < 0 { return 0 - 1 }
|
||||
if glyf < 0 { return 0 - 1 }
|
||||
if hmtx < 0 { return 0 - 1 }
|
||||
|
||||
let id = tt_n
|
||||
tt_n = tt_n + 1
|
||||
pokep(tt_data, id, d)
|
||||
poke32(tt_size, id, size)
|
||||
let upem = tt_u16(d, head + 18)
|
||||
if upem <= 0 { upem = 1000 }
|
||||
poke32(tt_upem, id, upem)
|
||||
poke32(tt_locfm, id, tt_i16(d, head + 50))
|
||||
poke32(tt_nglyf, id, tt_u16(d, maxp + 4))
|
||||
poke32(tt_asc, id, tt_i16(d, hhea + 4))
|
||||
poke32(tt_desc, id, tt_i16(d, hhea + 6))
|
||||
poke32(tt_gap, id, tt_i16(d, hhea + 8))
|
||||
poke32(tt_nhm, id, tt_u16(d, hhea + 34))
|
||||
poke32(tt_glyf, id, glyf)
|
||||
poke32(tt_loca, id, loca)
|
||||
poke32(tt_hmtx, id, hmtx)
|
||||
tt_pick_cmap(id, d, tt_find_table(d, base, 99, 109, 97, 112))
|
||||
return id
|
||||
}
|
||||
|
||||
# ---- codepoint -> glyph id ------------------------------------------------
|
||||
fn tt_glyph_index(id: int, cp: int) -> int {
|
||||
let d = peekp(tt_data, id)
|
||||
let s = peek32(tt_cmap, id)
|
||||
if s < 0 { return 0 }
|
||||
let fmt = peek32(tt_cfmt, id)
|
||||
|
||||
if fmt == 4 {
|
||||
if cp > 65535 { return 0 }
|
||||
let segX2 = tt_u16(d, s + 6)
|
||||
let segc = segX2 / 2
|
||||
let endp = s + 14
|
||||
let startp = endp + segX2 + 2
|
||||
let deltap = startp + segX2
|
||||
let rangep = deltap + segX2
|
||||
for i in 0 .. segc {
|
||||
if cp <= tt_u16(d, endp + i * 2) {
|
||||
let st = tt_u16(d, startp + i * 2)
|
||||
if cp < st { return 0 }
|
||||
let ro = tt_u16(d, rangep + i * 2)
|
||||
if ro == 0 { return band(cp + tt_i16(d, deltap + i * 2), 65535) }
|
||||
let g = tt_u16(d, rangep + i * 2 + ro + (cp - st) * 2)
|
||||
if g == 0 { return 0 }
|
||||
return band(g + tt_i16(d, deltap + i * 2), 65535)
|
||||
}
|
||||
}
|
||||
return 0
|
||||
}
|
||||
if fmt == 12 {
|
||||
let ng = tt_u32(d, s + 12)
|
||||
for i in 0 .. ng {
|
||||
let g = s + 16 + i * 12
|
||||
if cp >= tt_u32(d, g) {
|
||||
if cp <= tt_u32(d, g + 4) { return tt_u32(d, g + 8) + (cp - tt_u32(d, g)) }
|
||||
}
|
||||
}
|
||||
return 0
|
||||
}
|
||||
if fmt == 6 {
|
||||
let first = tt_u16(d, s + 6)
|
||||
let cnt = tt_u16(d, s + 8)
|
||||
if cp >= first { if cp < first + cnt { return tt_u16(d, s + 10 + (cp - first) * 2) } }
|
||||
return 0
|
||||
}
|
||||
if fmt == 0 {
|
||||
if cp < 256 { return peek8(d, s + 6 + cp) }
|
||||
}
|
||||
return 0
|
||||
}
|
||||
|
||||
fn tt_advance(id: int, gid: int) -> int {
|
||||
let d = peekp(tt_data, id)
|
||||
let hmtx = peek32(tt_hmtx, id)
|
||||
let n = peek32(tt_nhm, id)
|
||||
if gid < n { return tt_u16(d, hmtx + gid * 4) }
|
||||
return tt_u16(d, hmtx + (n - 1) * 4)
|
||||
}
|
||||
|
||||
# ---- outline extraction ---------------------------------------------------
|
||||
fn ol_pt(x: fixed, y: fixed, on: int) -> void {
|
||||
if ol_n >= TT_PTS { return }
|
||||
pokef(ol_x, ol_n, x)
|
||||
pokef(ol_y, ol_n, y)
|
||||
poke32(ol_on, ol_n, on)
|
||||
ol_n = ol_n + 1
|
||||
}
|
||||
|
||||
fn tt_glyph_start(id: int, gid: int) -> int {
|
||||
let d = peekp(tt_data, id)
|
||||
let loca = peek32(tt_loca, id)
|
||||
if peek32(tt_locfm, id) == 0 { return tt_u16(d, loca + gid * 2) * 2 }
|
||||
return tt_u32(d, loca + gid * 4)
|
||||
}
|
||||
fn tt_glyph_end(id: int, gid: int) -> int {
|
||||
let d = peekp(tt_data, id)
|
||||
let loca = peek32(tt_loca, id)
|
||||
if peek32(tt_locfm, id) == 0 { return tt_u16(d, loca + (gid + 1) * 2) * 2 }
|
||||
return tt_u32(d, loca + (gid + 1) * 4)
|
||||
}
|
||||
|
||||
# Append glyph `gid`, transformed by [a b c e] + (dx,dy), to the outline.
|
||||
fn tt_load_outline(id: int, gid: int, a: fixed, b: fixed, c: fixed, e: fixed, dx: fixed, dy: fixed, depth: int) -> void {
|
||||
if gid < 0 { return }
|
||||
if gid >= peek32(tt_nglyf, id) { return }
|
||||
if depth > 5 { return }
|
||||
let goff = tt_glyph_start(id, gid)
|
||||
let gend = tt_glyph_end(id, gid)
|
||||
if goff >= gend { return }
|
||||
let d = peekp(tt_data, id)
|
||||
let g = peek32(tt_glyf, id) + goff
|
||||
let nc = tt_i16(d, g)
|
||||
|
||||
if nc >= 0 {
|
||||
let endpts = g + 10
|
||||
let npts = 0
|
||||
if nc > 0 { npts = tt_u16(d, endpts + (nc - 1) * 2) + 1 }
|
||||
let p = endpts + nc * 2
|
||||
p = p + 2 + tt_u16(d, p) # skip instructions
|
||||
|
||||
let flags = mem_alloc(npts + 8)
|
||||
let i = 0
|
||||
while i < npts {
|
||||
let fl = peek8(d, p)
|
||||
p = p + 1
|
||||
poke8(flags, i, fl)
|
||||
i = i + 1
|
||||
if band(fl, 8) != 0 { # REPEAT
|
||||
let r = peek8(d, p)
|
||||
p = p + 1
|
||||
while r > 0 {
|
||||
if i < npts { poke8(flags, i, fl) i = i + 1 }
|
||||
r = r - 1
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
let xs = mem_alloc((npts + 1) * 4)
|
||||
let ys = mem_alloc((npts + 1) * 4)
|
||||
let xv = 0
|
||||
for k in 0 .. npts {
|
||||
let fl = peek8(flags, k)
|
||||
if band(fl, 2) != 0 {
|
||||
let dxv = peek8(d, p)
|
||||
p = p + 1
|
||||
if band(fl, 16) != 0 { xv = xv + dxv } else { xv = xv - dxv }
|
||||
} else {
|
||||
if band(fl, 16) == 0 { xv = xv + tt_i16(d, p) p = p + 2 }
|
||||
}
|
||||
poke32(xs, k, xv)
|
||||
}
|
||||
let yv = 0
|
||||
for k in 0 .. npts {
|
||||
let fl = peek8(flags, k)
|
||||
if band(fl, 4) != 0 {
|
||||
let dyv = peek8(d, p)
|
||||
p = p + 1
|
||||
if band(fl, 32) != 0 { yv = yv + dyv } else { yv = yv - dyv }
|
||||
} else {
|
||||
if band(fl, 32) == 0 { yv = yv + tt_i16(d, p) p = p + 2 }
|
||||
}
|
||||
poke32(ys, k, yv)
|
||||
}
|
||||
|
||||
let start = 0
|
||||
for ci in 0 .. nc {
|
||||
let last = tt_u16(d, endpts + ci * 2)
|
||||
for k in start .. last + 1 {
|
||||
let X = fx(peek32(xs, k))
|
||||
let Y = fx(peek32(ys, k))
|
||||
ol_pt(a * X + c * Y + dx, b * X + e * Y + dy, band(peek8(flags, k), 1))
|
||||
}
|
||||
if ol_ne < 256 {
|
||||
poke32(ol_ends, ol_ne, ol_n)
|
||||
ol_ne = ol_ne + 1
|
||||
}
|
||||
start = last + 1
|
||||
}
|
||||
mem_free(flags)
|
||||
mem_free(xs)
|
||||
mem_free(ys)
|
||||
} else {
|
||||
# composite glyph: components, each with its own placement and transform
|
||||
let p = g + 10
|
||||
let more = 1
|
||||
while more == 1 {
|
||||
let flags = tt_u16(d, p)
|
||||
let cgid = tt_u16(d, p + 2)
|
||||
p = p + 4
|
||||
let arg1 = 0
|
||||
let arg2 = 0
|
||||
if band(flags, 1) != 0 {
|
||||
arg1 = tt_i16(d, p)
|
||||
arg2 = tt_i16(d, p + 2)
|
||||
p = p + 4
|
||||
} else {
|
||||
arg1 = tt_i8(d, p)
|
||||
arg2 = tt_i8(d, p + 1)
|
||||
p = p + 2
|
||||
}
|
||||
let ca = 1.0
|
||||
let cb = 0.0
|
||||
let cc = 0.0
|
||||
let ce = 1.0
|
||||
if band(flags, 8) != 0 {
|
||||
ca = as_fixed(shl(tt_i16(d, p), 2)) # F2Dot14 -> Q16.16
|
||||
ce = ca
|
||||
p = p + 2
|
||||
}
|
||||
if band(flags, 64) != 0 {
|
||||
ca = as_fixed(shl(tt_i16(d, p), 2))
|
||||
ce = as_fixed(shl(tt_i16(d, p + 2), 2))
|
||||
p = p + 4
|
||||
}
|
||||
if band(flags, 128) != 0 {
|
||||
ca = as_fixed(shl(tt_i16(d, p), 2))
|
||||
cb = as_fixed(shl(tt_i16(d, p + 2), 2))
|
||||
cc = as_fixed(shl(tt_i16(d, p + 4), 2))
|
||||
ce = as_fixed(shl(tt_i16(d, p + 6), 2))
|
||||
p = p + 8
|
||||
}
|
||||
let odx = dx
|
||||
let ody = dy
|
||||
if band(flags, 2) != 0 {
|
||||
odx = a * fx(arg1) + c * fx(arg2) + dx
|
||||
ody = b * fx(arg1) + e * fx(arg2) + dy
|
||||
}
|
||||
tt_load_outline(id, cgid, a * ca + c * cb, b * ca + e * cb, a * cc + c * ce, b * cc + e * ce, odx, ody, depth + 1)
|
||||
more = 0
|
||||
if band(flags, 32) != 0 { more = 1 }
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
import "truetype_raster.ludic"
|
||||
380
runtime/native/truetype_raster.ludic
Normal file
380
runtime/native/truetype_raster.ludic
Normal file
|
|
@ -0,0 +1,380 @@
|
|||
# truetype_raster.ludic — glyph rasterization, the glyph cache, UTF-8 decoding
|
||||
# and text drawing. Split out of truetype.ludic (the sfnt/cmap/outline half).
|
||||
|
||||
# ---- rasterization --------------------------------------------------------
|
||||
fn ed_add(x0: fixed, y0: fixed, x1: fixed, y1: fixed) -> void {
|
||||
if ed_n >= TT_EDGES { return }
|
||||
pokef(ed_x0, ed_n, x0)
|
||||
pokef(ed_y0, ed_n, y0)
|
||||
pokef(ed_x1, ed_n, x1)
|
||||
pokef(ed_y1, ed_n, y1)
|
||||
ed_n = ed_n + 1
|
||||
}
|
||||
|
||||
fn tt_isqrt(v: int) -> int {
|
||||
if v <= 0 { return 0 }
|
||||
let r = 0
|
||||
let b = 32768
|
||||
while b > 0 {
|
||||
let t = r + b
|
||||
if t * t <= v { r = t }
|
||||
b = b / 2
|
||||
}
|
||||
return r
|
||||
}
|
||||
|
||||
# flatten one quadratic Bézier into line segments, subdivided by chord length
|
||||
fn ed_quad(x0: fixed, y0: fixed, cx: fixed, cy: fixed, x1: fixed, y1: fixed) -> void {
|
||||
let dx = flr(x1) - flr(x0)
|
||||
let dy = flr(y1) - flr(y0)
|
||||
let n = tt_isqrt(dx * dx + dy * dy) / 3
|
||||
if n < 2 { n = 2 }
|
||||
if n > 24 { n = 24 }
|
||||
let px = x0
|
||||
let py = y0
|
||||
for i in 1 .. n + 1 {
|
||||
let t = fx(i) / n
|
||||
let u = 1.0 - t
|
||||
let qx = u * u * x0 + 2.0 * u * t * cx + t * t * x1
|
||||
let qy = u * u * y0 + 2.0 * u * t * cy + t * t * y1
|
||||
ed_add(px, py, qx, qy)
|
||||
px = qx
|
||||
py = qy
|
||||
}
|
||||
}
|
||||
|
||||
# Rasterize a glyph at `px` pixels. Coverage lands in a fresh buffer; the
|
||||
# geometry is left in gr_* for the caller.
|
||||
var gr_w: int = 0
|
||||
var gr_h: int = 0
|
||||
var gr_ox: int = 0
|
||||
var gr_oy: int = 0
|
||||
var gr_adv: int = 0
|
||||
|
||||
fn tt_raster(id: int, gid: int, px: int) -> ptr {
|
||||
let upem = peek32(tt_upem, id)
|
||||
let scale = fx(px) / upem
|
||||
gr_adv = flr(fx(tt_advance(id, gid)) * scale + 0.5)
|
||||
gr_w = 0
|
||||
gr_h = 0
|
||||
ol_n = 0
|
||||
ol_ne = 0
|
||||
ed_n = 0
|
||||
tt_load_outline(id, gid, 1.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0)
|
||||
if ol_n == 0 { return ptr_null() }
|
||||
|
||||
let minx = 999999.0
|
||||
let miny = 999999.0
|
||||
let maxx = 0.0 - 999999.0
|
||||
let maxy = 0.0 - 999999.0
|
||||
for i in 0 .. ol_n {
|
||||
let X = peekf(ol_x, i) * scale
|
||||
let Y = peekf(ol_y, i) * scale
|
||||
if X < minx { minx = X }
|
||||
if X > maxx { maxx = X }
|
||||
if Y < miny { miny = Y }
|
||||
if Y > maxy { maxy = Y }
|
||||
}
|
||||
let x0 = flr(minx)
|
||||
let y0 = flr(miny)
|
||||
let x1 = flr(maxx) + 1
|
||||
let y1 = flr(maxy) + 1
|
||||
if maxx == fx(flr(maxx)) { x1 = flr(maxx) }
|
||||
if maxy == fx(flr(maxy)) { y1 = flr(maxy) }
|
||||
let W = x1 - x0
|
||||
let H = y1 - y0
|
||||
if W <= 0 { return ptr_null() }
|
||||
if H <= 0 { return ptr_null() }
|
||||
if W > 1024 { return ptr_null() }
|
||||
if H > 1024 { return ptr_null() }
|
||||
gr_w = W
|
||||
gr_h = H
|
||||
gr_ox = x0
|
||||
gr_oy = y1
|
||||
|
||||
# build edges in supersample space (y grows downward)
|
||||
let start = 0
|
||||
for ci in 0 .. ol_ne {
|
||||
let end = peek32(ol_ends, ci)
|
||||
let cnt = end - start
|
||||
if cnt >= 2 {
|
||||
let first_on = 0 - 1
|
||||
for i in 0 .. cnt {
|
||||
if first_on < 0 { if peek32(ol_on, start + i) == 1 { first_on = i } }
|
||||
}
|
||||
let sx = 0.0
|
||||
let sy = 0.0
|
||||
if first_on < 0 {
|
||||
# all off-curve: start at the midpoint of the first and last point
|
||||
let mx = (peekf(ol_x, start) + peekf(ol_x, start + cnt - 1)) / 2
|
||||
let my = (peekf(ol_y, start) + peekf(ol_y, start + cnt - 1)) / 2
|
||||
sx = (mx * scale - fx(x0)) * TT_SS
|
||||
sy = (fx(y1) - my * scale) * TT_SS
|
||||
first_on = 0
|
||||
} else {
|
||||
sx = (peekf(ol_x, start + first_on) * scale - fx(x0)) * TT_SS
|
||||
sy = (fx(y1) - peekf(ol_y, start + first_on) * scale) * TT_SS
|
||||
}
|
||||
let curx = sx
|
||||
let cury = sy
|
||||
let step = 0
|
||||
while step < cnt {
|
||||
let i = (first_on + 1 + step) % cnt
|
||||
let ix = (peekf(ol_x, start + i) * scale - fx(x0)) * TT_SS
|
||||
let iy = (fx(y1) - peekf(ol_y, start + i) * scale) * TT_SS
|
||||
if peek32(ol_on, start + i) == 1 {
|
||||
ed_add(curx, cury, ix, iy)
|
||||
curx = ix
|
||||
cury = iy
|
||||
} else {
|
||||
let j = (i + 1) % cnt
|
||||
let jx = (peekf(ol_x, start + j) * scale - fx(x0)) * TT_SS
|
||||
let jy = (fx(y1) - peekf(ol_y, start + j) * scale) * TT_SS
|
||||
let ex = jx
|
||||
let ey = jy
|
||||
if peek32(ol_on, start + j) == 1 {
|
||||
step = step + 1
|
||||
} else {
|
||||
ex = (ix + jx) / 2 # implied on-curve midpoint
|
||||
ey = (iy + jy) / 2
|
||||
}
|
||||
ed_quad(curx, cury, ix, iy, ex, ey)
|
||||
curx = ex
|
||||
cury = ey
|
||||
}
|
||||
step = step + 1
|
||||
}
|
||||
ed_add(curx, cury, sx, sy)
|
||||
}
|
||||
start = end
|
||||
}
|
||||
|
||||
let SW = W * TT_SS
|
||||
let SH = H * TT_SS
|
||||
let cover = mem_alloc(W * H)
|
||||
mem_set(cover, 0, W * H)
|
||||
let unit = 255 / (TT_SS * TT_SS)
|
||||
|
||||
for sy in 0 .. SH {
|
||||
let yc = fx(sy) + 0.5
|
||||
let m = 0
|
||||
for i in 0 .. ed_n {
|
||||
let ya = peekf(ed_y0, i)
|
||||
let yb = peekf(ed_y1, i)
|
||||
let hit = 0
|
||||
if ya <= yc { if yb > yc { hit = 1 } }
|
||||
if yb <= yc { if ya > yc { hit = 1 } }
|
||||
if hit == 1 {
|
||||
let t = (yc - ya) / (yb - ya)
|
||||
pokef(sc_x, m, peekf(ed_x0, i) + t * (peekf(ed_x1, i) - peekf(ed_x0, i)))
|
||||
if yb > ya { poke32(sc_d, m, 1) } else { poke32(sc_d, m, 0 - 1) }
|
||||
m = m + 1
|
||||
}
|
||||
}
|
||||
# insertion sort the crossings by x
|
||||
for i in 1 .. m {
|
||||
let kx = peekf(sc_x, i)
|
||||
let kd = peek32(sc_d, i)
|
||||
let j = i - 1
|
||||
let placed = 0
|
||||
while j >= 0 {
|
||||
if peekf(sc_x, j) > kx {
|
||||
pokef(sc_x, j + 1, peekf(sc_x, j))
|
||||
poke32(sc_d, j + 1, peek32(sc_d, j))
|
||||
j = j - 1
|
||||
} else {
|
||||
pokef(sc_x, j + 1, kx)
|
||||
poke32(sc_d, j + 1, kd)
|
||||
placed = 1
|
||||
j = 0 - 1
|
||||
}
|
||||
}
|
||||
if placed == 0 {
|
||||
pokef(sc_x, 0, kx)
|
||||
poke32(sc_d, 0, kd)
|
||||
}
|
||||
}
|
||||
let wind = 0
|
||||
let oy = sy / TT_SS
|
||||
for i in 0 .. m - 1 {
|
||||
wind = wind + peek32(sc_d, i)
|
||||
if wind != 0 {
|
||||
let xa = peekf(sc_x, i)
|
||||
let xb = peekf(sc_x, i + 1)
|
||||
if xa < 0.0 { xa = 0.0 }
|
||||
if xb > fx(SW) { xb = fx(SW) }
|
||||
if xb > xa {
|
||||
let ixa = flr(xa)
|
||||
let ixb = flr(xb) + 1
|
||||
for sx in ixa .. ixb {
|
||||
let cxl = xa
|
||||
let cxr = xb
|
||||
if fx(sx) > cxl { cxl = fx(sx) }
|
||||
if fx(sx + 1) < cxr { cxr = fx(sx + 1) }
|
||||
let cvr = cxr - cxl
|
||||
if cvr > 0.0 {
|
||||
let oxp = sx / TT_SS
|
||||
if oxp >= 0 { if oxp < W { if oy >= 0 { if oy < H {
|
||||
let v = peek8(cover, oy * W + oxp) + flr(cvr * unit)
|
||||
if v > 255 { v = 255 }
|
||||
poke8(cover, oy * W + oxp, v)
|
||||
} } } }
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return cover
|
||||
}
|
||||
|
||||
# ---- glyph cache ----------------------------------------------------------
|
||||
# Rasterizing is far too slow to repeat per frame, so a coverage mask is kept
|
||||
# per (font, codepoint, size). Open addressing, 8 probes, evict on miss.
|
||||
fn gc_hash(font: int, cp: int, px: int) -> int {
|
||||
return band(bxor(bxor(cp * 2654435761, shl(font, 20)), shl(px, 8)), TT_GC - 1)
|
||||
}
|
||||
|
||||
fn tt_glyph_get(font: int, cp: int, px: int) -> int {
|
||||
let h = gc_hash(font, cp, px)
|
||||
for k in 0 .. 8 {
|
||||
let s = band(h + k, TT_GC - 1)
|
||||
if peek32(gc_used, s) == 1 {
|
||||
if peek32(gc_font, s) == font {
|
||||
if peek32(gc_cp, s) == cp {
|
||||
if peek32(gc_px, s) == px { return s }
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
let s = h
|
||||
if peek32(gc_used, s) == 1 {
|
||||
let old = peekp(gc_bmp, s)
|
||||
if ptr_is_null(old) == false { mem_free(old) }
|
||||
}
|
||||
let bmp = tt_raster(font, tt_glyph_index(font, cp), px)
|
||||
pokep(gc_bmp, s, bmp)
|
||||
poke32(gc_used, s, 1)
|
||||
poke32(gc_font, s, font)
|
||||
poke32(gc_cp, s, cp)
|
||||
poke32(gc_px, s, px)
|
||||
poke32(gc_w, s, gr_w)
|
||||
poke32(gc_h, s, gr_h)
|
||||
poke32(gc_ox, s, gr_ox)
|
||||
poke32(gc_oy, s, gr_oy)
|
||||
poke32(gc_adv, s, gr_adv)
|
||||
return s
|
||||
}
|
||||
|
||||
# ---- UTF-8 ----------------------------------------------------------------
|
||||
var u8_next: int = 0 # byte index just past the codepoint last decoded
|
||||
|
||||
fn tt_utf8(s: str, at: int) -> int {
|
||||
let c = peek8(s, at)
|
||||
let extra = 0 - 1
|
||||
if c < 128 { extra = 0 }
|
||||
if shr(c, 5) == 6 { extra = 1 }
|
||||
if shr(c, 4) == 14 { extra = 2 }
|
||||
if shr(c, 3) == 30 { extra = 3 }
|
||||
if extra < 0 {
|
||||
u8_next = at + 1
|
||||
return 65533
|
||||
}
|
||||
if extra == 0 {
|
||||
u8_next = at + 1
|
||||
return c
|
||||
}
|
||||
let cp = band(c, shr(63, extra))
|
||||
for i in 0 .. extra {
|
||||
let b = peek8(s, at + 1 + i)
|
||||
if band(b, 192) != 128 {
|
||||
u8_next = at + 1 + i
|
||||
return 65533
|
||||
}
|
||||
cp = bor(shl(cp, 6), band(b, 63))
|
||||
}
|
||||
u8_next = at + 1 + extra
|
||||
return cp
|
||||
}
|
||||
|
||||
# ---- drawing --------------------------------------------------------------
|
||||
fn tt_blit(bmp: ptr, w: int, h: int, dx: int, dy: int, colour: int) -> void {
|
||||
if ptr_is_null(bmp) { return }
|
||||
let cr = band(shr(colour, 16), 255)
|
||||
let cg = band(shr(colour, 8), 255)
|
||||
let cb = band(colour, 255)
|
||||
for y in 0 .. h {
|
||||
let py = dy + y
|
||||
if py >= 0 {
|
||||
if py < rt_fbh {
|
||||
for x in 0 .. w {
|
||||
let a = peek8(bmp, y * w + x)
|
||||
if a != 0 {
|
||||
let pxx = dx + x
|
||||
if pxx >= 0 {
|
||||
if pxx < rt_fbw {
|
||||
let d = peek32(rt_fb, py * rt_fbw + pxx)
|
||||
let rr = (cr * a + band(shr(d, 16), 255) * (255 - a)) / 255
|
||||
let rg = (cg * a + band(shr(d, 8), 255) * (255 - a)) / 255
|
||||
let rb = (cb * a + band(d, 255) * (255 - a)) / 255
|
||||
poke32(rt_fb, py * rt_fbw + pxx, bor(bor(shl(rr, 16), shl(rg, 8)), rb))
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn rt_text_ttf(font: int, x: int, y: int, s: str, colour: int, px: int) -> void {
|
||||
if font < 0 { return }
|
||||
if font >= tt_n { return }
|
||||
if px <= 0 { return }
|
||||
let upem = peek32(tt_upem, font)
|
||||
let scale = fx(px) / upem
|
||||
let baseline = y + flr(fx(peek32(tt_asc, font)) * scale + 0.5)
|
||||
let lineh = flr(fx(peek32(tt_asc, font) - peek32(tt_desc, font) + peek32(tt_gap, font)) * scale + 0.5)
|
||||
let penx = x
|
||||
let i = 0
|
||||
while peek8(s, i) != 0 {
|
||||
let cp = tt_utf8(s, i)
|
||||
i = u8_next
|
||||
if cp == 10 {
|
||||
penx = x
|
||||
baseline = baseline + lineh
|
||||
} else {
|
||||
let g = tt_glyph_get(font, cp, px)
|
||||
tt_blit(peekp(gc_bmp, g), peek32(gc_w, g), peek32(gc_h, g), penx + peek32(gc_ox, g), baseline - peek32(gc_oy, g), colour)
|
||||
penx = penx + peek32(gc_adv, g)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn rt_text_w(font: int, s: str, px: int) -> int {
|
||||
if font < 0 { return 0 }
|
||||
if font >= tt_n { return 0 }
|
||||
if px <= 0 { return 0 }
|
||||
let w = 0
|
||||
let best = 0
|
||||
let i = 0
|
||||
while peek8(s, i) != 0 {
|
||||
let cp = tt_utf8(s, i)
|
||||
i = u8_next
|
||||
if cp == 10 {
|
||||
if w > best { best = w }
|
||||
w = 0
|
||||
} else {
|
||||
w = w + peek32(gc_adv, tt_glyph_get(font, cp, px))
|
||||
}
|
||||
}
|
||||
if w > best { best = w }
|
||||
return best
|
||||
}
|
||||
|
||||
fn rt_text_h(font: int, px: int) -> int {
|
||||
if font < 0 { return 0 }
|
||||
if font >= tt_n { return 0 }
|
||||
let scale = fx(px) / peek32(tt_upem, font)
|
||||
return flr(fx(peek32(tt_asc, font) - peek32(tt_desc, font) + peek32(tt_gap, font)) * scale + 0.5)
|
||||
}
|
||||
312
runtime/native/ui.ludic
Normal file
312
runtime/native/ui.ludic
Normal file
|
|
@ -0,0 +1,312 @@
|
|||
# ============================================================================
|
||||
# ui.ludic — the retained UI engine, written in Ludic.
|
||||
#
|
||||
# A `ui Name { … }` block in a game is DATA: the compiler flattens the widget
|
||||
# tree and emits a build function that calls rt_ui_set() for each property.
|
||||
# Everything after that — measure/arrange layout, 9-slice skins, text, keyboard
|
||||
# focus and activation — is this file.
|
||||
#
|
||||
# Widgets are parallel arrays rather than a struct per widget, because Ludic
|
||||
# has components for per-entity data and raw memory for everything else, and a
|
||||
# widget is not an entity.
|
||||
# ============================================================================
|
||||
|
||||
const UI_MAX: int = 256
|
||||
|
||||
# widget types, matching the compiler's flattener
|
||||
const WT_PANEL: int = 0
|
||||
const WT_COL: int = 1
|
||||
const WT_ROW: int = 2
|
||||
const WT_LABEL: int = 3
|
||||
const WT_BUTTON: int = 4
|
||||
const WT_IMAGE: int = 5
|
||||
const WT_SPACER: int = 6
|
||||
|
||||
# property keys — the private protocol between ludicc and this runtime
|
||||
const K_TYPE: int = 0
|
||||
const K_PARENT: int = 1
|
||||
const K_W: int = 2
|
||||
const K_H: int = 3
|
||||
const K_X: int = 4
|
||||
const K_Y: int = 5
|
||||
const K_HASPOS: int = 6
|
||||
const K_PAD: int = 7
|
||||
const K_GAP: int = 8
|
||||
const K_BG: int = 9
|
||||
const K_FG: int = 10
|
||||
const K_BORDER: int = 11
|
||||
const K_ALIGN: int = 12
|
||||
const K_GROW: int = 13
|
||||
const K_FONT: int = 14
|
||||
const K_SIZE: int = 15
|
||||
const K_SKININSET: int = 16
|
||||
const K_FOCUSABLE: int = 17
|
||||
const K_VISIBLE: int = 18
|
||||
const K_IMG: int = 19
|
||||
const K_SKIN: int = 20
|
||||
|
||||
var ui_type: ptr = ptr_null()
|
||||
var ui_parent: ptr = ptr_null()
|
||||
var ui_w: ptr = ptr_null()
|
||||
var ui_h: ptr = ptr_null()
|
||||
var ui_x: ptr = ptr_null()
|
||||
var ui_y: ptr = ptr_null()
|
||||
var ui_haspos: ptr = ptr_null()
|
||||
var ui_pad: ptr = ptr_null()
|
||||
var ui_gap: ptr = ptr_null()
|
||||
var ui_bg: ptr = ptr_null()
|
||||
var ui_fg: ptr = ptr_null()
|
||||
var ui_border: ptr = ptr_null()
|
||||
var ui_align: ptr = ptr_null()
|
||||
var ui_grow: ptr = ptr_null()
|
||||
var ui_font: ptr = ptr_null()
|
||||
var ui_size: ptr = ptr_null()
|
||||
var ui_skin: ptr = ptr_null()
|
||||
var ui_inset: ptr = ptr_null()
|
||||
var ui_img: ptr = ptr_null()
|
||||
var ui_focusable: ptr = ptr_null()
|
||||
var ui_rx: ptr = ptr_null()
|
||||
var ui_ry: ptr = ptr_null()
|
||||
var ui_rw: ptr = ptr_null()
|
||||
var ui_rh: ptr = ptr_null()
|
||||
var ui_visible: ptr = ptr_null()
|
||||
var ui_fired: ptr = ptr_null()
|
||||
var ui_hasdyn: ptr = ptr_null()
|
||||
var ui_dyn: ptr = ptr_null() # UI_MAX * 96 bytes
|
||||
var ui_text: ptr = ptr_null() # UI_MAX static string pointers
|
||||
|
||||
var ui_n: int = 0
|
||||
var ui_active: int = -1
|
||||
var ui_focus: int = -1
|
||||
|
||||
fn rt_ui_init() -> void {
|
||||
ui_type = mem_alloc(UI_MAX * 4)
|
||||
ui_parent = mem_alloc(UI_MAX * 4)
|
||||
ui_w = mem_alloc(UI_MAX * 4)
|
||||
ui_h = mem_alloc(UI_MAX * 4)
|
||||
ui_x = mem_alloc(UI_MAX * 4)
|
||||
ui_y = mem_alloc(UI_MAX * 4)
|
||||
ui_haspos = mem_alloc(UI_MAX * 4)
|
||||
ui_pad = mem_alloc(UI_MAX * 4)
|
||||
ui_gap = mem_alloc(UI_MAX * 4)
|
||||
ui_bg = mem_alloc(UI_MAX * 4)
|
||||
ui_fg = mem_alloc(UI_MAX * 4)
|
||||
ui_border = mem_alloc(UI_MAX * 4)
|
||||
ui_align = mem_alloc(UI_MAX * 4)
|
||||
ui_grow = mem_alloc(UI_MAX * 4)
|
||||
ui_font = mem_alloc(UI_MAX * 4)
|
||||
ui_size = mem_alloc(UI_MAX * 4)
|
||||
ui_skin = mem_alloc(UI_MAX * 4)
|
||||
ui_inset = mem_alloc(UI_MAX * 4)
|
||||
ui_img = mem_alloc(UI_MAX * 4)
|
||||
ui_focusable = mem_alloc(UI_MAX * 4)
|
||||
ui_rx = mem_alloc(UI_MAX * 4)
|
||||
ui_ry = mem_alloc(UI_MAX * 4)
|
||||
ui_rw = mem_alloc(UI_MAX * 4)
|
||||
ui_rh = mem_alloc(UI_MAX * 4)
|
||||
ui_visible = mem_alloc(UI_MAX * 4)
|
||||
ui_fired = mem_alloc(UI_MAX * 4)
|
||||
ui_hasdyn = mem_alloc(UI_MAX * 4)
|
||||
ui_dyn = mem_alloc(UI_MAX * 96)
|
||||
ui_text = mem_alloc(UI_MAX * 8)
|
||||
}
|
||||
|
||||
# ---- build-time interface (called by compiler-emitted code) ---------------
|
||||
fn rt_ui_reset(n: int) -> void {
|
||||
ui_n = n
|
||||
for i in 0 .. n {
|
||||
poke32(ui_type, i, 0)
|
||||
poke32(ui_parent, i, 0 - 1)
|
||||
poke32(ui_w, i, 0)
|
||||
poke32(ui_h, i, 0)
|
||||
poke32(ui_x, i, 0)
|
||||
poke32(ui_y, i, 0)
|
||||
poke32(ui_haspos, i, 0)
|
||||
poke32(ui_pad, i, 0)
|
||||
poke32(ui_gap, i, 0)
|
||||
poke32(ui_bg, i, 0 - 1)
|
||||
poke32(ui_fg, i, 0 - 1)
|
||||
poke32(ui_border, i, 0 - 1)
|
||||
poke32(ui_align, i, 0 - 1)
|
||||
poke32(ui_grow, i, 0)
|
||||
poke32(ui_font, i, 0 - 1)
|
||||
poke32(ui_size, i, 8)
|
||||
poke32(ui_skin, i, 0 - 1)
|
||||
poke32(ui_inset, i, 6)
|
||||
poke32(ui_img, i, 0 - 1)
|
||||
poke32(ui_focusable, i, 0)
|
||||
poke32(ui_visible, i, 1)
|
||||
poke32(ui_fired, i, 0)
|
||||
poke32(ui_hasdyn, i, 0)
|
||||
pokep(ui_text, i, ptr_null())
|
||||
}
|
||||
}
|
||||
|
||||
fn rt_ui_set(i: int, k: int, v: int) -> void {
|
||||
if i < 0 { return }
|
||||
if i >= UI_MAX { return }
|
||||
if k == K_TYPE { poke32(ui_type, i, v) }
|
||||
if k == K_PARENT { poke32(ui_parent, i, v) }
|
||||
if k == K_W { poke32(ui_w, i, v) }
|
||||
if k == K_H { poke32(ui_h, i, v) }
|
||||
if k == K_X { poke32(ui_x, i, v) }
|
||||
if k == K_Y { poke32(ui_y, i, v) }
|
||||
if k == K_HASPOS { poke32(ui_haspos, i, v) }
|
||||
if k == K_PAD { poke32(ui_pad, i, v) }
|
||||
if k == K_GAP { poke32(ui_gap, i, v) }
|
||||
if k == K_BG { poke32(ui_bg, i, v) }
|
||||
if k == K_FG { poke32(ui_fg, i, v) }
|
||||
if k == K_BORDER { poke32(ui_border, i, v) }
|
||||
if k == K_ALIGN { poke32(ui_align, i, v) }
|
||||
if k == K_GROW { poke32(ui_grow, i, v) }
|
||||
if k == K_FONT { poke32(ui_font, i, v) }
|
||||
if k == K_SIZE { poke32(ui_size, i, v) }
|
||||
if k == K_SKININSET { poke32(ui_inset, i, v) }
|
||||
if k == K_FOCUSABLE { poke32(ui_focusable, i, v) }
|
||||
if k == K_VISIBLE { poke32(ui_visible, i, v) }
|
||||
if k == K_IMG { poke32(ui_img, i, v) }
|
||||
if k == K_SKIN { poke32(ui_skin, i, v) }
|
||||
}
|
||||
|
||||
fn rt_ui_static_text(i: int, s: str) -> void {
|
||||
if i < 0 { return }
|
||||
if i >= UI_MAX { return }
|
||||
pokep(ui_text, i, s)
|
||||
}
|
||||
|
||||
# ---- text helpers: TrueType when a font is loaded, bitmap otherwise -------
|
||||
fn ui_str(i: int) -> ptr {
|
||||
if peek32(ui_hasdyn, i) == 1 { return ptr_add(ui_dyn, i * 96) }
|
||||
let t = peekp(ui_text, i)
|
||||
if ptr_is_null(t) { return ptr_add(ui_dyn, i * 96) }
|
||||
return t
|
||||
}
|
||||
|
||||
fn ui_draw_text(font: int, x: int, y: int, s: ptr, colour: int, size: int) -> void {
|
||||
if font >= 0 {
|
||||
if font < tt_n {
|
||||
rt_text_ttf(font, x, y, s, colour, size)
|
||||
return
|
||||
}
|
||||
}
|
||||
rt_text(x, y, s, colour, max(size / 8, 1))
|
||||
}
|
||||
|
||||
fn ui_tw(font: int, s: ptr, size: int) -> int {
|
||||
if font >= 0 {
|
||||
if font < tt_n { return rt_text_w(font, s, size) }
|
||||
}
|
||||
let n = 0
|
||||
while peek8(s, n) != 0 { n = n + 1 }
|
||||
return n * 6 * max(size / 8, 1)
|
||||
}
|
||||
|
||||
fn ui_th(font: int, size: int) -> int {
|
||||
if font >= 0 {
|
||||
if font < tt_n { return rt_text_h(font, size) }
|
||||
}
|
||||
return 7 * max(size / 8, 1)
|
||||
}
|
||||
|
||||
fn ui_is_container(t: int) -> bool {
|
||||
if t == WT_PANEL { return true }
|
||||
if t == WT_COL { return true }
|
||||
if t == WT_ROW { return true }
|
||||
return false
|
||||
}
|
||||
fn ui_dir(t: int) -> int {
|
||||
if t == WT_ROW { return 0 }
|
||||
return 1
|
||||
}
|
||||
fn ui_under(i: int, root: int) -> bool {
|
||||
let k = i
|
||||
while k >= 0 {
|
||||
if k == root { return true }
|
||||
k = peek32(ui_parent, k)
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
# ---- measure: content sizes, children before parents ----------------------
|
||||
fn ui_measure() -> void {
|
||||
let i = ui_n - 1
|
||||
while i >= 0 {
|
||||
if peek32(ui_visible, i) == 0 {
|
||||
poke32(ui_rw, i, 0)
|
||||
poke32(ui_rh, i, 0)
|
||||
} else {
|
||||
let t = peek32(ui_type, i)
|
||||
let pad = peek32(ui_pad, i)
|
||||
let cw = 0
|
||||
let ch = 0
|
||||
if t == WT_LABEL { cw = 0 - 1 }
|
||||
if t == WT_BUTTON { cw = 0 - 1 }
|
||||
if cw == 0 - 1 {
|
||||
let s = ui_str(i)
|
||||
cw = ui_tw(peek32(ui_font, i), s, peek32(ui_size, i)) + 2 * pad
|
||||
ch = ui_th(peek32(ui_font, i), peek32(ui_size, i)) + 2 * pad
|
||||
if t == WT_BUTTON {
|
||||
cw = cw + 10
|
||||
ch = ch + 6
|
||||
}
|
||||
} else {
|
||||
if t == WT_IMAGE {
|
||||
let im = peek32(ui_img, i)
|
||||
if im >= 0 {
|
||||
cw = peek32(img_w, im)
|
||||
ch = peek32(img_h, im)
|
||||
}
|
||||
} else {
|
||||
if t == WT_SPACER {
|
||||
cw = peek32(ui_w, i)
|
||||
ch = peek32(ui_h, i)
|
||||
} else {
|
||||
let dir = ui_dir(t)
|
||||
let mainsz = 0
|
||||
let cross = 0
|
||||
let nc = 0
|
||||
for c in 0 .. ui_n {
|
||||
if peek32(ui_parent, c) == i {
|
||||
if peek32(ui_visible, c) == 1 {
|
||||
if dir == 1 {
|
||||
mainsz = mainsz + peek32(ui_rh, c)
|
||||
cross = max(cross, peek32(ui_rw, c))
|
||||
} else {
|
||||
mainsz = mainsz + peek32(ui_rw, c)
|
||||
cross = max(cross, peek32(ui_rh, c))
|
||||
}
|
||||
nc = nc + 1
|
||||
}
|
||||
}
|
||||
}
|
||||
if nc > 1 { mainsz = mainsz + peek32(ui_gap, i) * (nc - 1) }
|
||||
mainsz = mainsz + 2 * pad
|
||||
cross = cross + 2 * pad
|
||||
if dir == 1 {
|
||||
cw = cross
|
||||
ch = mainsz
|
||||
} else {
|
||||
cw = mainsz
|
||||
ch = cross
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
let rw = peek32(ui_w, i)
|
||||
let rh = peek32(ui_h, i)
|
||||
if rw == 0 { rw = cw }
|
||||
if rh == 0 { rh = ch }
|
||||
poke32(ui_rw, i, rw)
|
||||
poke32(ui_rh, i, rh)
|
||||
}
|
||||
i = i - 1
|
||||
}
|
||||
}
|
||||
|
||||
fn ui_eff_align(child: int, parent: int) -> int {
|
||||
if peek32(ui_align, child) >= 0 { return peek32(ui_align, child) }
|
||||
if peek32(ui_align, parent) >= 0 { return peek32(ui_align, parent) }
|
||||
return 0
|
||||
}
|
||||
|
||||
import "ui_draw.ludic"
|
||||
283
runtime/native/ui_draw.ludic
Normal file
283
runtime/native/ui_draw.ludic
Normal file
|
|
@ -0,0 +1,283 @@
|
|||
# ui_draw.ludic — layout arrange, drawing, focus/activation and the game-facing
|
||||
# accessors. Split out of ui.ludic (the storage/build/measure half).
|
||||
|
||||
# ---- arrange: rects, parents before children ------------------------------
|
||||
fn ui_arrange(i: int, x: int, y: int) -> void {
|
||||
poke32(ui_rx, i, x)
|
||||
poke32(ui_ry, i, y)
|
||||
let t = peek32(ui_type, i)
|
||||
if ui_is_container(t) == false { return }
|
||||
let dir = ui_dir(t)
|
||||
let pad = peek32(ui_pad, i)
|
||||
let gap = peek32(ui_gap, i)
|
||||
let innerw = peek32(ui_rw, i) - 2 * pad
|
||||
let innerh = peek32(ui_rh, i) - 2 * pad
|
||||
let total = 0
|
||||
let ng = 0
|
||||
let grows = 0
|
||||
for c in 0 .. ui_n {
|
||||
if peek32(ui_parent, c) == i {
|
||||
if peek32(ui_visible, c) == 1 {
|
||||
if dir == 1 { total = total + peek32(ui_rh, c) } else { total = total + peek32(ui_rw, c) }
|
||||
ng = ng + 1
|
||||
grows = grows + peek32(ui_grow, c)
|
||||
}
|
||||
}
|
||||
}
|
||||
if ng > 1 { total = total + gap * (ng - 1) }
|
||||
let avail = innerw
|
||||
if dir == 1 { avail = innerh }
|
||||
let extra = max(avail - total, 0)
|
||||
let cx = x + pad
|
||||
let cy = y + pad
|
||||
for c in 0 .. ui_n {
|
||||
if peek32(ui_parent, c) == i {
|
||||
if peek32(ui_visible, c) == 1 {
|
||||
let kw = peek32(ui_rw, c)
|
||||
let kh = peek32(ui_rh, c)
|
||||
if peek32(ui_grow, c) != 0 {
|
||||
if grows > 0 {
|
||||
if dir == 1 { kh = kh + extra / grows } else { kw = kw + extra / grows }
|
||||
}
|
||||
}
|
||||
let al = ui_eff_align(c, i)
|
||||
poke32(ui_rw, c, kw)
|
||||
poke32(ui_rh, c, kh)
|
||||
if dir == 1 {
|
||||
let ax = x + pad
|
||||
if al == 1 { ax = x + pad + (innerw - kw) / 2 }
|
||||
if al == 2 { ax = x + pad + (innerw - kw) }
|
||||
ui_arrange(c, ax, cy)
|
||||
cy = cy + kh + gap
|
||||
} else {
|
||||
let ay = y + pad
|
||||
if al == 1 { ay = y + pad + (innerh - kh) / 2 }
|
||||
if al == 2 { ay = y + pad + (innerh - kh) }
|
||||
ui_arrange(c, cx, ay)
|
||||
cx = cx + kw + gap
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn ui_layout() -> void {
|
||||
if ui_active < 0 { return }
|
||||
ui_measure()
|
||||
let px = (rt_fbw - peek32(ui_rw, ui_active)) / 2
|
||||
let py = (rt_fbh - peek32(ui_rh, ui_active)) / 2
|
||||
if peek32(ui_haspos, ui_active) == 1 {
|
||||
px = peek32(ui_x, ui_active)
|
||||
py = peek32(ui_y, ui_active)
|
||||
}
|
||||
ui_arrange(ui_active, px, py)
|
||||
}
|
||||
|
||||
# ---- drawing --------------------------------------------------------------
|
||||
fn ui_lighten(c: int) -> int {
|
||||
let r = band(shr(c, 16), 255)
|
||||
let g = band(shr(c, 8), 255)
|
||||
let b = band(c, 255)
|
||||
r = r + (255 - r) * 4 / 10
|
||||
g = g + (255 - g) * 4 / 10
|
||||
b = b + (255 - b) * 4 / 10
|
||||
return bor(bor(shl(r, 16), shl(g, 8)), b)
|
||||
}
|
||||
|
||||
fn ui_draw_node(i: int) -> void {
|
||||
if peek32(ui_visible, i) == 0 { return }
|
||||
let t = peek32(ui_type, i)
|
||||
let rx = peek32(ui_rx, i)
|
||||
let ry = peek32(ui_ry, i)
|
||||
let rw = peek32(ui_rw, i)
|
||||
let rh = peek32(ui_rh, i)
|
||||
let skin = peek32(ui_skin, i)
|
||||
let focused = 0
|
||||
if i == ui_focus { focused = 1 }
|
||||
|
||||
if t == WT_PANEL {
|
||||
if skin >= 0 {
|
||||
rt_draw_9slice(skin, rx, ry, rw, rh, peek32(ui_inset, i))
|
||||
} else {
|
||||
if peek32(ui_bg, i) >= 0 { rt_fill_rect(rx, ry, rw, rh, peek32(ui_bg, i)) }
|
||||
if peek32(ui_border, i) >= 0 { rt_frame_rect(rx, ry, rw, rh, peek32(ui_border, i)) }
|
||||
}
|
||||
}
|
||||
if t == WT_BUTTON {
|
||||
let bg = peek32(ui_bg, i)
|
||||
if bg < 0 { bg = 0x2a2a3a }
|
||||
if focused == 1 { bg = ui_lighten(bg) }
|
||||
if skin >= 0 {
|
||||
rt_draw_9slice(skin, rx, ry, rw, rh, peek32(ui_inset, i))
|
||||
} else {
|
||||
rt_fill_rect(rx, ry, rw, rh, bg)
|
||||
}
|
||||
let bc = peek32(ui_border, i)
|
||||
if bc < 0 { bc = 0x555577 }
|
||||
if focused == 1 { bc = 0xffff00 }
|
||||
rt_frame_rect(rx, ry, rw, rh, bc)
|
||||
let s = ui_str(i)
|
||||
let fg = peek32(ui_fg, i)
|
||||
if fg < 0 { fg = 0xffffff }
|
||||
let font = peek32(ui_font, i)
|
||||
let size = peek32(ui_size, i)
|
||||
ui_draw_text(font, rx + (rw - ui_tw(font, s, size)) / 2, ry + (rh - ui_th(font, size)) / 2, s, fg, size)
|
||||
}
|
||||
if t == WT_LABEL {
|
||||
let s = ui_str(i)
|
||||
let fg = peek32(ui_fg, i)
|
||||
if fg < 0 { fg = 0xffffff }
|
||||
let font = peek32(ui_font, i)
|
||||
let size = peek32(ui_size, i)
|
||||
let pad = peek32(ui_pad, i)
|
||||
let tw = ui_tw(font, s, size)
|
||||
let tx = rx + pad
|
||||
let al = peek32(ui_align, i)
|
||||
if al == 1 { tx = rx + (rw - tw) / 2 }
|
||||
if al == 2 { tx = rx + rw - pad - tw }
|
||||
ui_draw_text(font, tx, ry + pad, s, fg, size)
|
||||
}
|
||||
if t == WT_IMAGE {
|
||||
if peek32(ui_img, i) >= 0 { rt_draw_image_scaled(peek32(ui_img, i), rx, ry, rw, rh) }
|
||||
}
|
||||
for c in 0 .. ui_n {
|
||||
if peek32(ui_parent, c) == i { ui_draw_node(c) }
|
||||
}
|
||||
}
|
||||
|
||||
# ---- focus and activation -------------------------------------------------
|
||||
var ui_fl: ptr = ptr_null()
|
||||
|
||||
fn ui_focusables() -> int {
|
||||
if ptr_is_null(ui_fl) { ui_fl = mem_alloc(UI_MAX * 4) }
|
||||
let n = 0
|
||||
for i in 0 .. ui_n {
|
||||
if peek32(ui_focusable, i) == 1 {
|
||||
if peek32(ui_visible, i) == 1 {
|
||||
if ui_under(i, ui_active) {
|
||||
poke32(ui_fl, n, i)
|
||||
n = n + 1
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return n
|
||||
}
|
||||
|
||||
fn rt_ui_open(root: int) -> void {
|
||||
ui_active = root
|
||||
let n = ui_focusables()
|
||||
ui_focus = 0 - 1
|
||||
if n > 0 { ui_focus = peek32(ui_fl, 0) }
|
||||
}
|
||||
|
||||
fn rt_ui_tick(k: int) -> void {
|
||||
if ui_active < 0 { return }
|
||||
for i in 0 .. ui_n { poke32(ui_fired, i, 0) }
|
||||
ui_layout()
|
||||
let n = ui_focusables()
|
||||
if n == 0 {
|
||||
ui_focus = 0 - 1
|
||||
return
|
||||
}
|
||||
let cur = 0 - 1
|
||||
for i in 0 .. n {
|
||||
if peek32(ui_fl, i) == ui_focus { cur = i }
|
||||
}
|
||||
if cur < 0 {
|
||||
cur = 0
|
||||
ui_focus = peek32(ui_fl, 0)
|
||||
}
|
||||
if k == 119 { # 'w'
|
||||
cur = (cur - 1 + n) % n
|
||||
ui_focus = peek32(ui_fl, cur)
|
||||
}
|
||||
if k == 115 { # 's'
|
||||
cur = (cur + 1) % n
|
||||
ui_focus = peek32(ui_fl, cur)
|
||||
}
|
||||
if k == 32 { poke32(ui_fired, ui_focus, 1) }
|
||||
if k == 10 { poke32(ui_fired, ui_focus, 1) }
|
||||
if k == 13 { poke32(ui_fired, ui_focus, 1) }
|
||||
}
|
||||
|
||||
fn rt_ui_render() -> void {
|
||||
if ui_active < 0 { return }
|
||||
ui_layout()
|
||||
ui_draw_node(ui_active)
|
||||
}
|
||||
|
||||
# ---- game-facing accessors ------------------------------------------------
|
||||
fn rt_ui_clicked(id: int) -> bool {
|
||||
if id < 0 { return false }
|
||||
if id >= ui_n { return false }
|
||||
return peek32(ui_fired, id) == 1
|
||||
}
|
||||
|
||||
fn rt_ui_set_text(id: int, s: str) -> void {
|
||||
if id < 0 { return }
|
||||
if id >= ui_n { return }
|
||||
let base = id * 96
|
||||
let i = 0
|
||||
let ch = peek8(s, 0)
|
||||
while ch != 0 {
|
||||
if i >= 95 { ch = 0 }
|
||||
if ch != 0 {
|
||||
poke8(ui_dyn, base + i, ch)
|
||||
i = i + 1
|
||||
ch = peek8(s, i)
|
||||
}
|
||||
}
|
||||
poke8(ui_dyn, base + i, 0)
|
||||
poke32(ui_hasdyn, id, 1)
|
||||
}
|
||||
|
||||
fn rt_ui_set_int(id: int, n: int) -> void {
|
||||
if id < 0 { return }
|
||||
if id >= ui_n { return }
|
||||
let base = id * 96
|
||||
let at = 0
|
||||
let v = n
|
||||
if v < 0 {
|
||||
poke8(ui_dyn, base, 45)
|
||||
at = 1
|
||||
v = 0 - v
|
||||
}
|
||||
if v == 0 {
|
||||
poke8(ui_dyn, base + at, 48)
|
||||
at = at + 1
|
||||
} else {
|
||||
let digits = 0
|
||||
let t = v
|
||||
while t > 0 {
|
||||
digits = digits + 1
|
||||
t = t / 10
|
||||
}
|
||||
let p = digits
|
||||
while p > 0 {
|
||||
let div = 1
|
||||
for k in 1 .. p { div = div * 10 }
|
||||
poke8(ui_dyn, base + at, 48 + (v / div) % 10)
|
||||
at = at + 1
|
||||
p = p - 1
|
||||
}
|
||||
}
|
||||
poke8(ui_dyn, base + at, 0)
|
||||
poke32(ui_hasdyn, id, 1)
|
||||
}
|
||||
|
||||
fn rt_ui_focus(id: int) -> void {
|
||||
if id < 0 { return }
|
||||
if id >= ui_n { return }
|
||||
ui_focus = id
|
||||
}
|
||||
|
||||
fn rt_ui_focused() -> int {
|
||||
return ui_focus
|
||||
}
|
||||
|
||||
fn rt_ui_visible(id: int, v: int) -> void {
|
||||
if id < 0 { return }
|
||||
if id >= ui_n { return }
|
||||
poke32(ui_visible, id, v)
|
||||
}
|
||||
Loading…
Add table
Add a link
Reference in a new issue