tiny.gui.surface

1pub const Capacity = struct {2    nodes: usize,3    runs: usize,4    styles: usize,5    images: usize,6    image_pixels: usize,7    semantic_bytes: usize,8    surface_offset: usize,9    surface_bytes: usize,10    node_offset: usize,11    node_slots: usize,12    node_bytes: usize,13    run_offset: usize,14    run_slots: usize,15    run_bytes: usize,16    style_offset: usize,17    style_slots: usize,18    style_bytes: usize,19    image_offset: usize,20    image_slots: usize,21    image_bytes: usize,22    image_pixel_offset: usize,23    image_pixel_slots: usize,24    image_pixel_bytes: usize,25    semantic_offset: usize,26    storage_bytes: usize,2728    pub fn derive(limits: Limits) DeriveError!Capacity {29        if (limits.nodes == 0) return error.InvalidNodeLimit;30        const surface = try placed(UiSurfaceTree, 0, 1);31        const nodes = try placed(UiNode, surface.end, limits.nodes - 1);32        const runs = try placed(UiTextRun, nodes.end, limits.runs);33        const styles = try placed(UiTextStyle, runs.end, limits.styles);34        const images = try placed(UiImage, styles.end, limits.images);35        const image_pixels = try placed(u32, images.end, limits.image_pixels);36        const semantics = try placed(u8, image_pixels.end, limits.semantic_bytes);37        return .{38            .nodes = limits.nodes,39            .runs = limits.runs,40            .styles = limits.styles,41            .images = limits.images,42            .image_pixels = limits.image_pixels,43            .semantic_bytes = limits.semantic_bytes,44            .surface_offset = surface.start,45            .surface_bytes = surface.bytes,46            .node_offset = nodes.start,47            .node_slots = limits.nodes - 1,48            .node_bytes = nodes.bytes,49            .run_offset = runs.start,50            .run_slots = limits.runs,51            .run_bytes = runs.bytes,52            .style_offset = styles.start,53            .style_slots = limits.styles,54            .style_bytes = styles.bytes,55            .image_offset = images.start,56            .image_slots = limits.images,57            .image_bytes = images.bytes,58            .image_pixel_offset = image_pixels.start,59            .image_pixel_slots = limits.image_pixels,60            .image_pixel_bytes = image_pixels.bytes,61            .semantic_offset = semantics.start,62            .storage_bytes = semantics.end,63        };64    }6566    pub fn admits(self: Capacity, facts: Facts) bool {67        return self.toLimits().admits(facts);68    }6970    pub fn toLimits(self: Capacity) Limits {71        return .{72            .nodes = self.nodes,73            .runs = self.runs,74            .styles = self.styles,75            .images = self.images,76            .image_pixels = self.image_pixels,77            .semantic_bytes = self.semantic_bytes,78        };79    }80};

1pub const DeriveError = error{2    InvalidNodeLimit,3    CapacityOverflow,4};

1pub const Facts = struct {2    nodes: usize = 0,3    runs: usize = 0,4    styles: usize = 0,5    images: usize = 0,6    image_pixels: usize = 0,7    semantic_bytes: usize = 0,8};

1pub const Limits = struct {2    nodes: usize,3    runs: usize = 0,4    styles: usize = 0,5    images: usize = 0,6    image_pixels: usize = 0,7    semantic_bytes: usize,89    pub fn admits(self: Limits, facts: Facts) bool {10        return facts.nodes <= self.nodes and11            facts.runs <= self.runs and12            facts.styles <= self.styles and13            facts.images <= self.images and14            facts.image_pixels <= self.image_pixels and15            facts.semantic_bytes <= self.semantic_bytes;16    }17};

1pub const CommandUiColor = extern struct {2    r: u8,3    g: u8,4    b: u8,5    a: u8,6};

1pub const CommandUiImage = extern struct {2    width: u32,3    height: u32,4    pixels_ptr: ?[*]const u32,5    pixels_len: usize,6};

1pub const CommandUiImagePaint = extern struct {2    is_set: u8,3    index: u32,4    source: CommandUiRect,5    tint: CommandUiOptionalColor,6    opacity: u8,7};

1pub const CommandUiLinearGradient = extern struct {2    is_set: u8,3    start: CommandUiPoint,4    end: CommandUiPoint,5    start_color: CommandUiColor,6    end_color: CommandUiColor,7};

