4e27a7e6c9
What works on iOS sim now:
- pure-UIKit boot via UIApplicationMain (no SDL3 on iOS)
- SxGLView (CAEAGLLayer) + EAGLContext(GLES3) + CADisplayLink
- GLES3 shader path in modules/ui/renderer.sx (was wasm-only; now
wasm-OR-ios)
- UITouch -> ui.Event translation (mouse_down/moved/up) on touchesBegan/
Moved/Ended/Cancelled. Verified by tapping the chess board: the
expected pawn highlights and its legal moves show as green dots.
- chdir to NSBundle.mainBundle.resourcePath inside UIKitPlatform.init so
the game's relative fopen("assets/...") calls resolve.
Required restructuring to fix four problems discovered along the way:
1. GL context + load_gl must happen BEFORE UIApplicationMain so the
game's pipeline.init (which compiles shaders) doesn't crash on null
function pointers. Pulled EAGLContext creation + load_gl out of
didFinishLaunching: into UIKitPlatform.init via uikit_create_gl_context.
2. UIScreen.nativeScale returns CGFloat (=double on 64-bit Apple).
Reading it through a `(*void, *void) -> f32` msgSend signature
clobbers the value to 0 — the upper 32 bits of d0 land where the f32
reads from. Replaced msg_f with msg_d returning f64 (and added
msg_odbl for setContentScaleFactor: which takes CGFloat).
3. `xx <f64-call-result>` directly assigned to an f32 field through a
sema path lowers as `sitofp` (integer→float) on the double — LLVM
verification rejects it. Workaround: hoist into an `f64` local first.
4. The renderer was selecting the GLSL 330 core shader on every non-wasm
target, including iOS GLES3 where it silently fails to compile and
no quads render. Added OS == .ios to the GLES branch.
Game changes:
- main.sx: g_plat is now a boxed `Platform` (not concrete *SdlPlatform).
Backend chosen per-target via `inline if OS == .ios { ... }`. The
ESC-to-stop handling is OS-guarded (mobile apps don't quit on key
press, and SDL_Keycode references would force-link SDL on iOS).
- build.sx: iOS no longer adds SDL3; it adds UIKit + OpenGLES +
QuartzCore instead.
- delta_time and viewport dims are now mirrored to free globals so the
dock subsystem (`g_dock_delta_time = @g_delta_time`) and build_ui
layout decisions don't need a pointer through the boxed protocol.
Other:
- Added `stop()` to the Platform protocol (no-op on UIKitPlatform).
- examples/66-uikit-platform.sx updated: taps advance the clear color
(red → green → blue) — smoke test for the touch IMP wiring.
- shutdown() on UIKitPlatform is a no-op (mobile apps don't tear down).
Outstanding for next session:
- The Dynamic Island notch overlaps the top of the board because we
haven't read UIView.safeAreaInsets yet (CGRect/UIEdgeInsets struct
returns require a different msgSend ABI than we currently express).
- Keyboard observer (UIKeyboardWillChangeFrameNotification + animation
duration) — the load-bearing iOS feature.
- Real-device codesigning workflow for the new build.
Two more sx compiler bugs to file out of this work:
- xx(f64 call result) → f32 emits sitofp (problem #3 above).
- Inline `#import` inside `inline if` fails to parse (we worked around
by importing both backends unconditionally; the unused-backend's
Obj-C calls are gated by `inline if OS == .ios`).
461 lines
15 KiB
Plaintext
Executable File
461 lines
15 KiB
Plaintext
Executable File
#import "modules/std.sx";
|
|
#import "modules/compiler.sx";
|
|
#import "modules/opengl.sx";
|
|
#import "modules/math";
|
|
#import "modules/ui/types.sx";
|
|
#import "modules/ui/render.sx";
|
|
#import "modules/ui/glyph_cache.sx";
|
|
#import "modules/ui/font.sx";
|
|
|
|
// Vertex: pos(2) + uv(2) + color(4) + params(4) = 12 floats
|
|
UI_VERTEX_FLOATS :s64: 12;
|
|
UI_VERTEX_BYTES :s64: 48;
|
|
MAX_UI_VERTICES :s64: 16384;
|
|
|
|
UIRenderer :: struct {
|
|
vao: u32;
|
|
vbo: u32;
|
|
shader: u32;
|
|
proj_loc: s32;
|
|
tex_loc: s32;
|
|
vertices: [*]f32;
|
|
vertex_count: s64;
|
|
screen_width: f32;
|
|
screen_height: f32;
|
|
dpi_scale: f32;
|
|
white_texture: u32;
|
|
current_texture: u32;
|
|
draw_calls: s64;
|
|
|
|
init :: (self: *UIRenderer) {
|
|
// Create shader (ES for WASM/WebGL2 + iOS GLES3, Core for desktop GL 3.3)
|
|
inline if OS == .wasm or OS == .ios {
|
|
self.shader = create_program(UI_VERT_SRC_ES, UI_FRAG_SRC_ES);
|
|
} else {
|
|
self.shader = create_program(UI_VERT_SRC_CORE, UI_FRAG_SRC_CORE);
|
|
}
|
|
self.proj_loc = glGetUniformLocation(self.shader, "uProj");
|
|
self.tex_loc = glGetUniformLocation(self.shader, "uTex");
|
|
|
|
// Allocate vertex buffer (CPU side)
|
|
buf_size := MAX_UI_VERTICES * UI_VERTEX_BYTES;
|
|
self.vertices = xx context.allocator.alloc(buf_size);
|
|
memset(self.vertices, 0, buf_size);
|
|
self.vertex_count = 0;
|
|
|
|
// Create VAO/VBO
|
|
glGenVertexArrays(1, @self.vao);
|
|
glGenBuffers(1, @self.vbo);
|
|
glBindVertexArray(self.vao);
|
|
glBindBuffer(GL_ARRAY_BUFFER, self.vbo);
|
|
glBufferData(GL_ARRAY_BUFFER, xx buf_size, null, GL_DYNAMIC_DRAW);
|
|
|
|
// pos (2 floats)
|
|
glVertexAttribPointer(0, 2, GL_FLOAT, 0, xx UI_VERTEX_BYTES, xx 0);
|
|
glEnableVertexAttribArray(0);
|
|
// uv (2 floats)
|
|
glVertexAttribPointer(1, 2, GL_FLOAT, 0, xx UI_VERTEX_BYTES, xx 8);
|
|
glEnableVertexAttribArray(1);
|
|
// color (4 floats)
|
|
glVertexAttribPointer(2, 4, GL_FLOAT, 0, xx UI_VERTEX_BYTES, xx 16);
|
|
glEnableVertexAttribArray(2);
|
|
// params: corner_radius, border_width, rect_w, rect_h
|
|
glVertexAttribPointer(3, 4, GL_FLOAT, 0, xx UI_VERTEX_BYTES, xx 32);
|
|
glEnableVertexAttribArray(3);
|
|
|
|
glBindVertexArray(0);
|
|
|
|
self.dpi_scale = 1.0;
|
|
|
|
// 1x1 white texture for solid rects
|
|
self.white_texture = create_white_texture();
|
|
}
|
|
|
|
begin :: (self: *UIRenderer, width: f32, height: f32, font_texture: u32) {
|
|
self.screen_width = width;
|
|
self.screen_height = height;
|
|
self.vertex_count = 0;
|
|
self.current_texture = font_texture;
|
|
self.draw_calls = 0;
|
|
|
|
// Set up GL state once for the entire frame
|
|
glUseProgram(self.shader);
|
|
proj := Mat4.ortho(0.0, width, height, 0.0, -1.0, 1.0);
|
|
glUniformMatrix4fv(self.proj_loc, 1, 0, proj.data);
|
|
glUniform1i(self.tex_loc, 0);
|
|
glActiveTexture(GL_TEXTURE0);
|
|
glBindTexture(GL_TEXTURE_2D, font_texture);
|
|
glBindVertexArray(self.vao);
|
|
glBindBuffer(GL_ARRAY_BUFFER, self.vbo);
|
|
}
|
|
|
|
bind_texture :: (self: *UIRenderer, tex: u32) {
|
|
if tex != self.current_texture {
|
|
self.flush();
|
|
self.current_texture = tex;
|
|
}
|
|
}
|
|
|
|
// Emit a quad (2 triangles = 6 vertices)
|
|
push_quad :: (self: *UIRenderer, frame: Frame, color: Color, radius: f32, border_w: f32) {
|
|
if self.vertex_count + 6 > MAX_UI_VERTICES {
|
|
self.flush();
|
|
}
|
|
|
|
x0 := frame.origin.x;
|
|
y0 := frame.origin.y;
|
|
x1 := x0 + frame.size.width;
|
|
y1 := y0 + frame.size.height;
|
|
|
|
r := color.rf();
|
|
g := color.gf();
|
|
b := color.bf();
|
|
a := color.af();
|
|
|
|
w := frame.size.width;
|
|
h := frame.size.height;
|
|
|
|
// 6 vertices for quad: TL, TR, BL, TR, BR, BL
|
|
self.write_vertex(x0, y0, 0.0, 0.0, r, g, b, a, radius, border_w, w, h);
|
|
self.write_vertex(x1, y0, 1.0, 0.0, r, g, b, a, radius, border_w, w, h);
|
|
self.write_vertex(x0, y1, 0.0, 1.0, r, g, b, a, radius, border_w, w, h);
|
|
self.write_vertex(x1, y0, 1.0, 0.0, r, g, b, a, radius, border_w, w, h);
|
|
self.write_vertex(x1, y1, 1.0, 1.0, r, g, b, a, radius, border_w, w, h);
|
|
self.write_vertex(x0, y1, 0.0, 1.0, r, g, b, a, radius, border_w, w, h);
|
|
}
|
|
|
|
// Emit a quad with custom UV coordinates (for sprite sheet sub-textures)
|
|
push_quad_uv :: (self: *UIRenderer, frame: Frame, color: Color, radius: f32, border_w: f32, uv_min: Point, uv_max: Point) {
|
|
if self.vertex_count + 6 > MAX_UI_VERTICES {
|
|
self.flush();
|
|
}
|
|
|
|
x0 := frame.origin.x;
|
|
y0 := frame.origin.y;
|
|
x1 := x0 + frame.size.width;
|
|
y1 := y0 + frame.size.height;
|
|
|
|
r := color.rf();
|
|
g := color.gf();
|
|
b := color.bf();
|
|
a := color.af();
|
|
|
|
w := frame.size.width;
|
|
h := frame.size.height;
|
|
|
|
u0 := uv_min.x;
|
|
v0 := uv_min.y;
|
|
u1 := uv_max.x;
|
|
v1 := uv_max.y;
|
|
|
|
self.write_vertex(x0, y0, u0, v0, r, g, b, a, radius, border_w, w, h);
|
|
self.write_vertex(x1, y0, u1, v0, r, g, b, a, radius, border_w, w, h);
|
|
self.write_vertex(x0, y1, u0, v1, r, g, b, a, radius, border_w, w, h);
|
|
self.write_vertex(x1, y0, u1, v0, r, g, b, a, radius, border_w, w, h);
|
|
self.write_vertex(x1, y1, u1, v1, r, g, b, a, radius, border_w, w, h);
|
|
self.write_vertex(x0, y1, u0, v1, r, g, b, a, radius, border_w, w, h);
|
|
}
|
|
|
|
write_vertex :: (self: *UIRenderer, x: f32, y: f32, u: f32, v: f32, r: f32, g: f32, b: f32, a: f32, cr: f32, bw: f32, rw: f32, rh: f32) {
|
|
off := self.vertex_count * UI_VERTEX_FLOATS;
|
|
self.vertices[off + 0] = x;
|
|
self.vertices[off + 1] = y;
|
|
self.vertices[off + 2] = u;
|
|
self.vertices[off + 3] = v;
|
|
self.vertices[off + 4] = r;
|
|
self.vertices[off + 5] = g;
|
|
self.vertices[off + 6] = b;
|
|
self.vertices[off + 7] = a;
|
|
self.vertices[off + 8] = cr;
|
|
self.vertices[off + 9] = bw;
|
|
self.vertices[off + 10] = rw;
|
|
self.vertices[off + 11] = rh;
|
|
self.vertex_count += 1;
|
|
}
|
|
|
|
// Walk the render tree and emit quads
|
|
process :: (self: *UIRenderer, tree: *RenderTree) {
|
|
i := 0;
|
|
while i < tree.nodes.len {
|
|
node := tree.nodes.items[i];
|
|
if node.type == {
|
|
case .rect: {
|
|
self.push_quad(node.frame, node.fill_color, 0.0, 0.0);
|
|
}
|
|
case .rounded_rect: {
|
|
self.push_quad(node.frame, node.fill_color, node.corner_radius, node.stroke_width);
|
|
}
|
|
case .text: {
|
|
if g_font != null {
|
|
self.render_text(node);
|
|
}
|
|
}
|
|
case .image: {
|
|
self.bind_texture(node.texture_id);
|
|
neg2 : f32 = 0.0 - 2.0;
|
|
self.push_quad_uv(node.frame, COLOR_WHITE, neg2, 0.0, node.uv_min, node.uv_max);
|
|
// Re-bind font atlas after image
|
|
font := g_font;
|
|
if font != null {
|
|
self.bind_texture(font.texture_id);
|
|
}
|
|
}
|
|
case .clip_push: {
|
|
self.flush();
|
|
glEnable(GL_SCISSOR_TEST);
|
|
dpi := self.dpi_scale;
|
|
glScissor(
|
|
xx (node.frame.origin.x * dpi),
|
|
xx ((self.screen_height - node.frame.origin.y - node.frame.size.height) * dpi),
|
|
xx (node.frame.size.width * dpi),
|
|
xx (node.frame.size.height * dpi)
|
|
);
|
|
}
|
|
case .clip_pop: {
|
|
self.flush();
|
|
glDisable(GL_SCISSOR_TEST);
|
|
}
|
|
case .opacity_push: {}
|
|
case .opacity_pop: {}
|
|
}
|
|
i += 1;
|
|
}
|
|
}
|
|
|
|
flush :: (self: *UIRenderer) {
|
|
if self.vertex_count == 0 { return; }
|
|
|
|
// Only bind the current texture (program, projection, VAO already bound in begin())
|
|
glBindTexture(GL_TEXTURE_2D, self.current_texture);
|
|
|
|
upload_size : s64 = self.vertex_count * UI_VERTEX_BYTES;
|
|
// Use glBufferData to orphan the old buffer and avoid GPU sync stalls
|
|
glBufferData(GL_ARRAY_BUFFER, xx upload_size, self.vertices, GL_DYNAMIC_DRAW);
|
|
glDrawArrays(GL_TRIANGLES, 0, xx self.vertex_count);
|
|
|
|
self.vertex_count = 0;
|
|
self.draw_calls += 1;
|
|
}
|
|
|
|
render_text :: (self: *UIRenderer, node: RenderNode) {
|
|
font := g_font;
|
|
if font == null { return; }
|
|
|
|
// Shape text into positioned glyphs
|
|
font.shape_text(node.text, node.font_size);
|
|
|
|
// Flush any new glyphs to the atlas texture (no texture switch needed — atlas is already bound)
|
|
font.flush();
|
|
|
|
r := node.text_color.rf();
|
|
g := node.text_color.gf();
|
|
b := node.text_color.bf();
|
|
a := node.text_color.af();
|
|
|
|
ascent := font.get_ascent(node.font_size);
|
|
raster_size := node.font_size * font.dpi_scale;
|
|
inv_dpi := font.inv_dpi;
|
|
|
|
i : s64 = 0;
|
|
while i < font.shaped_buf.len {
|
|
shaped := font.shaped_buf.items[i];
|
|
cached := font.get_or_rasterize(shaped.glyph_index, raster_size);
|
|
|
|
if cached != null {
|
|
if cached.width > 0.0 {
|
|
// Scale physical pixel dimensions back to logical units
|
|
gx0 := node.frame.origin.x + shaped.x + cached.offset_x * inv_dpi;
|
|
gy0 := node.frame.origin.y + ascent + shaped.y + cached.offset_y * inv_dpi;
|
|
gx1 := gx0 + cached.width * inv_dpi;
|
|
gy1 := gy0 + cached.height * inv_dpi;
|
|
|
|
u0 := cached.uv_x;
|
|
v0 := cached.uv_y;
|
|
u1 := cached.uv_x + cached.uv_w;
|
|
v1 := cached.uv_y + cached.uv_h;
|
|
|
|
if self.vertex_count + 6 > MAX_UI_VERTICES {
|
|
self.flush();
|
|
}
|
|
|
|
// corner_radius = -1.0 signals "text mode" to the fragment shader
|
|
neg1 : f32 = 0.0 - 1.0;
|
|
self.write_vertex(gx0, gy0, u0, v0, r, g, b, a, neg1, 0.0, 0.0, 0.0);
|
|
self.write_vertex(gx1, gy0, u1, v0, r, g, b, a, neg1, 0.0, 0.0, 0.0);
|
|
self.write_vertex(gx0, gy1, u0, v1, r, g, b, a, neg1, 0.0, 0.0, 0.0);
|
|
self.write_vertex(gx1, gy0, u1, v0, r, g, b, a, neg1, 0.0, 0.0, 0.0);
|
|
self.write_vertex(gx1, gy1, u1, v1, r, g, b, a, neg1, 0.0, 0.0, 0.0);
|
|
self.write_vertex(gx0, gy1, u0, v1, r, g, b, a, neg1, 0.0, 0.0, 0.0);
|
|
}
|
|
}
|
|
i += 1;
|
|
}
|
|
|
|
// Flush any glyphs rasterized during this text draw
|
|
font.flush();
|
|
}
|
|
}
|
|
|
|
create_white_texture :: () -> u32 {
|
|
tex : u32 = 0;
|
|
glGenTextures(1, @tex);
|
|
glBindTexture(GL_TEXTURE_2D, tex);
|
|
pixel : [4]u8 = .[255, 255, 255, 255];
|
|
glTexImage2D(GL_TEXTURE_2D, 0, xx GL_RGBA, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, @pixel);
|
|
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, xx GL_NEAREST);
|
|
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, xx GL_NEAREST);
|
|
tex;
|
|
}
|
|
|
|
// --- UI Shaders ---
|
|
|
|
// --- Desktop (Core Profile 3.3) shaders ---
|
|
|
|
UI_VERT_SRC_CORE :: #string GLSL
|
|
#version 330 core
|
|
layout(location = 0) in vec2 aPos;
|
|
layout(location = 1) in vec2 aUV;
|
|
layout(location = 2) in vec4 aColor;
|
|
layout(location = 3) in vec4 aParams;
|
|
|
|
uniform mat4 uProj;
|
|
|
|
out vec2 vUV;
|
|
out vec4 vColor;
|
|
out vec4 vParams;
|
|
|
|
void main() {
|
|
gl_Position = uProj * vec4(aPos, 0.0, 1.0);
|
|
vUV = aUV;
|
|
vColor = aColor;
|
|
vParams = aParams;
|
|
}
|
|
GLSL;
|
|
|
|
UI_FRAG_SRC_CORE :: #string GLSL
|
|
#version 330 core
|
|
in vec2 vUV;
|
|
in vec4 vColor;
|
|
in vec4 vParams;
|
|
|
|
uniform sampler2D uTex;
|
|
|
|
out vec4 FragColor;
|
|
|
|
float roundedBoxSDF(vec2 center, vec2 half_size, float radius) {
|
|
vec2 q = abs(center) - half_size + vec2(radius);
|
|
return length(max(q, vec2(0.0))) + min(max(q.x, q.y), 0.0) - radius;
|
|
}
|
|
|
|
void main() {
|
|
float mode = vParams.x;
|
|
float border = vParams.y;
|
|
vec2 rectSize = vParams.zw;
|
|
|
|
if (mode < -1.5) {
|
|
// Image mode (mode == -2.0): sample texture
|
|
FragColor = texture(uTex, vUV) * vColor;
|
|
} else if (mode < 0.0) {
|
|
// Text mode (mode == -1.0): sample glyph atlas .r as alpha
|
|
float alpha = texture(uTex, vUV).r;
|
|
float ew = fwidth(alpha) * 0.7;
|
|
alpha = smoothstep(0.5 - ew, 0.5 + ew, alpha);
|
|
FragColor = vec4(vColor.rgb, vColor.a * pow(alpha, 0.9));
|
|
} else if (mode > 0.0 || border > 0.0) {
|
|
// Rounded rect: SDF alpha, vertex color only (no texture sample)
|
|
vec2 half_size = rectSize * 0.5;
|
|
vec2 center = (vUV - vec2(0.5)) * rectSize;
|
|
float dist = roundedBoxSDF(center, half_size, mode);
|
|
float aa = fwidth(dist);
|
|
float alpha = 1.0 - smoothstep(-aa, aa, dist);
|
|
|
|
if (border > 0.0) {
|
|
float inner = roundedBoxSDF(center, half_size - vec2(border), max(mode - border, 0.0));
|
|
float border_alpha = smoothstep(-aa, aa, inner);
|
|
alpha = alpha * max(border_alpha, 0.0);
|
|
}
|
|
|
|
FragColor = vec4(vColor.rgb, vColor.a * alpha);
|
|
} else {
|
|
// Plain rect: vertex color only (no texture sample)
|
|
FragColor = vColor;
|
|
}
|
|
}
|
|
GLSL;
|
|
|
|
// --- WASM (ES 3.0 / WebGL2) shaders ---
|
|
|
|
UI_VERT_SRC_ES :: #string GLSL
|
|
#version 300 es
|
|
precision mediump float;
|
|
layout(location = 0) in vec2 aPos;
|
|
layout(location = 1) in vec2 aUV;
|
|
layout(location = 2) in vec4 aColor;
|
|
layout(location = 3) in vec4 aParams;
|
|
|
|
uniform mat4 uProj;
|
|
|
|
out vec2 vUV;
|
|
out vec4 vColor;
|
|
out vec4 vParams;
|
|
|
|
void main() {
|
|
gl_Position = uProj * vec4(aPos, 0.0, 1.0);
|
|
vUV = aUV;
|
|
vColor = aColor;
|
|
vParams = aParams;
|
|
}
|
|
GLSL;
|
|
|
|
UI_FRAG_SRC_ES :: #string GLSL
|
|
#version 300 es
|
|
precision mediump float;
|
|
in vec2 vUV;
|
|
in vec4 vColor;
|
|
in vec4 vParams;
|
|
|
|
uniform sampler2D uTex;
|
|
|
|
out vec4 FragColor;
|
|
|
|
float roundedBoxSDF(vec2 center, vec2 half_size, float radius) {
|
|
vec2 q = abs(center) - half_size + vec2(radius);
|
|
return length(max(q, vec2(0.0))) + min(max(q.x, q.y), 0.0) - radius;
|
|
}
|
|
|
|
void main() {
|
|
float mode = vParams.x;
|
|
float border = vParams.y;
|
|
vec2 rectSize = vParams.zw;
|
|
|
|
if (mode < -1.5) {
|
|
// Image mode (mode == -2.0): sample texture
|
|
FragColor = texture(uTex, vUV) * vColor;
|
|
} else if (mode < 0.0) {
|
|
// Text mode (mode == -1.0): sample glyph atlas .r as alpha
|
|
float alpha = texture(uTex, vUV).r;
|
|
float ew = fwidth(alpha) * 0.7;
|
|
alpha = smoothstep(0.5 - ew, 0.5 + ew, alpha);
|
|
FragColor = vec4(vColor.rgb, vColor.a * pow(alpha, 0.9));
|
|
} else if (mode > 0.0 || border > 0.0) {
|
|
// Rounded rect: SDF alpha, vertex color only
|
|
vec2 half_size = rectSize * 0.5;
|
|
vec2 center = (vUV - vec2(0.5)) * rectSize;
|
|
float dist = roundedBoxSDF(center, half_size, mode);
|
|
float aa = fwidth(dist);
|
|
float alpha = 1.0 - smoothstep(-aa, aa, dist);
|
|
|
|
if (border > 0.0) {
|
|
float inner = roundedBoxSDF(center, half_size - vec2(border), max(mode - border, 0.0));
|
|
float border_alpha = smoothstep(-aa, aa, inner);
|
|
alpha = alpha * max(border_alpha, 0.0);
|
|
}
|
|
|
|
FragColor = vec4(vColor.rgb, vColor.a * alpha);
|
|
} else {
|
|
// Plain rect: vertex color only
|
|
FragColor = vColor;
|
|
}
|
|
}
|
|
GLSL;
|