forked from AbleOS/ableos
441 lines
10 KiB
Plaintext
441 lines
10 KiB
Plaintext
.{math, memory, dt} := @use("stn");
|
|
.{Color, text} := @use("lib:render");
|
|
.{get_glyph, get_glyph_unicode, Font, UNC_TABLE_SIZE} := text;
|
|
.{Vec2} := math
|
|
|
|
// safety: don't use before init() or you will get a memory access violation
|
|
framebuffer := memory.dangling(Color)
|
|
utf8_len_table := [u8].(0, 0, 2, 3)
|
|
|
|
init := fn(doublebuffer: bool): Surface {
|
|
framebuffer = dt.get(^Color, "framebuffer/fb0/ptr\0")
|
|
width := dt.get(uint, "framebuffer/fb0/width\0")
|
|
height := dt.get(uint, "framebuffer/fb0/height\0")
|
|
if doublebuffer {
|
|
return Surface.new(width, height)
|
|
} else {
|
|
return .(framebuffer, width, height, width * height)
|
|
}
|
|
}
|
|
|
|
Surface := struct {
|
|
buf: ^Color,
|
|
width: uint,
|
|
height: uint,
|
|
size: uint,
|
|
|
|
new := fn(width: uint, height: uint): Self {
|
|
size := width * height
|
|
return .(
|
|
memory.alloc(Color, size),
|
|
width,
|
|
height,
|
|
size,
|
|
)
|
|
}
|
|
|
|
clone := fn(self: ^Self): Self {
|
|
new_self := Self.new(self.width, self.height)
|
|
memory.copy(Color, self.buf, new_self.buf, self.size)
|
|
return new_self
|
|
}
|
|
$clear := fn(self: Self, color: Color): void {
|
|
memory.set(Color, &color, self.buf, self.size)
|
|
}
|
|
|
|
$sync := fn(self: Self): void {
|
|
memory.copy(Color, self.buf, framebuffer, self.size)
|
|
}
|
|
|
|
$index := fn(self: Self, x: uint, y: uint): uint {
|
|
return x + self.width * y
|
|
}
|
|
|
|
$indexptr := fn(self: Self, x: uint, y: uint): ^Color {
|
|
return self.buf + self.index(x, y)
|
|
}
|
|
|
|
$put_pixel := fn(self: Self, pos: Vec2(uint), color: Color): void {
|
|
*self.indexptr(pos.x, pos.y) = color
|
|
}
|
|
|
|
put_filled_rect := fn(self: Self, pos: Vec2(uint), tr: Vec2(uint), color: Color): void {
|
|
top_start_idx := self.indexptr(pos.x, pos.y)
|
|
bottom_start_idx := self.indexptr(pos.x, pos.y + tr.y - 1)
|
|
rows_to_fill := tr.y
|
|
|
|
loop if rows_to_fill <= 1 break else {
|
|
memory.set(Color, &color, top_start_idx, tr.x)
|
|
memory.set(Color, &color, bottom_start_idx, tr.x)
|
|
|
|
top_start_idx += self.width
|
|
bottom_start_idx -= self.width
|
|
rows_to_fill -= 2
|
|
}
|
|
|
|
if rows_to_fill == 1 {
|
|
memory.set(Color, &color, top_start_idx, tr.x)
|
|
}
|
|
}
|
|
|
|
put_rect := fn(self: Self, pos: Vec2(uint), tr: Vec2(uint), color: Color): void {
|
|
start_idx := self.indexptr(pos.x, pos.y)
|
|
end_idx := self.indexptr(pos.x, pos.y + tr.y)
|
|
right_start_idx := self.indexptr(pos.x + tr.x, pos.y)
|
|
|
|
loop if start_idx > end_idx break else {
|
|
*start_idx = color;
|
|
*right_start_idx = color
|
|
start_idx += self.width
|
|
right_start_idx += self.width
|
|
}
|
|
|
|
memory.set(Color, &color, self.indexptr(pos.x, pos.y), @bitcast(tr.x + 1))
|
|
memory.set(Color, &color, self.indexptr(pos.x, pos.y + tr.y), @bitcast(tr.x + 1))
|
|
}
|
|
|
|
put_line_low := fn(self: Self, p0: Vec2(uint), p1: Vec2(uint), color: Color): void {
|
|
dx := @as(int, @bitcast(p1.x - p0.x))
|
|
dy := @as(int, @bitcast(p1.y - p0.y))
|
|
yi := 1
|
|
if dy < 0 {
|
|
yi = -1
|
|
dy = -dy
|
|
}
|
|
D := @as(int, 2) * dy - dx
|
|
y := p0.y
|
|
x := p0.x
|
|
loop if x == p1.x break else {
|
|
*self.indexptr(x, y) = color
|
|
if D > 0 {
|
|
y += yi
|
|
D += 2 * (dy - dx)
|
|
} else {
|
|
D += 2 * dy
|
|
}
|
|
x += 1
|
|
}
|
|
}
|
|
|
|
put_line_high := fn(self: Self, p0: Vec2(uint), p1: Vec2(uint), color: Color): void {
|
|
dx := @as(int, @bitcast(p1.x - p0.x))
|
|
dy := @as(int, @bitcast(p1.y - p0.y))
|
|
xi := 1
|
|
if dy < 0 {
|
|
xi = -1
|
|
dx = -dx
|
|
}
|
|
D := @as(int, 2) * dx - dy
|
|
x := p0.x
|
|
y := p0.y
|
|
loop if y == p1.y break else {
|
|
*self.indexptr(x, y) = color
|
|
if D > 0 {
|
|
x += xi
|
|
D += 2 * (dx - dy)
|
|
} else {
|
|
D += 2 * dx
|
|
}
|
|
y += 1
|
|
}
|
|
}
|
|
|
|
put_line := fn(self: Self, p0: Vec2(uint), p1: Vec2(uint), color: Color): void {
|
|
if math.abs(int, @bitcast(p1.y - p0.y)) < math.abs(int, @bitcast(p1.x - p0.x)) {
|
|
if p0.x > p1.x {
|
|
@inline(put_line_low, self, p1, p0, color)
|
|
} else {
|
|
@inline(put_line_low, self, p0, p1, color)
|
|
}
|
|
} else {
|
|
if p0.y > p1.y {
|
|
@inline(put_line_high, self, p1, p0, color)
|
|
} else {
|
|
@inline(put_line_high, self, p0, p1, color)
|
|
}
|
|
}
|
|
}
|
|
|
|
put_surface := fn(self: Self, top: Self, pos: Vec2(uint), flip_v: bool): void {
|
|
src_top_cursor := top.buf
|
|
src_bottom_cursor := top.buf + top.width * (top.height - 1)
|
|
|
|
dst_top_idx := self.indexptr(pos.x, pos.y)
|
|
dst_bottom_idx := self.indexptr(pos.x, pos.y + top.height - 1)
|
|
|
|
dst_increment := self.width
|
|
|
|
if flip_v {
|
|
dst_increment = -dst_increment
|
|
tmp := dst_top_idx
|
|
dst_top_idx = dst_bottom_idx
|
|
dst_bottom_idx = tmp
|
|
}
|
|
|
|
rows_to_copy := top.height
|
|
|
|
loop if rows_to_copy <= 1 break else {
|
|
memory.copy(Color, src_top_cursor, dst_top_idx, top.width)
|
|
memory.copy(Color, src_bottom_cursor, dst_bottom_idx, top.width)
|
|
|
|
dst_top_idx += dst_increment
|
|
dst_bottom_idx -= dst_increment
|
|
src_top_cursor += top.width
|
|
src_bottom_cursor -= top.width
|
|
rows_to_copy -= 2
|
|
}
|
|
|
|
if rows_to_copy == 1 {
|
|
memory.copy(Color, src_top_cursor, dst_top_idx, top.width)
|
|
}
|
|
}
|
|
|
|
// peony-made
|
|
put_trirect := fn(self: Self, pos: Vec2(uint), size: Vec2(int), color0: Color, color1: Color): void {
|
|
step := Vec2(int).(1, 1)
|
|
if size.x < 0 {
|
|
step.x = -1
|
|
}
|
|
if size.y < 0 {
|
|
step.y /= @bitcast(size.x)
|
|
}
|
|
|
|
start_y := pos.y
|
|
target := pos + @bitcast(size)
|
|
|
|
loop if pos.x == target.x break else {
|
|
@inline(put_vline, self, pos.x, pos.y, target.y, color0)
|
|
@inline(put_vline, self, pos.x, pos.y, start_y, color1)
|
|
pos += @bitcast(step)
|
|
}
|
|
}
|
|
|
|
// peony-made
|
|
put_vline := fn(self: Self, x: uint, y0: uint, y1: uint, color: Color): void {
|
|
if y1 < y0 {
|
|
tmp := y0
|
|
y0 = y1
|
|
y1 = tmp
|
|
}
|
|
y := y0
|
|
|
|
loop if y == y1 break else {
|
|
*self.indexptr(x, y) = color
|
|
y += 1
|
|
}
|
|
}
|
|
|
|
// peony-made
|
|
put_hline := fn(self: Self, y: uint, x0: uint, x1: uint, color: Color): void {
|
|
if x1 < x0 {
|
|
tmp := x0
|
|
x0 = x1
|
|
x1 = tmp
|
|
}
|
|
memory.set(Color, &color, self.indexptr(x0, y), @bitcast(x1 - x0))
|
|
}
|
|
|
|
put_circle := fn(self: Self, pos: Vec2(uint), radius: uint, color: Color): void {
|
|
x := 0
|
|
y := radius
|
|
error := @as(int, 3) - 2 * @intcast(radius)
|
|
loop if x > y break else {
|
|
self.put_pixel(pos + .(x, y), color)
|
|
self.put_pixel(pos + .(-x, y), color)
|
|
self.put_pixel(pos + .(x, -y), color)
|
|
self.put_pixel(pos + .(-x, -y), color)
|
|
self.put_pixel(pos + .(y, x), color)
|
|
self.put_pixel(pos + .(-y, x), color)
|
|
self.put_pixel(pos + .(y, -x), color)
|
|
self.put_pixel(pos + .(-y, -x), color)
|
|
if error < 0 {
|
|
error += 4 * @intcast(x) + 6
|
|
} else {
|
|
error += 4 * (@intcast(x) - @intcast(y)) + 10
|
|
y -= 1
|
|
}
|
|
x += 1
|
|
}
|
|
}
|
|
|
|
put_filled_circle := fn(self: Self, pos: Vec2(uint), radius: uint, color: Color): void {
|
|
x := 0
|
|
y := radius
|
|
error := @as(int, 3) - 2 * @intcast(radius)
|
|
|
|
loop if x > y break else {
|
|
self.put_hline(pos.y + y, pos.x - x, pos.x + x, color)
|
|
self.put_hline(pos.y - y, pos.x - x, pos.x + x, color)
|
|
|
|
if x != y {
|
|
self.put_hline(pos.y + x, pos.x - y, pos.x + y, color)
|
|
self.put_hline(pos.y - x, pos.x - y, pos.x + y, color)
|
|
}
|
|
|
|
if error < 0 {
|
|
error += 4 * @intcast(x) + 6
|
|
} else {
|
|
error += 4 * (@intcast(x) - @intcast(y)) + 10
|
|
y -= 1
|
|
}
|
|
x += 1
|
|
}
|
|
}
|
|
|
|
put_textured_circle := fn(self: Self, source: Self, source_pos: Vec2(uint), pos: Vec2(uint), radius: uint): void {
|
|
x := 0
|
|
y := radius
|
|
error := @as(int, 3) - 2 * @intcast(radius)
|
|
|
|
loop if x > y break else {
|
|
memory.copy(Color, source.indexptr(source_pos.x - x, source_pos.y + y), self.indexptr(pos.x - x, pos.y + y), 2 * x)
|
|
memory.copy(Color, source.indexptr(source_pos.x - x, source_pos.y - y), self.indexptr(pos.x - x, pos.y - y), 2 * x)
|
|
|
|
if x != y {
|
|
memory.copy(Color, source.indexptr(source_pos.x - y, source_pos.y + x), self.indexptr(pos.x - y, pos.y + x), 2 * y)
|
|
memory.copy(Color, source.indexptr(source_pos.x - y, source_pos.y - x), self.indexptr(pos.x - y, pos.y - x), 2 * y)
|
|
}
|
|
|
|
if error < 0 {
|
|
error += 4 * @intcast(x) + 6
|
|
} else {
|
|
error += 4 * (@intcast(x) - @intcast(y)) + 10
|
|
y -= 1
|
|
}
|
|
x += 1
|
|
}
|
|
}
|
|
|
|
put_text := fn(self: Self, font: Font, pos: Vec2(uint), color: Color, str: ^u8): void {
|
|
cursor := Vec2(uint).(pos.x, pos.y)
|
|
|
|
max_y := self.height - font.height
|
|
next_line_y := font.height + font.line_gap
|
|
char_advance := font.width + font.char_gap
|
|
self_width := self.width
|
|
|
|
loop if *str == 0 break else {
|
|
if cursor.y > max_y break
|
|
|
|
glyph_data := @as(^u8, idk)
|
|
code_point := @as(uint, 0)
|
|
|
|
if (*str & 0x80) == 0 {
|
|
if *str == 10 {
|
|
cursor.x = pos.x
|
|
cursor.y += next_line_y
|
|
str += 1
|
|
continue
|
|
}
|
|
|
|
if font.unicode == null {
|
|
if *str > font.num_glyphs {
|
|
str += 1
|
|
continue
|
|
}
|
|
glyph_data = get_glyph(font, *str)
|
|
} else {
|
|
if *str < UNC_TABLE_SIZE {
|
|
glyph_index := *(font.unicode + *str)
|
|
if glyph_index == 0xFFFF {
|
|
str += 1
|
|
continue
|
|
}
|
|
glyph_data = font.data + glyph_index * font.bytes_per_glyph
|
|
} else {
|
|
str += 1
|
|
continue
|
|
}
|
|
}
|
|
str += 1
|
|
} else if font.unicode != null {
|
|
first_byte := *str
|
|
num_bytes := @as(uint, 0)
|
|
|
|
num_bytes = utf8_len_table[first_byte >> 5 & 0x3]
|
|
|
|
if num_bytes == 0 {
|
|
str += 1
|
|
continue
|
|
}
|
|
|
|
code_point = first_byte & (0x7F >> num_bytes | 0x1F)
|
|
|
|
valid_sequence := true
|
|
bytes_processed := 1
|
|
|
|
loop if bytes_processed >= num_bytes break else {
|
|
str += 1
|
|
if *str == 0 | (*str & 0xC0) != 0x80 {
|
|
valid_sequence = false
|
|
}
|
|
if valid_sequence == false {
|
|
break
|
|
}
|
|
code_point = code_point << 6 | *str & 0x3F
|
|
bytes_processed += 1
|
|
}
|
|
|
|
if valid_sequence == false {
|
|
str += 1
|
|
continue
|
|
}
|
|
|
|
str += 1
|
|
|
|
if code_point == 10 {
|
|
cursor.x = pos.x
|
|
cursor.y += next_line_y
|
|
continue
|
|
}
|
|
|
|
if code_point >= UNC_TABLE_SIZE {
|
|
continue
|
|
}
|
|
|
|
glyph_index := *(font.unicode + code_point)
|
|
if glyph_index == 0xFFFF {
|
|
continue
|
|
}
|
|
glyph_data = font.data + glyph_index * font.bytes_per_glyph
|
|
}
|
|
|
|
if cursor.x + font.width >= self_width {
|
|
cursor.x = pos.x
|
|
cursor.y += next_line_y
|
|
}
|
|
|
|
dest := self.indexptr(cursor.x, cursor.y)
|
|
rows := font.height
|
|
|
|
loop if rows == 0 break else {
|
|
byte := *glyph_data
|
|
pixel_dest := dest
|
|
mask := @as(u8, 0x80)
|
|
bits := font.width
|
|
|
|
loop if bits == 0 break else {
|
|
if (byte & mask) != 0 {
|
|
*pixel_dest = color
|
|
}
|
|
pixel_dest += 1
|
|
mask >>= 1
|
|
if mask == 0 & bits > 0 {
|
|
glyph_data += 1
|
|
byte = *glyph_data
|
|
mask = 0x80
|
|
}
|
|
bits -= 1
|
|
}
|
|
|
|
if mask != 0x80 {
|
|
glyph_data += 1
|
|
}
|
|
dest += self_width
|
|
rows -= 1
|
|
}
|
|
|
|
cursor.x += char_advance
|
|
}
|
|
}
|
|
} |