1pub const CommandUiNode = extern struct {2    widget_id: u64,3    kind: u8,4    focusable: u8,5    style: CommandUiStyle,6    size: CommandUiDimensions,7    paint: CommandUiPaint,8    text_ptr: ?*const CommandUiText,9    children_ptr: ?[*]const CommandUiNode,10    children_len: usize,11    action_ptr: ?[*]const u8,12    action_len: usize,13    role_ptr: ?[*]const u8,14    role_len: usize,15    state_flags: u64,16    text_selection: CommandUiTextSelection,17};

1pub const CommandUiPaint = extern struct {2    background: CommandUiOptionalColor,3    linear_gradient: CommandUiLinearGradient,4    foreground: CommandUiOptionalColor,5    border: CommandUiOptionalColor,6    border_width: f32,7    corner_roundness: f32,8    border_edges: CommandUiBorderPaint,9    shadow: CommandUiShadowPaint,10    image: CommandUiImagePaint,11};

1pub const CommandUiPoint = extern struct {2    x: f32,3    y: f32,4};

1pub const CommandUiRect = extern struct {2    x: f32,3    y: f32,4    width: f32,5    height: f32,6};

1pub const CommandUiSurface = extern struct {2    available_width: f32,3    available_height: f32,4    root_ptr: ?*const CommandUiNode,5    images_ptr: ?[*]const CommandUiImage,6    images_len: usize,7};

1pub const CommandUiText = extern struct {2    content_ptr: ?[*]const u8,3    content_len: usize,4    runs_ptr: ?[*]const CommandUiTextRun,5    runs_len: usize,6    styles_ptr: ?[*]const CommandUiTextStyle,7    styles_len: usize,8    font_asset_id: u64,9    font_weight: u16,10    point_size: f64,11    line_height: f64,12    wrap_width: f64,13    horizontal_align: u8,14    vertical_align: u8,15};

1pub const CommandUiTextRun = extern struct {2    byte_start: usize,3    byte_end: usize,4    style_slot: u16,5    foreground: CommandUiOptionalColor,6    background: CommandUiOptionalColor,7    underline: u8,8    strikethrough: u8,9};

1pub const CommandUiTextStyle = extern struct {2    font_asset_id: u64,3    point_size: f64,4};

1pub const Placement = struct {2    limits: capacity_mod.Limits,3    bytes: []align(capacity_mod.storage_alignment) u8,4    surface: ?Surface = null,5    facts: capacity_mod.Facts = .{},67    pub fn init(8        bytes: []align(capacity_mod.storage_alignment) u8,9        capacity: capacity_mod.Capacity,10    ) Placement {11        std.debug.assert(bytes.len == capacity.storage_bytes);12        return .{ .limits = capacity.toLimits(), .bytes = bytes };13    }1415    pub inline fn cloneSurface(self: *Placement, src: Surface) CloneError!Surface {16        const facts = try survey.surface(src);17        if (!self.limits.admits(facts)) return error.SurfaceCapacityExceeded;18        return self.placeSurface(src, facts);19    }2021    pub fn cloneCommandSurface(22        self: *Placement,23        src: *const command.CommandUiSurface,24    ) CloneError!Surface {25        const facts = try survey.commandSurface(src);26        if (!self.limits.admits(facts)) return error.SurfaceCapacityExceeded;27        return self.placeCommandSurface(src, facts);28    }2930    pub fn reset(self: *Placement) void {31        self.surface = null;32        self.facts = .{};33    }3435    pub fn current(self: *const Placement) ?Surface {36        return self.surface;37    }3839    pub inline fn currentPtr(self: *const Placement) ?*const Surface {40        if (self.surface) |*value| return value;41        return null;42    }4344    pub inline fn hasSurface(self: *const Placement) bool {45        return self.surface != null;46    }4748    pub fn status(self: *const Placement) PlacementStatus {49        return .{50            .capacity = self.derivedCapacity(),51            .facts = self.facts,52            .has_surface = self.surface != null,53        };54    }5556    fn derivedCapacity(self: *const Placement) capacity_mod.Capacity {57        return capacity_mod.Capacity.derive(self.limits) catch unreachable;58    }5960    fn placeSurface(61        self: *Placement,62        src: Surface,63        facts: capacity_mod.Facts,64    ) Surface {65        var cursor = Cursor.init(self, self.derivedCapacity());66        const tree = cursor.surface();67        tree.* = .{68            .available_size = src.tree.available_size,69            .root = cursor.cloneNode(&src.tree.root),70        };71        const result = Surface{72            .tree = tree,73            .images = cursor.cloneImages(src.images),74        };75        cursor.finish(facts);76        self.surface = result;77        self.facts = facts;78        return result;79    }8081    fn placeCommandSurface(82        self: *Placement,83        src: *const command.CommandUiSurface,84        facts: capacity_mod.Facts,85    ) Surface {86        var cursor = Cursor.init(self, self.derivedCapacity());87        const tree = cursor.surface();88        tree.* = .{89            .available_size = .{90                .width = src.available_width,91                .height = src.available_height,92            },93            .root = cursor.cloneCommandNode(src.root_ptr.?),94        };95        const result = Surface{96            .tree = tree,97            .images = cursor.cloneCommandImages(src),98        };99        cursor.finish(facts);100        self.surface = result;101        self.facts = facts;102        return result;103    }104};

