5cc45a2b38
items is now a []T slice whose .len IS the live element count (cap = allocated
capacity), so a List iterates directly: `for xs.items (e) { ... }`. A
`len :: (self) -> i64 #get => items.len` accessor keeps `xs.len` reads working;
`.len` WRITES become `.items.len`. List stays 24 bytes (`[]T`=16 + cap=8).
- list.sx: append/ensure_capacity/deinit rewritten for the slice backing. deinit
guards the free on `cap > 0` (true ownership) and resets via explicit
ptr=null/len=0 (a `.{}` slice assignment yields a garbage len; `.[]` is the
empty-slice literal but can't be assigned to a generic []T — both worked around).
- Compiler coupling updated: comptime_vm makeStringList/readStringList write/read
items as a {ptr,len} fat pointer at field 0 + cap at field 1; control_flow
listView views an `items: []T` slice (keeps the legacy {[*]T,len} shape too).
- Migrated List `.len` writes to `.items.len` in sched.sx + ui/{render,pipeline,
glyph_cache} + platform/{sdl3,android,uikit}.
- Snapshots: List's type-table layout changed → ~40 .ir + memory/0800 (items now
prints as a slice) regenerated; diagnostics/1183 retargeted to a genuine
many-pointer (xs.items is a slice now). Example memory/0840 locks for-each.
180 lines
4.2 KiB
Plaintext
Executable File
180 lines
4.2 KiB
Plaintext
Executable File
#import "modules/std.sx";
|
|
#import "modules/ui/types.sx";
|
|
|
|
RenderNodeType :: enum {
|
|
rect;
|
|
rounded_rect;
|
|
text;
|
|
image;
|
|
clip_push;
|
|
clip_pop;
|
|
opacity_push;
|
|
opacity_pop;
|
|
}
|
|
|
|
RenderNode :: struct {
|
|
type: RenderNodeType;
|
|
frame: Frame;
|
|
|
|
// Rect / rounded_rect
|
|
fill_color: Color;
|
|
stroke_color: Color;
|
|
stroke_width: f32;
|
|
corner_radius: f32;
|
|
|
|
// Text
|
|
text: string;
|
|
font_size: f32;
|
|
text_color: Color;
|
|
|
|
// Image
|
|
texture_id: u32;
|
|
uv_min: Point;
|
|
uv_max: Point;
|
|
|
|
// Opacity
|
|
opacity: f32;
|
|
|
|
depth: i64;
|
|
}
|
|
|
|
RenderTree :: struct {
|
|
nodes: List(RenderNode);
|
|
generation: i64;
|
|
|
|
init :: () -> RenderTree {
|
|
RenderTree.{ generation = 0 }
|
|
}
|
|
|
|
clear :: (self: *RenderTree) {
|
|
self.nodes.items.len = 0;
|
|
self.generation += 1;
|
|
}
|
|
|
|
add :: (self: *RenderTree, node: RenderNode) -> i64 {
|
|
idx := self.nodes.len;
|
|
self.nodes.append(node);
|
|
idx
|
|
}
|
|
}
|
|
|
|
// Stateful builder — views use this to emit render nodes
|
|
|
|
RenderContext :: struct {
|
|
tree: *RenderTree;
|
|
clip_depth: i64;
|
|
opacity: f32;
|
|
depth: i64;
|
|
|
|
init :: (tree: *RenderTree) -> RenderContext {
|
|
RenderContext.{
|
|
tree = tree,
|
|
clip_depth = 0,
|
|
opacity = 1.0,
|
|
depth = 0
|
|
}
|
|
}
|
|
|
|
add_rect :: (self: *RenderContext, frame: Frame, fill: Color) {
|
|
self.tree.add(.{
|
|
type = .rect,
|
|
frame = frame,
|
|
fill_color = fill,
|
|
opacity = self.opacity,
|
|
depth = self.depth,
|
|
});
|
|
self.depth += 1;
|
|
}
|
|
|
|
add_rounded_rect :: (self: *RenderContext, frame: Frame, fill: Color, radius: f32) {
|
|
self.tree.add(.{
|
|
type = .rounded_rect,
|
|
frame = frame,
|
|
fill_color = fill,
|
|
corner_radius = radius,
|
|
opacity = self.opacity,
|
|
depth = self.depth,
|
|
});
|
|
self.depth += 1;
|
|
}
|
|
|
|
add_stroked_rect :: (self: *RenderContext, frame: Frame, fill: Color, stroke: Color, stroke_w: f32, radius: f32) {
|
|
self.tree.add(.{
|
|
type = .rounded_rect,
|
|
frame = frame,
|
|
fill_color = fill,
|
|
stroke_color = stroke,
|
|
stroke_width = stroke_w,
|
|
corner_radius = radius,
|
|
opacity = self.opacity,
|
|
depth = self.depth,
|
|
});
|
|
self.depth += 1;
|
|
}
|
|
|
|
add_text :: (self: *RenderContext, frame: Frame, text: string, font_size: f32, color: Color) {
|
|
self.tree.add(.{
|
|
type = .text,
|
|
frame = frame,
|
|
text = text,
|
|
font_size = font_size,
|
|
text_color = color,
|
|
opacity = self.opacity,
|
|
depth = self.depth,
|
|
});
|
|
self.depth += 1;
|
|
}
|
|
|
|
add_image :: (self: *RenderContext, frame: Frame, texture_id: u32) {
|
|
self.add_image_uv(frame, texture_id, Point.zero(), Point.{ x = 1.0, y = 1.0 });
|
|
}
|
|
|
|
add_image_uv :: (self: *RenderContext, frame: Frame, texture_id: u32, uv_min: Point, uv_max: Point) {
|
|
self.tree.add(.{
|
|
type = .image,
|
|
frame = frame,
|
|
texture_id = texture_id,
|
|
uv_min = uv_min,
|
|
uv_max = uv_max,
|
|
opacity = self.opacity,
|
|
depth = self.depth,
|
|
});
|
|
self.depth += 1;
|
|
}
|
|
|
|
push_clip :: (self: *RenderContext, frame: Frame) {
|
|
self.tree.add(.{
|
|
type = .clip_push,
|
|
frame = frame,
|
|
depth = self.depth,
|
|
});
|
|
self.clip_depth += 1;
|
|
}
|
|
|
|
pop_clip :: (self: *RenderContext) {
|
|
self.tree.add(.{
|
|
type = .clip_pop,
|
|
depth = self.depth,
|
|
});
|
|
self.clip_depth -= 1;
|
|
}
|
|
|
|
push_opacity :: (self: *RenderContext, alpha: f32) {
|
|
prev := self.opacity;
|
|
self.opacity = prev * alpha;
|
|
self.tree.add(.{
|
|
type = .opacity_push,
|
|
opacity = self.opacity,
|
|
depth = self.depth,
|
|
});
|
|
}
|
|
|
|
pop_opacity :: (self: *RenderContext, prev_opacity: f32) {
|
|
self.tree.add(.{
|
|
type = .opacity_pop,
|
|
depth = self.depth,
|
|
});
|
|
self.opacity = prev_opacity;
|
|
}
|
|
}
|