1pub const PlacementStatus = struct {2    capacity: capacity_mod.Capacity,3    facts: capacity_mod.Facts,4    has_surface: bool,5};

1pub const Storage = struct {2    phase: alloc_phase.capacity.Phase,3    capacity: capacity_mod.Capacity,4    bytes: []align(capacity_mod.storage_alignment) u8,5    placement: Placement,67    pub const Limits: type = capacity_mod.Limits;8    pub const Capacity: type = capacity_mod.Capacity;9    pub const Exhaustion: type = @import("storage.zig").Exhaustion;10    pub const InitError = std.mem.Allocator.Error || capacity_mod.DeriveError;1112    pub const claim: alloc_phase.capacity.Declaration = .{13        .source = .{14            .id = "gui.surface_clone_storage",15            .kind = .phase_static,16            .limit_source = .caller,17            .storage = .{18                .covered = &.{19                    .{20                        .id = "one_cloned_uisurfacetree_header_and_caller_sized_ty_33bebc07fe23",21                        .lifetime = .steady,22                        .detail = "one cloned UiSurfaceTree header and caller-sized typed node arena",23                    },24                    .{25                        .id = "caller_sized_cloned_uitextrun_arena",26                        .lifetime = .steady,27                        .detail = "caller-sized cloned UiTextRun arena",28                    },29                    .{30                        .id = "caller_sized_cloned_uitextstyle_arena",31                        .lifetime = .steady,32                        .detail = "caller-sized cloned UiTextStyle arena",33                    },34                    .{35                        .id = "caller_sized_cloned_ui_image_descriptor_arena",36                        .lifetime = .steady,37                        .detail = "caller-sized cloned UI image descriptor arena",38                    },39                    .{40                        .id = "caller_sized_cloned_packed_rgba8_image_pixels",41                        .lifetime = .steady,42                        .detail = "caller-sized cloned packed RGBA8 image pixels",43                    },44                    .{45                        .id = "caller_sized_cloned_text_action_and_role_bytes",46                        .lifetime = .steady,47                        .detail = "caller-sized cloned text action and role bytes",48                    },49                },50                .excluded = &.{51                    "caller-owned source trees and command pointer memory",52                    "sdfii retained root lookup and transactional replacement slots",53                    "frame layout render input and paint storage",54                },55            },56            .capacity = .{57                .inputs = &.{58                    alloc_phase.capacity.bindInput(Limits, "nodes", "nodes"),59                    alloc_phase.capacity.bindInput(Limits, "runs", "runs"),60                    alloc_phase.capacity.bindInput(Limits, "styles", "styles"),61                    alloc_phase.capacity.bindInput(Limits, "images", "images"),62                    alloc_phase.capacity.bindInput(Limits, "image_pixels", "image_pixels"),63                    alloc_phase.capacity.bindInput(Limits, "semantic_bytes", "semantic_bytes"),64                },65                .type_selectors = &.{66                    alloc_phase.capacity.bindType(UiSurfaceTree, "uisurfacetree"),67                    alloc_phase.capacity.bindType(UiNode, "uinode"),68                    alloc_phase.capacity.bindType(UiTextRun, "uitextrun"),69                    alloc_phase.capacity.bindType(UiTextStyle, "uitextstyle"),70                    alloc_phase.capacity.bindType(UiImage, "uiimage"),71                    alloc_phase.capacity.bindType(u32, "u32"),72                },73                .nodes = &.{74                    .{ .constant = 1 },75                    .{ .scale = .{ .node = 0, .coefficient = .{ .size_of_concrete_type = 0 } } },76                    .{ .alignment = .{ .node = 1, .alignment = .{ .literal = 16 } } },77                    .{ .input = 0 },78                    .{ .scale = .{ .node = 3, .coefficient = .{ .size_of_concrete_type = 1 } } },79                    .{ .alignment = .{ .node = 4, .alignment = .{ .literal = 16 } } },80                    .{ .input = 1 },81                    .{ .scale = .{ .node = 6, .coefficient = .{ .size_of_concrete_type = 2 } } },82                    .{ .alignment = .{ .node = 7, .alignment = .{ .literal = 16 } } },83                    .{ .input = 2 },84                    .{ .scale = .{ .node = 9, .coefficient = .{ .size_of_concrete_type = 3 } } },85                    .{ .alignment = .{ .node = 10, .alignment = .{ .literal = 16 } } },86                    .{ .input = 3 },87                    .{ .scale = .{ .node = 12, .coefficient = .{ .size_of_concrete_type = 4 } } },88                    .{ .alignment = .{ .node = 13, .alignment = .{ .literal = 16 } } },89                    .{ .input = 4 },90                    .{ .scale = .{ .node = 15, .coefficient = .{ .size_of_concrete_type = 5 } } },91                    .{ .alignment = .{ .node = 16, .alignment = .{ .literal = 16 } } },92                    .{ .input = 5 },93                    .{ .alignment = .{ .node = 18, .alignment = .{ .literal = 16 } } },94                    .{ .add = .{ .left = 2, .right = 5 } },95                    .{ .add = .{ .left = 20, .right = 8 } },96                    .{ .add = .{ .left = 21, .right = 11 } },97                    .{ .add = .{ .left = 22, .right = 14 } },98                    .{ .add = .{ .left = 23, .right = 17 } },99                    .{ .add = .{ .left = 24, .right = 19 } },100                },101                .assertions = &.{.{102                    .scope = .closure_total,103                    .measure = .retained,104                    .relation = .upper_bound,105                    .expression = 25,106                }},107            },108            .overload = .{109                .kind = .reject_before_mutation,110                .detail = "depth invalid command facts and max-plus-one node run style image pixel or semantic demand reject during survey before placement state changes",111            },112            .risks = .{113                .transitive = .{114                    .status = .witnessed,115                    .detail = "typed native and command placement traversals carry no allocator capability after storage activation",116                },117                .foreign = .{118                    .status = .open,119                    .detail = "command trees and image tables are foreign pointer graphs whose memory must remain immutable and valid through survey and placement",120                },121            },122            .obligations = &.{123                .{ .key = "gui_surface_clone_capacity", .role = .capacity_model },124                .{ .key = "gui_surface_clone_survey", .role = .overload },125                .{ .key = "gui_surface_clone_acquisition", .role = .custom },126                .{ .key = "gui_surface_clone_boundary", .role = .overload },127                .{ .key = "gui_surface_clone_command", .role = .foreign_risk },128                .{ .key = "gui_surface_clone_images", .role = .overload },129                .{ .key = "gui_surface_clone_command_images_overload", .role = .overload },130                .{ .key = "gui_surface_clone_command_images_foreign_risk", .role = .foreign_risk },131                .{ .key = "gui_surface_clone_sealed", .role = .transitive_risk },132            },133        },134        .bindings = .{135            .owner = @This(),136            .seal = .{137                .family = alloc_phase.capacity.selector(@This().activate),138                .premise = .{139                    .class = .checked_semantic_fact,140                    .authority = .checker,141                },142            },143            .teardown = .{144                .family = alloc_phase.capacity.selector(@This().deinit),145                .premise = .{146                    .class = .checked_semantic_fact,147                    .authority = .checker,148                },149            },150        },151    };152153    pub fn init(allocator: std.mem.Allocator, limits: Limits) InitError!Storage {154        const capacity = try Capacity.derive(limits);155        const bytes = try allocator.alignedAlloc(156            u8,157            .fromByteUnits(capacity_mod.storage_alignment),158            capacity.storage_bytes,159        );160        return .{161            .phase = .initialization,162            .capacity = capacity,163            .bytes = bytes,164            .placement = Placement.init(bytes, capacity),165        };166    }167168    pub fn activate(self: *Storage) void {169        std.debug.assert(self.phase == .initialization);170        self.assertStorage();171        self.phase = .steady;172    }173174    pub fn cloneSurface(self: *Storage, src: Surface) CloneError!Surface {175        std.debug.assert(self.phase == .steady);176        self.assertStorage();177        return self.placement.cloneSurface(src);178    }179180    pub fn cloneCommandSurface(181        self: *Storage,182        src: *const command.CommandUiSurface,183    ) CloneError!Surface {184        std.debug.assert(self.phase == .steady);185        self.assertStorage();186        return self.placement.cloneCommandSurface(src);187    }188189    pub fn current(self: *const Storage) ?Surface {190        return self.placement.current();191    }192193    pub fn status(self: *const Storage) PlacementStatus {194        self.assertStorage();195        return self.placement.status();196    }197198    pub fn deinit(self: *Storage, allocator: std.mem.Allocator) void {199        std.debug.assert(self.phase != .teardown);200        self.assertStorage();201        self.phase = .teardown;202        allocator.free(self.bytes);203        self.bytes = &.{};204        self.placement.bytes = &.{};205        self.placement.reset();206    }207208    fn assertStorage(self: *const Storage) void {209        std.debug.assert(self.bytes.len == self.capacity.storage_bytes);210        std.debug.assert(self.placement.bytes.ptr == self.bytes.ptr);211        std.debug.assert(self.placement.bytes.len == self.bytes.len);212        std.debug.assert(std.meta.eql(self.placement.limits, self.capacity.toLimits()));213    }214};

1pub const Error = error{2    SurfaceTooDeep,3    SurfaceFactsOverflow,4    InvalidCommand,5};

1pub const Surface = struct {2    tree: *const gui.model.UiSurfaceTree,3    images: gui.model.UiImageSet = .{},4};

1pub const storage_alignment: usize = @max(2    @alignOf(UiSurfaceTree),3    @max(4        @alignOf(UiNode),5        @max(@alignOf(UiTextRun), @max(@alignOf(UiTextStyle), @alignOf(UiImage))),6    ),7);

1pub const Exhaustion = survey.Error || error{SurfaceCapacityExceeded};

1pub fn commandSurface(src: *const command.CommandUiSurface) Error!capacity.Facts {2    const root = src.root_ptr orelse return error.InvalidCommand;3    var facts = capacity.Facts{};4    try commandImages(src, &facts);5    try commandNode(root, &facts, 0, src.images_len);6    return facts;7}

1pub fn surface(src: types.Surface) Error!capacity.Facts {2    var facts = capacity.Facts{};3    try surfaceImages(src.images, &facts);4    try surfaceNode(&src.tree.root, &facts, 0, src.images.images.len);5    return facts;6}

1pub const surface = @import("surface/root.zig");

1const capacity_mod = @import("capacity.zig");2const command = @import("command.zig");3const storage_mod = @import("storage.zig");4const survey = @import("survey.zig");5const types = @import("types.zig");67pub const CommandUiColor = command.CommandUiColor;8pub const CommandUiImage = command.CommandUiImage;9pub const CommandUiImagePaint = command.CommandUiImagePaint;10pub const CommandUiLinearGradient = command.CommandUiLinearGradient;11pub const CommandUiNode = command.CommandUiNode;12pub const CommandUiPaint = command.CommandUiPaint;13pub const CommandUiPoint = command.CommandUiPoint;14pub const CommandUiRect = command.CommandUiRect;15pub const CommandUiSurface = command.CommandUiSurface;16pub const CommandUiText = command.CommandUiText;17pub const CommandUiTextRun = command.CommandUiTextRun;18pub const CommandUiTextStyle = command.CommandUiTextStyle;19pub const Facts = capacity_mod.Facts;20pub const Limits = capacity_mod.Limits;21pub const Capacity = capacity_mod.Capacity;22pub const DeriveError = capacity_mod.DeriveError;23pub const Placement = storage_mod.Placement;24pub const PlacementStatus = storage_mod.PlacementStatus;25pub const Storage = storage_mod.Storage;26pub const CloneError = storage_mod.CloneError;27pub const SurveyError = survey.Error;28pub const Surface = types.Surface;29pub const max_depth = survey.max_depth;30pub const storage_alignment = capacity_mod.storage_alignment;3132pub const surveySurface = survey.surface;33pub const surveyCommandSurface = survey.commandSurface;

1pub const max_depth = gui.layout.max_depth;