Unnamed: 0
int64
0
0
repo_id
stringlengths
5
186
file_path
stringlengths
15
223
content
stringlengths
1
32.8M
0
repos/MinimalRoboticsPlatform/src/environments
repos/MinimalRoboticsPlatform/src/environments/sysCallTopicsTest/envConfig.zig
pub const envConfTemplate = @import("configTemplates").envConfigTemplate; const StatusControlConf = envConfTemplate.StatusControlConf; pub const env_config = envConfTemplate.EnvConfig(3){ .status_control = [_]StatusControlConf{ .{ .status_type = .isize, .name = "height", .id = 0, .topic_conf = null, }, .{ .status_type = .topic, .name = "height-sensor", .id = 1, .topic_conf = .{ .buffer_type = envConfTemplate.TopicBufferTypes.RingBuffer, .buffer_size = 0x100000, }, }, .{ .status_type = .topic, .name = "front-ultrasonic-proximity", .id = 2, .topic_conf = .{ .buffer_type = envConfTemplate.TopicBufferTypes.RingBuffer, .buffer_size = 1024, }, }, }, };
0
repos/MinimalRoboticsPlatform/src/environments/sysCallTopicsTest
repos/MinimalRoboticsPlatform/src/environments/sysCallTopicsTest/setupRoutines/raspi3bSetup.zig
const std = @import("std"); const board = @import("board"); const arm = @import("arm"); const cpuContext = arm.cpuContext; const periph = @import("periph"); const kprint = periph.uart.UartWriter(.ttbr1).kprint; const ProccessorRegMap = arm.processor.ProccessorRegMap; const sharedKernelServices = @import("sharedKernelServices"); const Scheduler = sharedKernelServices.Scheduler; pub fn bcm2835Setup(scheduler: *Scheduler) void { _ = scheduler; // enabling arm generic timer irq @as(*volatile u32, @ptrFromInt(board.PeriphConfig(.ttbr1).ArmGenericTimer.base_address)).* = 1 << 1 | 1 << 3; ProccessorRegMap.DaifReg.setDaifClr(.{ .debug = true, .serr = true, .irqs = true, .fiqs = true, }); if (board.driver.secondaryInterruptConrtollerDriver) |secondary_ic| { secondary_ic.addIcHandler(&irqHandler) catch |e| { kprint("[error] addIcHandler error: {s} \n", .{@errorName(e)}); while (true) {} }; } kprint("inited raspberry secondary Ic and arm timer \n", .{}); } pub const RegValues = struct { // all banks are lister here: https://github.com/torvalds/linux/blob/master/Documentation/devicetree/bindings/interrupt-controller/brcm%2Cbcm2835-armctrl-ic.txt pub const Bank0 = enum(u32) { armTimer = 1 << 0, armMailbox = 1 << 1, armDoorbell0 = 1 << 2, armDoorbell1 = 1 << 3, vpu0Halted = 1 << 4, vpu1Halted = 1 << 5, illegalType0 = 1 << 6, illegalType1 = 1 << 7, pending1 = 1 << 8, pending2 = 1 << 9, notDefined = 0, }; pub const Bank1 = enum(u32) { timer0 = 1 << 0, timer1 = 1 << 1, timer2 = 1 << 2, timer3 = 1 << 3, codec0 = 1 << 4, codec1 = 1 << 5, codec2 = 1 << 6, vcJpeg = 1 << 7, isp = 1 << 8, vcUsb = 1 << 9, vc3d = 1 << 10, transposer = 1 << 11, multicoresync0 = 1 << 12, multicoresync1 = 1 << 13, multicoresync2 = 1 << 14, multicoresync3 = 1 << 15, dma0 = 1 << 16, dma1 = 1 << 17, vcDma2 = 1 << 18, vcDma3 = 1 << 19, dma4 = 1 << 20, dma5 = 1 << 21, dma6 = 1 << 22, dma7 = 1 << 23, dma8 = 1 << 24, dma9 = 1 << 25, dma10 = 1 << 26, // 27: dma11-14 - shared interrupt for dma 11 to 14 dma11 = 1 << 27, // 28: dmaall - triggers on all dma interrupts (including chanel 15) dmaall = 1 << 28, aux = 1 << 29, arm = 1 << 30, vpudma = 1 << 31, notDefined = 0, }; // bank2 pub const Bank2 = enum(u32) { hostport = 1 << 0, videoscaler = 1 << 1, ccp2tx = 1 << 2, sdc = 1 << 3, dsi0 = 1 << 4, ave = 1 << 5, cam0 = 1 << 6, cam1 = 1 << 7, hdmi0 = 1 << 8, hdmi1 = 1 << 9, pixelValve1 = 1 << 10, i2cSpislv = 1 << 11, dsi1 = 1 << 12, pwa0 = 1 << 13, pwa1 = 1 << 14, cpr = 1 << 15, smi = 1 << 16, gpio0 = 1 << 17, gpio1 = 1 << 18, gpio2 = 1 << 19, gpio3 = 1 << 20, vci2c = 1 << 21, vcSpi = 1 << 22, vcI2spcm = 1 << 23, vcSdio = 1 << 24, vcUart = 1 << 25, slimbus = 1 << 26, vec = 1 << 27, cpg = 1 << 28, rng = 1 << 29, vcArasansdio = 1 << 30, avspmon = 1 << 31, notDefined = 0, }; }; // bcm2835 interrupt controller handler for raspberry const Bank0 = RegValues.Bank0; const Bank1 = RegValues.Bank1; const Bank2 = RegValues.Bank2; pub fn irqHandler(context: *cpuContext.CpuContext) void { var irq_bank_0 = std.meta.intToEnum(Bank0, board.SecondaryInterruptControllerKpiType.RegMap.pendingBasic.*) catch |e| { kprint("[panic] std meta intToEnum error: {s} \n", .{@errorName(e)}); while (true) {} }; var irq_bank_1 = std.meta.intToEnum(Bank1, board.SecondaryInterruptControllerKpiType.RegMap.pendingIrq1.*) catch |e| { kprint("[panic] std meta intToEnum error: {s} \n", .{@errorName(e)}); while (true) {} }; var irq_bank_2 = std.meta.intToEnum(Bank2, board.SecondaryInterruptControllerKpiType.RegMap.pendingIrq2.*) catch |e| { kprint("[panic] std meta intToEnum error: {s} \n", .{@errorName(e)}); while (true) {} }; switch (irq_bank_0) { // One or more bits set in pending register 1 Bank0.pending1 => { switch (irq_bank_1) { Bank1.timer1 => { if (std.mem.eql(u8, board.driver.timerDriver.timer_name, "bcm2835_timer")) { board.driver.timerDriver.timerTick(context) catch |e| { kprint("[panic] timerDriver timerTick error: {s} \n", .{@errorName(e)}); while (true) {} }; } }, else => { // kprint("Not supported 1 irq num: {s} \n", .{@tagName(irq_bank_1)}); }, } }, // One or more bits set in pending register 2 Bank0.pending2 => { switch (irq_bank_2) { else => { // kprint("Not supported bank 2 irq num: {s} \n", .{@tagName(irq_bank_0)}); }, } }, Bank0.armTimer => { if (std.mem.eql(u8, board.driver.timerDriver.timer_name, "arm_gt")) { board.driver.timerDriver.timerTick(context) catch |e| { kprint("[panic] timerDriver timerTick error: {s} \n", .{@errorName(e)}); while (true) {} }; } }, else => { // kprint("Not supported bank(neither 1/2) irq num: {d} \n", .{intController.RegMap.pendingBasic.*}); // raspberries timers are a mess and I'm currently unsure if the Arm Generic timer // has an enum defined in the banks or if it's not defined through the bcm28835 system. }, } }
0
repos/MinimalRoboticsPlatform/src/environments/sysCallTopicsTest
repos/MinimalRoboticsPlatform/src/environments/sysCallTopicsTest/setupRoutines/routines.zig
const board = @import("board"); const std = @import("std"); const sharedKernelServices = @import("sharedKernelServices"); const Scheduler = sharedKernelServices.Scheduler; const raspi3bSetup = @import("raspi3bSetup.zig").bcm2835Setup; const qemuVirtSetup = @import("qemuVirtSetup.zig").qemuVirtSetup; const SetupRoutine = fn (scheduler: *Scheduler) void; const boardSpecificSetup = blk: { if (std.mem.eql(u8, board.config.board_name, "raspi3b")) { break :blk [_]SetupRoutine{raspi3bSetup}; } else if (std.mem.eql(u8, board.config.board_name, "qemuVirt")) { break :blk [_]SetupRoutine{qemuVirtSetup}; } }; // setupRoutines array is loaded and inited by the kernel pub const setupRoutines = [_]SetupRoutine{} ++ boardSpecificSetup;
0
repos/MinimalRoboticsPlatform/src/environments/sysCallTopicsTest
repos/MinimalRoboticsPlatform/src/environments/sysCallTopicsTest/setupRoutines/qemuVirtSetup.zig
const std = @import("std"); const board = @import("board"); const arm = @import("arm"); const cpuContext = arm.cpuContext; const ProccessorRegMap = arm.processor.ProccessorRegMap; const gic = arm.gicv2.Gic(.ttbr1); const InterruptIds = gic.InterruptIds; const periph = @import("periph"); const kprint = periph.uart.UartWriter(.ttbr1).kprint; const sharedKernelServices = @import("sharedKernelServices"); const Scheduler = sharedKernelServices.Scheduler; pub fn qemuVirtSetup(scheduler: *Scheduler) void { _ = scheduler; gic.init() catch |e| { kprint("[panic] gic init error: {s}\n", .{@errorName(e)}); while (true) {} }; gic.Gicd.gicdConfig(InterruptIds.non_secure_physical_timer, 0x2) catch |e| { kprint("[panic] gicd gicdConfig error: {s}\n", .{@errorName(e)}); while (true) {} }; gic.Gicd.gicdSetPriority(InterruptIds.non_secure_physical_timer, 0) catch |e| { kprint("[panic] gicd setPriority error: {s}\n", .{@errorName(e)}); while (true) {} }; gic.Gicd.gicdSetTarget(InterruptIds.non_secure_physical_timer, 1) catch |e| { kprint("[panic] gicd setTarget error: {s}\n", .{@errorName(e)}); while (true) {} }; gic.Gicd.gicdClearPending(InterruptIds.non_secure_physical_timer) catch |e| { kprint("[panic] gicd clearPending error: {s}\n", .{@errorName(e)}); while (true) {} }; gic.Gicd.gicdEnableInt(InterruptIds.non_secure_physical_timer) catch |e| { kprint("[panic] gicdEnableInt address calc error: {s}\n", .{@errorName(e)}); while (true) {} }; ProccessorRegMap.DaifReg.setDaifClr(.{ .debug = true, .serr = true, .irqs = true, .fiqs = true, }); }
0
repos/MinimalRoboticsPlatform/src/environments/sysCallTopicsTest/userApps
repos/MinimalRoboticsPlatform/src/environments/sysCallTopicsTest/userApps/app3/main.zig
const std = @import("std"); const board = @import("board"); const appLib = @import("appLib"); const Mutex = appLib.Mutex; const AppAlloc = appLib.AppAllocator; const SharedMemTopicsInterface = appLib.SharedMemTopicsInterface; const sysCalls = appLib.sysCalls; const utils = appLib.utils; const kprint = appLib.sysCalls.SysCallPrint.kprint; var test_counter: usize = 0; var shared_thread_counter: isize = 0; var mutex = Mutex.init(); var shared_mutex: *Mutex = &mutex; export fn app_main(pid: usize) linksection(".text.main") callconv(.C) noreturn { kprint("app3 initial pid: {d} \n", .{pid}); var ret: usize = 0; var ret_buff: []u8 = undefined; ret_buff.ptr = @as([*]u8, @ptrCast(&ret)); ret_buff.len = @sizeOf(@TypeOf(ret)); var topics_interf = SharedMemTopicsInterface.init() catch |e| { kprint("app3 SharedMemTopicsInterface init err: {s} \n", .{@errorName(e)}); while (true) {} }; while (true) { var read_len = topics_interf.read("front-ultrasonic-proximity", ret_buff) catch |e| { kprint("app3 SharedMemTopicsInterface read err: {s} \n", .{@errorName(e)}); while (true) {} }; if (read_len < ret_buff.len) kprint("buffer partially filled {d}/ {d} bytes \n", .{ read_len, ret_buff.len }); kprint("SharedMemTopicsInterface read: {any} \n", .{ret}); // _ = topics_interf; // _ = ret_buff; } }
0
repos/MinimalRoboticsPlatform/src/environments/sysCallTopicsTest/userApps
repos/MinimalRoboticsPlatform/src/environments/sysCallTopicsTest/userApps/app3/linker.ld
ENTRY(app_main) SECTIONS { . = 0x0; .text : ALIGN(16) { *(.text.main) } .got : { *(.got.plt); *(.got); } .rodata : ALIGN(0x8) { *(.rodata); *(.rodata.*); } .bss : ALIGN(0x10) { _bss_start = .; *(.bss.*); *(COMMON); _bss_end = .; } .data : { *(.data); *(.data.*); } .heap (NOLOAD) : ALIGN(8) { _heap_start = .; } }
0
repos/MinimalRoboticsPlatform/src/environments/sysCallTopicsTest/userApps
repos/MinimalRoboticsPlatform/src/environments/sysCallTopicsTest/userApps/app1/main.zig
const std = @import("std"); const appLib = @import("appLib"); const AppAlloc = appLib.AppAllocator; const sysCalls = appLib.sysCalls; const kprint = appLib.sysCalls.SysCallPrint.kprint; export fn app_main(pid: usize) linksection(".text.main") callconv(.C) noreturn { kprint("app1 initial pid: {d} \n", .{pid}); var counter: usize = 0; var payload: []u8 = undefined; payload.ptr = @as([*]u8, @ptrCast(&counter)); payload.len = @sizeOf(@TypeOf(counter)); while (true) { var data_written = sysCalls.pushToTopic("front-ultrasonic-proximity", payload) catch |e| { kprint("syscall pushToTopic err: {s} \n", .{@errorName(e)}); while (true) {} }; if (data_written < payload.len) kprint("partially written {d}/ {d} bytes \n", .{ data_written, payload.len }); kprint("pushin: {d} \n", .{counter}); counter += 1; // const topics_interfaces_read = @intToPtr(*volatile [1000]usize, 0x20000000).*; // kprint("topics interface read: {any} \n", .{topics_interfaces_read}); } }
0
repos/MinimalRoboticsPlatform/src/environments/sysCallTopicsTest/userApps
repos/MinimalRoboticsPlatform/src/environments/sysCallTopicsTest/userApps/app1/linker.ld
ENTRY(app_main) SECTIONS { . = 0x0; .text : ALIGN(16) { *(.text.main) } .got : { *(.got.plt); *(.got); } .rodata : ALIGN(0x8) { *(.rodata); *(.rodata.*); } .bss : ALIGN(0x10) { _bss_start = .; *(.bss.*); *(COMMON); _bss_end = .; } .data : { *(.data); *(.data.*); } .heap (NOLOAD) : ALIGN(8) { _heap_start = .; } }
0
repos/MinimalRoboticsPlatform/src/environments/sysCallTopicsTest/userApps/actions
repos/MinimalRoboticsPlatform/src/environments/sysCallTopicsTest/userApps/actions/action1/main.zig
const std = @import("std"); const appLib = @import("appLib"); const board = @import("board"); const arm = @import("arm"); const cpuContext = arm.cpuContext; const AppAlloc = appLib.AppAllocator; const sysCalls = appLib.sysCalls; const kprint = appLib.sysCalls.SysCallPrint.kprint; var test_counter: usize = 0; export fn app_main(pid: usize) linksection(".text.main") callconv(.C) noreturn { _ = pid; while (true) {} }
0
repos/MinimalRoboticsPlatform/src/environments/sysCallTopicsTest/userApps/actions
repos/MinimalRoboticsPlatform/src/environments/sysCallTopicsTest/userApps/actions/action1/linker.ld
ENTRY(app_main) SECTIONS { . = 0x0; .text : ALIGN(16) { *(.text.main) } .got : { *(.got.plt); *(.got); } .rodata : ALIGN(0x8) { *(.rodata); *(.rodata.*); } .bss : ALIGN(0x10) { _bss_start = .; *(.bss.*); *(COMMON); _bss_end = .; } .data : { *(.data); *(.data.*); } .heap (NOLOAD) : ALIGN(8) { _heap_start = .; } }
0
repos/MinimalRoboticsPlatform/src/environments/sysCallTopicsTest/userApps
repos/MinimalRoboticsPlatform/src/environments/sysCallTopicsTest/userApps/app2/main.zig
const std = @import("std"); const board = @import("board"); const appLib = @import("appLib"); const Mutex = appLib.Mutex; const AppAlloc = appLib.AppAllocator; const sysCalls = appLib.sysCalls; const utils = appLib.utils; const kprint = appLib.sysCalls.SysCallPrint.kprint; var test_counter: usize = 0; var shared_thread_counter: isize = 0; var mutex = Mutex.init(); var shared_mutex: *Mutex = &mutex; export fn app_main(pid: usize) linksection(".text.main") callconv(.C) noreturn { kprint("app2 initial pid: {d} \n", .{pid}); var ret: usize = 0; var ret_buff: []u8 = undefined; ret_buff.ptr = @as([*]u8, @ptrCast(&ret)); ret_buff.len = @sizeOf(@TypeOf(ret)); while (true) { kprint("going to wait \n", .{}); sysCalls.waitForTopicUpdate("front-ultrasonic-proximity") catch |e| { kprint("syscall waitForTopicUpdate err: {s} \n", .{@errorName(e)}); // while (true) {} }; var read_len = sysCalls.popFromTopic("front-ultrasonic-proximity", ret_buff) catch |e| { kprint("syscall popFromTopic err: {s} \n", .{@errorName(e)}); while (true) {} }; if (read_len < ret_buff.len) kprint("buffer partially filled {d}/ {d} bytes \n", .{ read_len, ret_buff.len }); kprint("topic pop: {any} \n", .{ret}); } }
0
repos/MinimalRoboticsPlatform/src/environments/sysCallTopicsTest/userApps
repos/MinimalRoboticsPlatform/src/environments/sysCallTopicsTest/userApps/app2/linker.ld
ENTRY(app_main) SECTIONS { . = 0x0; .text : ALIGN(16) { *(.text.main) *(.text.); *(.text.*); } .rodata : ALIGN(0x8) { *(.rodata); *(.rodata.*); } .got : { *(.got.plt); *(.got); } .bss : ALIGN(0x10) { _bss_start = .; *(.bss.*); *(COMMON); _bss_end = .; } .data : { *(.data); *(.data.*); } .heap (NOLOAD) : ALIGN(8) { _heap_start = .; } }
0
repos/MinimalRoboticsPlatform/src/environments/sysCallTopicsTest
repos/MinimalRoboticsPlatform/src/environments/sysCallTopicsTest/kernelThreads/threads.zig
const sharedKernelServices = @import("sharedKernelServices"); const Scheduler = sharedKernelServices.Scheduler; const Thread = fn (scheduler: *Scheduler) noreturn; // threads array is loaded and inited by the kernel pub const threads = [_]Thread{};
0
repos/MinimalRoboticsPlatform/src/environments
repos/MinimalRoboticsPlatform/src/environments/statusControlTest/envConfig.zig
pub const envConfTemplate = @import("configTemplates").envConfigTemplate; const StatusControlConf = envConfTemplate.StatusControlConf; pub const env_config = envConfTemplate.EnvConfig(3){ .status_control = [_]StatusControlConf{ .{ .status_type = .isize, .name = "height", .id = 0, .topic_conf = null, }, .{ .status_type = .bool, .name = "groundContact", .id = 1, .topic_conf = null, }, .{ .status_type = .topic, .name = "height-sensor", .id = 2, .topic_conf = .{ .buffer_type = envConfTemplate.TopicBufferTypes.RingBuffer, .buffer_size = 1024, }, }, }, };
0
repos/MinimalRoboticsPlatform/src/environments/statusControlTest
repos/MinimalRoboticsPlatform/src/environments/statusControlTest/setupRoutines/raspi3bSetup.zig
const std = @import("std"); const board = @import("board"); const arm = @import("arm"); const cpuContext = arm.cpuContext; const periph = @import("periph"); const kprint = periph.uart.UartWriter(.ttbr1).kprint; const ProccessorRegMap = arm.processor.ProccessorRegMap; const sharedKernelServices = @import("sharedKernelServices"); const Scheduler = sharedKernelServices.Scheduler; pub fn bcm2835Setup(scheduler: *Scheduler) void { _ = scheduler; // enabling arm generic timer irq @as(*volatile u32, @ptrFromInt(board.PeriphConfig(.ttbr1).ArmGenericTimer.base_address)).* = 1 << 1 | 1 << 3; ProccessorRegMap.DaifReg.setDaifClr(.{ .debug = true, .serr = true, .irqs = true, .fiqs = true, }); if (board.driver.secondaryInterruptConrtollerDriver) |secondary_ic| { secondary_ic.addIcHandler(&irqHandler) catch |e| { kprint("[error] addIcHandler error: {s} \n", .{@errorName(e)}); while (true) {} }; } kprint("inited raspberry secondary Ic and arm timer \n", .{}); } pub const RegValues = struct { // all banks are lister here: https://github.com/torvalds/linux/blob/master/Documentation/devicetree/bindings/interrupt-controller/brcm%2Cbcm2835-armctrl-ic.txt pub const Bank0 = enum(u32) { armTimer = 1 << 0, armMailbox = 1 << 1, armDoorbell0 = 1 << 2, armDoorbell1 = 1 << 3, vpu0Halted = 1 << 4, vpu1Halted = 1 << 5, illegalType0 = 1 << 6, illegalType1 = 1 << 7, pending1 = 1 << 8, pending2 = 1 << 9, notDefined = 0, }; pub const Bank1 = enum(u32) { timer0 = 1 << 0, timer1 = 1 << 1, timer2 = 1 << 2, timer3 = 1 << 3, codec0 = 1 << 4, codec1 = 1 << 5, codec2 = 1 << 6, vcJpeg = 1 << 7, isp = 1 << 8, vcUsb = 1 << 9, vc3d = 1 << 10, transposer = 1 << 11, multicoresync0 = 1 << 12, multicoresync1 = 1 << 13, multicoresync2 = 1 << 14, multicoresync3 = 1 << 15, dma0 = 1 << 16, dma1 = 1 << 17, vcDma2 = 1 << 18, vcDma3 = 1 << 19, dma4 = 1 << 20, dma5 = 1 << 21, dma6 = 1 << 22, dma7 = 1 << 23, dma8 = 1 << 24, dma9 = 1 << 25, dma10 = 1 << 26, // 27: dma11-14 - shared interrupt for dma 11 to 14 dma11 = 1 << 27, // 28: dmaall - triggers on all dma interrupts (including chanel 15) dmaall = 1 << 28, aux = 1 << 29, arm = 1 << 30, vpudma = 1 << 31, notDefined = 0, }; // bank2 pub const Bank2 = enum(u32) { hostport = 1 << 0, videoscaler = 1 << 1, ccp2tx = 1 << 2, sdc = 1 << 3, dsi0 = 1 << 4, ave = 1 << 5, cam0 = 1 << 6, cam1 = 1 << 7, hdmi0 = 1 << 8, hdmi1 = 1 << 9, pixelValve1 = 1 << 10, i2cSpislv = 1 << 11, dsi1 = 1 << 12, pwa0 = 1 << 13, pwa1 = 1 << 14, cpr = 1 << 15, smi = 1 << 16, gpio0 = 1 << 17, gpio1 = 1 << 18, gpio2 = 1 << 19, gpio3 = 1 << 20, vci2c = 1 << 21, vcSpi = 1 << 22, vcI2spcm = 1 << 23, vcSdio = 1 << 24, vcUart = 1 << 25, slimbus = 1 << 26, vec = 1 << 27, cpg = 1 << 28, rng = 1 << 29, vcArasansdio = 1 << 30, avspmon = 1 << 31, notDefined = 0, }; }; // bcm2835 interrupt controller handler for raspberry const Bank0 = RegValues.Bank0; const Bank1 = RegValues.Bank1; const Bank2 = RegValues.Bank2; pub fn irqHandler(context: *cpuContext.CpuContext) void { var irq_bank_0 = std.meta.intToEnum(Bank0, board.SecondaryInterruptControllerKpiType.RegMap.pendingBasic.*) catch |e| { kprint("[panic] std meta intToEnum error: {s} \n", .{@errorName(e)}); while (true) {} }; var irq_bank_1 = std.meta.intToEnum(Bank1, board.SecondaryInterruptControllerKpiType.RegMap.pendingIrq1.*) catch |e| { kprint("[panic] std meta intToEnum error: {s} \n", .{@errorName(e)}); while (true) {} }; var irq_bank_2 = std.meta.intToEnum(Bank2, board.SecondaryInterruptControllerKpiType.RegMap.pendingIrq2.*) catch |e| { kprint("[panic] std meta intToEnum error: {s} \n", .{@errorName(e)}); while (true) {} }; switch (irq_bank_0) { // One or more bits set in pending register 1 Bank0.pending1 => { switch (irq_bank_1) { Bank1.timer1 => { if (std.mem.eql(u8, board.driver.timerDriver.timer_name, "bcm2835_timer")) { board.driver.timerDriver.timerTick(context) catch |e| { kprint("[panic] timerDriver timerTick error: {s} \n", .{@errorName(e)}); while (true) {} }; } }, else => { // kprint("Not supported 1 irq num: {s} \n", .{@tagName(irq_bank_1)}); }, } }, // One or more bits set in pending register 2 Bank0.pending2 => { switch (irq_bank_2) { else => { // kprint("Not supported bank 2 irq num: {s} \n", .{@tagName(irq_bank_0)}); }, } }, Bank0.armTimer => { if (std.mem.eql(u8, board.driver.timerDriver.timer_name, "arm_gt")) { board.driver.timerDriver.timerTick(context) catch |e| { kprint("[panic] timerDriver timerTick error: {s} \n", .{@errorName(e)}); while (true) {} }; } }, else => { // kprint("Not supported bank(neither 1/2) irq num: {d} \n", .{intController.RegMap.pendingBasic.*}); // raspberries timers are a mess and I'm currently unsure if the Arm Generic timer // has an enum defined in the banks or if it's not defined through the bcm28835 system. }, } }
0
repos/MinimalRoboticsPlatform/src/environments/statusControlTest
repos/MinimalRoboticsPlatform/src/environments/statusControlTest/setupRoutines/routines.zig
const board = @import("board"); const std = @import("std"); const sharedKernelServices = @import("sharedKernelServices"); const Scheduler = sharedKernelServices.Scheduler; const raspi3bSetup = @import("raspi3bSetup.zig").bcm2835Setup; const qemuVirtSetup = @import("qemuVirtSetup.zig").qemuVirtSetup; const SetupRoutine = fn (scheduler: *Scheduler) void; const boardSpecificSetup = blk: { if (std.mem.eql(u8, board.config.board_name, "raspi3b")) { break :blk [_]SetupRoutine{raspi3bSetup}; } else if (std.mem.eql(u8, board.config.board_name, "qemuVirt")) { break :blk [_]SetupRoutine{qemuVirtSetup}; } }; // setupRoutines array is loaded and inited by the kernel pub const setupRoutines = [_]SetupRoutine{} ++ boardSpecificSetup;
0
repos/MinimalRoboticsPlatform/src/environments/statusControlTest
repos/MinimalRoboticsPlatform/src/environments/statusControlTest/setupRoutines/qemuVirtSetup.zig
const std = @import("std"); const board = @import("board"); const arm = @import("arm"); const cpuContext = arm.cpuContext; const ProccessorRegMap = arm.processor.ProccessorRegMap; const gic = arm.gicv2.Gic(.ttbr1); const InterruptIds = gic.InterruptIds; const periph = @import("periph"); const kprint = periph.uart.UartWriter(.ttbr1).kprint; const sharedKernelServices = @import("sharedKernelServices"); const Scheduler = sharedKernelServices.Scheduler; pub fn qemuVirtSetup(scheduler: *Scheduler) void { _ = scheduler; gic.init() catch |e| { kprint("[panic] gic init error: {s}\n", .{@errorName(e)}); while (true) {} }; gic.Gicd.gicdConfig(InterruptIds.non_secure_physical_timer, 0x2) catch |e| { kprint("[panic] gicd gicdConfig error: {s}\n", .{@errorName(e)}); while (true) {} }; gic.Gicd.gicdSetPriority(InterruptIds.non_secure_physical_timer, 0) catch |e| { kprint("[panic] gicd setPriority error: {s}\n", .{@errorName(e)}); while (true) {} }; gic.Gicd.gicdSetTarget(InterruptIds.non_secure_physical_timer, 1) catch |e| { kprint("[panic] gicd setTarget error: {s}\n", .{@errorName(e)}); while (true) {} }; gic.Gicd.gicdClearPending(InterruptIds.non_secure_physical_timer) catch |e| { kprint("[panic] gicd clearPending error: {s}\n", .{@errorName(e)}); while (true) {} }; gic.Gicd.gicdEnableInt(InterruptIds.non_secure_physical_timer) catch |e| { kprint("[panic] gicdEnableInt address calc error: {s}\n", .{@errorName(e)}); while (true) {} }; ProccessorRegMap.DaifReg.setDaifClr(.{ .debug = true, .serr = true, .irqs = true, .fiqs = true, }); }
0
repos/MinimalRoboticsPlatform/src/environments/statusControlTest/userApps
repos/MinimalRoboticsPlatform/src/environments/statusControlTest/userApps/app1/main.zig
const std = @import("std"); const appLib = @import("appLib"); const board = @import("board"); const arm = @import("arm"); const cpuContext = arm.cpuContext; const AppAlloc = appLib.AppAllocator; const sysCalls = appLib.sysCalls; const kprint = appLib.sysCalls.SysCallPrint.kprint; var test_counter: usize = 0; export fn app_main(pid: usize) linksection(".text.main") callconv(.C) noreturn { kprint("app1 initial pid: {d} \n", .{pid}); var read_state: bool = true; sysCalls.updateStatus("groundContact", true) catch |e| { kprint("sysCalls updateStatus err: {s} \n", .{@errorName(e)}); }; while (true) { read_state = sysCalls.readStatus(bool, "groundContact") catch |e| { kprint("sysCalls readStatus err: {s} \n", .{@errorName(e)}); while (true) {} }; if (read_state) { sysCalls.updateStatus("groundContact", false) catch |e| { kprint("sysCalls updateStatus err: {s} \n", .{@errorName(e)}); }; kprint("status set 1 to false \n", .{}); } kprint("status read 1: {any} \n", .{read_state}); } } // var test_counter: usize = 0; // export fn app_main(pid: usize) linksection(".text.main") callconv(.C) noreturn { // kprint("app1 initial pid: {d} \n", .{pid}); // while (true) { // test_counter += 1; // sysCalls.updateStatus("height", @intCast(isize, test_counter)) catch |e| { // kprint("sysCalls updateStatus err: {s} \n", .{@errorName(e)}); // }; // var read = sysCalls.readStatus(isize, "height") catch |e| { // kprint("sysCalls readStatus err: {s} \n", .{@errorName(e)}); // while (true) {} // }; // kprint("status read: {d} \n", .{read}); // } // }
0
repos/MinimalRoboticsPlatform/src/environments/statusControlTest/userApps
repos/MinimalRoboticsPlatform/src/environments/statusControlTest/userApps/app1/linker.ld
ENTRY(app_main) SECTIONS { . = 0x0; .text : ALIGN(16) { *(.text.main) } .got : { *(.got.plt); *(.got); } .rodata : ALIGN(0x8) { *(.rodata); *(.rodata.*); } .bss : ALIGN(0x10) { _bss_start = .; *(.bss.*); *(COMMON); _bss_end = .; } .data : { *(.data); *(.data.*); } .heap (NOLOAD) : ALIGN(8) { _heap_start = .; } }
0
repos/MinimalRoboticsPlatform/src/environments/statusControlTest/userApps/actions
repos/MinimalRoboticsPlatform/src/environments/statusControlTest/userApps/actions/action1/main.zig
const std = @import("std"); const appLib = @import("appLib"); const board = @import("board"); const arm = @import("arm"); const cpuContext = arm.cpuContext; const AppAlloc = appLib.AppAllocator; const sysCalls = appLib.sysCalls; const kprint = appLib.sysCalls.SysCallPrint.kprint; var test_counter: usize = 0; export fn app_main(pid: usize) linksection(".text.main") callconv(.C) noreturn { _ = pid; while (true) {} }
0
repos/MinimalRoboticsPlatform/src/environments/statusControlTest/userApps/actions
repos/MinimalRoboticsPlatform/src/environments/statusControlTest/userApps/actions/action1/linker.ld
ENTRY(app_main) SECTIONS { . = 0x0; .text : ALIGN(16) { *(.text.main) } .got : { *(.got.plt); *(.got); } .rodata : ALIGN(0x8) { *(.rodata); *(.rodata.*); } .bss : ALIGN(0x10) { _bss_start = .; *(.bss.*); *(COMMON); _bss_end = .; } .data : { *(.data); *(.data.*); } .heap (NOLOAD) : ALIGN(8) { _heap_start = .; } }
0
repos/MinimalRoboticsPlatform/src/environments/statusControlTest/userApps
repos/MinimalRoboticsPlatform/src/environments/statusControlTest/userApps/app2/main.zig
const std = @import("std"); const board = @import("board"); const appLib = @import("appLib"); const Mutex = appLib.Mutex; const AppAlloc = appLib.AppAllocator; const sysCalls = appLib.sysCalls; const utils = appLib.utils; const kprint = appLib.sysCalls.SysCallPrint.kprint; var test_counter: usize = 0; var shared_thread_counter: isize = 0; var mutex = Mutex.init(); var shared_mutex: *Mutex = &mutex; export fn app_main(pid: usize) linksection(".text.main") callconv(.C) noreturn { kprint("app2 initial pid: {d} \n", .{pid}); var read_state: bool = false; while (true) { // test_counter += 1; // kprint("app{d} test print {d} \n", .{ pid, test_counter }); read_state = sysCalls.readStatus(bool, "groundContact") catch |e| { kprint("sysCalls readStatus err: {s} \n", .{@errorName(e)}); while (true) {} }; if (!read_state) { sysCalls.updateStatus("groundContact", true) catch |e| { kprint("sysCalls updateStatus err: {s} \n", .{@errorName(e)}); }; kprint("status set 2 to true \n", .{}); } kprint("status read 2: {any} \n", .{read_state}); } }
0
repos/MinimalRoboticsPlatform/src/environments/statusControlTest/userApps
repos/MinimalRoboticsPlatform/src/environments/statusControlTest/userApps/app2/linker.ld
ENTRY(app_main) SECTIONS { . = 0x0; .text : ALIGN(16) { *(.text.main) *(.text.); *(.text.*); } .rodata : ALIGN(0x8) { *(.rodata); *(.rodata.*); } .got : { *(.got.plt); *(.got); } .bss : ALIGN(0x10) { _bss_start = .; *(.bss.*); *(COMMON); _bss_end = .; } .data : { *(.data); *(.data.*); } .heap (NOLOAD) : ALIGN(8) { _heap_start = .; } }
0
repos/MinimalRoboticsPlatform/src/environments/statusControlTest
repos/MinimalRoboticsPlatform/src/environments/statusControlTest/kernelThreads/threads.zig
const sharedKernelServices = @import("sharedKernelServices"); const Scheduler = sharedKernelServices.Scheduler; const Thread = fn (scheduler: *Scheduler) noreturn; pub const testThread = @import("testThread.zig"); // threads array is loaded and inited by the kernel pub const threads = [_]Thread{testThread.threadFn};
0
repos/MinimalRoboticsPlatform/src/environments/statusControlTest
repos/MinimalRoboticsPlatform/src/environments/statusControlTest/kernelThreads/testThread.zig
const std = @import("std"); const board = @import("board"); const arm = @import("arm"); const cpuContext = arm.cpuContext; const periph = @import("periph"); const kprint = periph.uart.UartWriter(.ttbr1).kprint; const sharedKernelServices = @import("sharedKernelServices"); const Scheduler = sharedKernelServices.Scheduler; pub fn threadFn(scheduler: *Scheduler) noreturn { _ = scheduler; while (true) {} }
0
repos/MinimalRoboticsPlatform/src
repos/MinimalRoboticsPlatform/src/periph/pl011.zig
const std = @import("std"); const board = @import("board"); const AddrSpace = board.boardConfig.AddrSpace; pub fn Pl011(comptime addr_space: AddrSpace) type { const pl011Cfg = board.PeriphConfig(addr_space).Pl011; return struct { const RegMap = struct { pub const dataReg = @as(*volatile u32, @ptrFromInt(pl011Cfg.base_address + 0x000)); pub const flagReg = @as(*volatile u32, @ptrFromInt(pl011Cfg.base_address + 0x018)); pub const intBaudRateReg = @as(*volatile u32, @ptrFromInt(pl011Cfg.base_address + 0x024)); pub const fracBaudRateReg = @as(*volatile u32, @ptrFromInt(pl011Cfg.base_address + 0x028)); pub const lineCtrlReg = struct { pub const reg = @as(*volatile u32, @ptrFromInt(pl011Cfg.base_address + 0x02c)); pub const RegAttr = packed struct { padding: u24 = 0, stick_parity_select: bool = false, tx_word_len: u2 = 3, // 3 => b11 => 8 bits enable_fifo: bool = false, two_stop_bits_select: bool = false, even_parity_select: bool = false, parity_enabled: bool = false, send_break: bool = false, pub fn asInt(self: RegAttr) u32 { return @as(u32, @bitCast(self)); } }; }; pub const ctrlReg = struct { pub const reg = @as(*volatile u32, @ptrFromInt(pl011Cfg.base_address + 0x030)); pub const RegAttr = packed struct { padding: u16 = 0, cts_hwflow_ctrl_en: bool = false, rts_hwflow_ctrl_en: bool = false, out2: bool = false, ou1: bool = false, req_to_send: bool = false, data_tx_ready: bool = false, rec_enable: bool = false, tx_enable: bool = false, loopback_enable: bool = false, reserved: u4 = 0, sir_low_power_irda_mode: bool = false, sir_enable: bool = false, uart_enable: bool = false, pub fn asInt(self: RegAttr) u32 { return @as(u32, @bitCast(self)); } }; }; pub const intMaskSetClearReg = @as(*volatile u32, @ptrFromInt(pl011Cfg.base_address + 0x038)); pub const dmaCtrlReg = @as(*volatile u32, @ptrFromInt(pl011Cfg.base_address + 0x048)); }; fn waitForTransmissionEnd() void { // 1 << 3 -> busy bit in flagReg reg while (RegMap.flagReg.* & @as(u32, 1 << 3) != 0) {} } // used for fracBaudRateReg, intBaudRateReg config registers fn calcClockDevisor() struct { integer: u16, fraction: u6 } { const div: u32 = 4 * pl011Cfg.base_clock / pl011Cfg.baudrate; return .{ .integer = (div >> 6) & 0xffff, .fraction = div & 0x3f }; } pub fn init() void { // disable uart RegMap.ctrlReg.reg.* = (RegMap.ctrlReg.RegAttr{ .uart_enable = false }).asInt(); waitForTransmissionEnd(); // flush fifo RegMap.lineCtrlReg.reg.* = RegMap.lineCtrlReg.reg.* & ~@as(u32, 1 << 4); // calc int and fraction part of the clock devisor and write it to regs const dev = calcClockDevisor(); RegMap.intBaudRateReg.* = dev.integer; RegMap.fracBaudRateReg.* = dev.fraction; var two_stop_bits = false; if (pl011Cfg.stop_bits == 2) two_stop_bits = true; if (pl011Cfg.data_bits != 8) @compileError("pl011 only supports 8 bit wlen"); RegMap.lineCtrlReg.reg.* = (RegMap.lineCtrlReg.RegAttr{ .two_stop_bits_select = two_stop_bits, .tx_word_len = 3, .enable_fifo = false, }).asInt(); // Mask all interrupts by setting corresponding bits to 1 RegMap.intMaskSetClearReg.* = 0x7ff; // Disable DMA by setting all bits to 0 RegMap.dmaCtrlReg.* = 0; // enabling only tx (has to happen first according to docs) RegMap.ctrlReg.reg.* = (RegMap.ctrlReg.RegAttr{ .tx_enable = true }).asInt(); RegMap.ctrlReg.reg.* = (RegMap.ctrlReg.RegAttr{ .tx_enable = true, .uart_enable = true }).asInt(); } pub fn write(data: []const u8) void { waitForTransmissionEnd(); for (data) |ch| { RegMap.dataReg.* = ch; waitForTransmissionEnd(); } } }; }
0
repos/MinimalRoboticsPlatform/src
repos/MinimalRoboticsPlatform/src/periph/periph.zig
pub const Pl011 = @import("pl011.zig").Pl011; pub const uart = @import("uart.zig");
0
repos/MinimalRoboticsPlatform/src
repos/MinimalRoboticsPlatform/src/periph/uart.zig
const std = @import("std"); const board = @import("board"); const AddrSpace = board.boardConfig.AddrSpace; pub fn UartWriter(comptime addr_space: AddrSpace) type { const pl011 = @import("pl011.zig").Pl011(addr_space); return struct { const Self = @This(); pub const Writer = std.io.Writer(*Self, error{}, appendWrite); pub fn writer(self: *Self) Writer { return .{ .context = self }; } /// Same as `append` except it returns the number of bytes written, which is always the same /// as `m.len`. The purpose of this function existing is to match `std.io.Writer` API. fn appendWrite(self: *Self, data: []const u8) error{}!usize { _ = self; pl011.write(data); return data.len; } pub fn kprint(comptime print_string: []const u8, args: anytype) void { var tempW: UartWriter(addr_space) = undefined; std.fmt.format(tempW.writer(), print_string, args) catch |err| { @panic(err); }; } }; }
0
repos/MinimalRoboticsPlatform/src
repos/MinimalRoboticsPlatform/src/bootloader/utils.zig
const kprint = @import("periph").uart.UartWriter(.ttbr0).kprint; pub fn panic() noreturn { kprint("[bootloader] panic \n", .{}); while (true) {} }
0
repos/MinimalRoboticsPlatform/src
repos/MinimalRoboticsPlatform/src/bootloader/linker.ld
ENTRY(_start) SECTIONS { . = {@zig}; _bl_bin_start = .; .text : ALIGN(16) { *(.text.boot) } .exceptions : ALIGN(0x800) { *(.text.exc_vec); } .rodata : ALIGN(0x8) { *(.rodata); *(.rodata.*); } .bootloader : ALIGN(16) { *(.text.); *(.text.*); } .got : { *(.got.plt); *(.got); } .bss : ALIGN(0x10) { _bss_start = .; *(.bss.*); *(COMMON); _bss_end = .; } .data : { *(.data); *(.data.*); } .bl_end (NOLOAD) : ALIGN(8) { _bl_end = .; } }
0
repos/MinimalRoboticsPlatform/src
repos/MinimalRoboticsPlatform/src/bootloader/bootloader.zig
const std = @import("std"); const alignForward = std.mem.alignForward; const utils = @import("utils"); // bootloader specific const board = @import("board"); const PeriphConfig = board.PeriphConfig(.ttbr0); const bl_utils = @import("utils.zig"); const intHandle = @import("blIntHandler.zig"); const b_options = @import("build_options"); // general periphs const periph = @import("periph"); // .ttbr0 arg sets the addresses value to either or user_, kernel_space const pl011 = periph.Pl011(.ttbr0); const kprint = periph.uart.UartWriter(.ttbr0).kprint; const arm = @import("arm"); const gic = arm.gicv2.Gic(.ttbr0); const ProccessorRegMap = arm.processor.ProccessorRegMap; const mmu = arm.mmu; const Granule = board.boardConfig.Granule; const GranuleParams = board.boardConfig.GranuleParams; const TransLvl = board.boardConfig.TransLvl; const kernel_bin = @embedFile("bins/kernel.bin"); // note: when bl_main gets too big(instruction mem wise), the exception vector table could be pushed too far up and potentially not be read! // todo => remember => callconv(.Naked) removed... export fn bl_main() linksection(".text.boot") noreturn { // setting stack pointer to writable memory (ram (userspace)) // using userspace as stack, incase the bootloader is located in rom const user_space_start = blk: { var user_space_start_tmp = (board.config.mem.bl_load_addr orelse 0) + (board.config.mem.rom_size orelse 0) + board.config.mem.kernel_space_size; // increasing user_space_start_tmp by stack_size so that later writes to the user_space don't overwrite the bl's stack user_space_start_tmp += board.config.mem.bl_stack_size; const aligned_userspace_addr = alignForward(usize, user_space_start_tmp, 16); ProccessorRegMap.setSp(aligned_userspace_addr); break :blk user_space_start_tmp; }; const _bl_bin_end: usize = @intFromPtr(@extern(?*u8, .{ .name = "_bl_end" }) orelse { kprint("[panic] error reading _bl_end label\n", .{}); bl_utils.panic(); }); var boot_without_rom_new_kernel_loc: usize = alignForward(usize, _bl_bin_end, 4096); if (board.config.mem.bl_load_addr == null) boot_without_rom_new_kernel_loc = 0; // mmu configuration... { const ttbr1 = blk: { const page_table = mmu.PageTable(board.config.mem.ram_size, Granule.Fourk) catch |e| { kprint("[panic] Page table init error: {s}\n", .{@errorName(e)}); bl_utils.panic(); }; // writing page dirs to userspace in ram. Writing to userspace because it would be overwritten in kernel space, when copying // the kernel. Additionally, on mmu turn on, the mmu would try to read from the page tables without mmu kernel space identifier bits on const ttbr1_mem = @as(*volatile [page_table.totaPageTableSize]usize, @ptrFromInt(alignForward(usize, user_space_start, Granule.Fourk.page_size))); // mapping general kernel mem (inlcuding device base) var ttbr1_write = page_table.init(ttbr1_mem, 0) catch |e| { kprint("[panic] Page table init error: {s}\n", .{@errorName(e)}); bl_utils.panic(); }; // creating virtual address space for kernel const kernel_mapping = mmu.Mapping{ .mem_size = board.config.mem.ram_size, .pointing_addr_start = board.config.mem.ram_start_addr + boot_without_rom_new_kernel_loc, .virt_addr_start = 0, .granule = Granule.Fourk, .addr_space = .ttbr1, .flags_last_lvl = mmu.TableDescriptorAttr{ .accessPerm = .only_el1_read_write, .attrIndex = .mair0 }, .flags_non_last_lvl = mmu.TableDescriptorAttr{ .accessPerm = .only_el1_read_write }, }; ttbr1_write.mapMem(kernel_mapping) catch |e| { kprint("[panic] Page table write error: {s}\n", .{@errorName(e)}); bl_utils.panic(); }; break :blk ttbr1_mem; }; const ttbr0 = blk: { // in case there is no rom(rom_size is equal to zero) and the kernel(and bl) are directly loaded to memory by some rom bootloader // the ttbr0 memory is also identity mapped to the ram const mapping_bl_phys_size: usize = (board.config.mem.rom_size orelse 0) + board.config.mem.ram_size; const page_table = mmu.PageTable(mapping_bl_phys_size, Granule.FourkSection) catch |e| { kprint("[panic] Page table init error: {s}\n", .{@errorName(e)}); bl_utils.panic(); }; var ttbr0_addr = user_space_start + (ttbr1.len * @sizeOf(usize)); ttbr0_addr = alignForward(usize, ttbr0_addr, Granule.Fourk.page_size); const ttbr0_mem = @as(*volatile [page_table.totaPageTableSize]usize, @ptrFromInt(ttbr0_addr)); // MMU page dir config // identity mapped memory for bootloader and kernel control handover! var ttbr0_write = page_table.init(ttbr0_mem, 0) catch |e| { kprint("[panic] Page table init error: {s}\n", .{@errorName(e)}); bl_utils.panic(); }; // writing to _id_mapped_dir(label) page table and creating new // identity mapped memory for bootloader to kernel transfer const bootloader_mapping = mmu.Mapping{ .mem_size = mapping_bl_phys_size, .pointing_addr_start = 0, .virt_addr_start = 0, .granule = Granule.FourkSection, .addr_space = .ttbr0, .flags_last_lvl = mmu.TableDescriptorAttr{ .accessPerm = .only_el1_read_write, .attrIndex = .mair0 }, .flags_non_last_lvl = mmu.TableDescriptorAttr{ .accessPerm = .only_el1_read_write }, }; ttbr0_write.mapMem(bootloader_mapping) catch |e| { kprint("[panic] Page table write error: {s}\n", .{@errorName(e)}); bl_utils.panic(); }; break :blk ttbr0_mem; }; // kprint("ttbr1: 0x{x} \n", .{@ptrToInt(ttbr1)}); // kprint("ttbr0: 0x{x} \n", .{@ptrToInt(ttbr0)}); // updating page dirs ProccessorRegMap.setTTBR0(@intFromPtr(ttbr0)); ProccessorRegMap.setTTBR1(@intFromPtr(ttbr1)); ProccessorRegMap.TcrReg.setTcrEl(.el1, (ProccessorRegMap.TcrReg{ .t0sz = 25, .t1sz = 25, .tg0 = 0, .tg1 = 0 }).asInt()); // attr0 is normal mem, not cachable ProccessorRegMap.MairReg.setMairEl(.el1, (ProccessorRegMap.MairReg{ .attr0 = 0xFF, .attr1 = 0x0, .attr2 = 0x0, .attr3 = 0x0, .attr4 = 0x0 }).asInt()); ProccessorRegMap.invalidateMmuTlbEl1(); ProccessorRegMap.invalidateCache(); ProccessorRegMap.isb(); ProccessorRegMap.dsb(); kprint("[bootloader] enabling mmu... \n", .{}); ProccessorRegMap.enableMmu(.el1); ProccessorRegMap.nop(); ProccessorRegMap.nop(); } // GIC Init if (std.mem.eql(u8, board.config.board_name, "qemuVirt")) { gic.init() catch |e| { kprint("[panic] GIC init error: {s} \n", .{@errorName(e)}); bl_utils.panic(); }; pl011.init(); } const current_el = ProccessorRegMap.getCurrentEl(); if (current_el != 1) { kprint("[panic] el must be 1! (it's: {d})\n", .{current_el}); bl_utils.panic(); } { var kernel_target_loc: []u8 = undefined; kernel_target_loc.ptr = @as([*]u8, @ptrFromInt(board.config.mem.va_start)); kernel_target_loc.len = kernel_bin.len; kprint("[bootloader] Copying kernel to addr_space: 0x{x}, with size: {d} \n", .{ @intFromPtr(kernel_target_loc.ptr), kernel_target_loc.len }); std.mem.copy(u8, kernel_target_loc, kernel_bin); const kernel_addr = @intFromPtr(kernel_target_loc.ptr); const kernel_sp = blk: { const aligned_ksize = alignForward(usize, kernel_target_loc.len, 0x8); break :blk utils.toTtbr1(usize, aligned_ksize + board.config.mem.k_stack_size); }; asm volatile ( \\mov sp, %[sp] \\mov x0, %[boot_without_rom_new_kernel_loc] \\br %[pc_addr] : : [sp] "r" (kernel_sp), [boot_without_rom_new_kernel_loc] "r" (boot_without_rom_new_kernel_loc), [pc_addr] "r" (kernel_addr), ); } while (true) {} } comptime { @export(intHandle.trapHandler, .{ .name = "trapHandler", .linkage = .Strong }); }
0
repos/MinimalRoboticsPlatform/src
repos/MinimalRoboticsPlatform/src/bootloader/exc_vec.S
.section .text.exc_vec .macro EXCEPTION_VECTOR int_type // storing CpuContext src/arm/CpuContext.zig on stack stp q1, q0, [sp, #-32]! stp q3, q2, [sp, #-32]! stp q5, q4, [sp, #-32]! stp q7, q6, [sp, #-32]! stp q9, q8, [sp, #-32]! stp q11, q10, [sp, #-32]! stp q13, q12, [sp, #-32]! stp q15, q14, [sp, #-32]! stp q17, q16, [sp, #-32]! stp q19, q18, [sp, #-32]! stp q21, q20, [sp, #-32]! stp q23, q22, [sp, #-32]! stp q25, q24, [sp, #-32]! stp q27, q26, [sp, #-32]! stp q29, q28, [sp, #-32]! stp q31, q30, [sp, #-32]! // gp regs stp x1, x0, [sp, #-16]! stp x3, x1, [sp, #-16]! stp x5, x4, [sp, #-16]! stp x7, x6, [sp, #-16]! stp x9, x8, [sp, #-16]! stp x11, x10, [sp, #-16]! stp x13, x12, [sp, #-16]! stp x15, x14, [sp, #-16]! stp x17, x16, [sp, #-16]! stp x19, x18, [sp, #-16]! stp x21, x20, [sp, #-16]! stp x23, x22, [sp, #-16]! stp x25, x24, [sp, #-16]! stp x27, x26, [sp, #-16]! stp x29, x28, [sp, #-16]! // sys regs mov x1, sp stp x1, x30, [sp, #-16]! mov x0, fp mrs x3, elr_el1 stp x3, x0, [sp, #-16]! mrs x0, sp_el0 // debug regs mrs x3, SPSel stp x3, x0, [sp, #-16]! mrs x0, far_el1 mrs x3, esr_el1 stp x0, x3, [sp, #-16]! mrs x0, CurrentEL lsr x0, x0, #2 stp xzr, x0, [sp, #-16]! // end of CpuState stack store // set stack as arg mov x0, sp ldr x1, #\int_type bl trapHandler // restoreContextFromStack are fns exported from CpuContext.zig b _restoreContextWithoutSwitchFromSp .endm // https://developer.arm.com/documentation/100933/0100/AArch64-exception-vector-table .globl _exception_vector_table .balign 0x80 _exception_vector_table: EXCEPTION_VECTOR el1Sp0Sync // el1_sp0_sync .balign 0x80 EXCEPTION_VECTOR el1Sp0Irq // el1_sp0_irq .balign 0x80 EXCEPTION_VECTOR el1Sp0Fiq // el1_sp0_fiq .balign 0x80 EXCEPTION_VECTOR el1Sp0Err // el1_sp0_error .balign 0x80 EXCEPTION_VECTOR el1Sync // el1Sync .balign 0x80 EXCEPTION_VECTOR el1Irq // el1Irq .balign 0x80 EXCEPTION_VECTOR el1Fiq // el1Fiq .balign 0x80 EXCEPTION_VECTOR el1Err // el1Error .balign 0x80 EXCEPTION_VECTOR el0Sync // el0_sync .balign 0x80 EXCEPTION_VECTOR el0Irq // el0_irq .balign 0x80 EXCEPTION_VECTOR el0Fiq // el0_fiq .balign 0x80 EXCEPTION_VECTOR el0Err // el0_error .balign 0x80 EXCEPTION_VECTOR el032Sync // el0_32_sync .balign 0x80 EXCEPTION_VECTOR el032Irq // el0_32_irq .balign 0x80 EXCEPTION_VECTOR el032Fiq // el0_32_fiq .balign 0x80 EXCEPTION_VECTOR el032Err // el0_32_error .balign 0x80
0
repos/MinimalRoboticsPlatform/src
repos/MinimalRoboticsPlatform/src/bootloader/blIntHandler.zig
const std = @import("std"); const bl_utils = @import("utils.zig"); const arm = @import("arm"); const ProccessorRegMap = arm.processor.ProccessorRegMap; const CpuContext = arm.cpuContext.CpuContext; const periph = @import("periph"); const kprint = periph.uart.UartWriter(.ttbr0).kprint; const gic = arm.gicv2; const timer = arm.timer; pub const ExceptionClass = enum(u6) { unknownReason = 0b000000, trappedWF = 0b000001, trappedMCR = 0b000011, trappedMcrr = 0b000100, trappedMCRWithAcc = 0b000101, trappedLdcStcAcc = 0b000110, sveAsmidFpAcc = 0b000111, trappedLdStInst = 0b001010, trappedMrrcWithAcc = 0b001100, branchTargetExc = 0b001101, illegalExecState = 0b001110, svcInstExcAArch32 = 0b010001, svcInstExAArch64 = 0b010101, trappedMsrMrsSiAarch64 = 0b011000, sveFuncTrappedAcc = 0b011001, excFromPointerAuthInst = 0b011100, instAbortFromLowerExcLvl = 0b100000, instAbortTakenWithoutExcLvlChange = 0b100001, pcAlignFaultExc = 0b100010, dataAbortFromLowerExcLvl = 0b100100, dataAbortWithoutExcLvlChange = 0b100101, spAlignmentFaultExc = 0b100110, trappedFpExcAarch32 = 0b101000, trappedFpExcAarch64 = 0b101100, brkPExcFromLowerExcLvl = 0b101111, brkPExcWithoutExcLvlChg = 0b110001, softwStepExcpFromLowerExcLvl = 0b110010, softwStepExcTakenWithoutExcLvlChange = 0b110011, watchPointExcpFromALowerExcLvl = 0b110100, watchPointExcpWithoutTakenWithoutExcLvlChange = 0b110101, bkptInstExecAarch32 = 0b111000, bkptInstExecAarch64 = 0b111100, }; pub fn trapHandler(temp_context: *CpuContext, tmp_int_type: usize) callconv(.C) noreturn { const int_type = tmp_int_type; const int_type_en = std.meta.intToEnum(gic.ExceptionType, int_type) catch { kprint("intToEnum int_type failed \n", .{}); bl_utils.panic(); }; temp_context.int_type = int_type; kprint("bl irqHandler \n", .{}); const iss = @as(u25, @truncate(temp_context.esr_el1)); const ifsc = @as(u6, @truncate(temp_context.esr_el1)); const il = @as(u1, @truncate(temp_context.esr_el1 >> 25)); const ec = @as(u6, @truncate(temp_context.esr_el1 >> 26)); const iss2 = @as(u5, @truncate(temp_context.esr_el1 >> 32)); _ = iss; _ = iss2; const ec_en = std.meta.intToEnum(ExceptionClass, ec) catch { kprint("esp exception class not found \n", .{}); bl_utils.panic(); }; const ifsc_en = std.meta.intToEnum(ProccessorRegMap.Esr_el1.Ifsc, ifsc) catch { kprint("esp exception class not found \n", .{}); bl_utils.panic(); }; kprint(".........sync exc............\n", .{}); kprint("Exception Class(from esp reg): {s} \n", .{@tagName(ec_en)}); kprint("IFC(from esp reg): {s} \n", .{@tagName(ifsc_en)}); kprint("- debug info: \n", .{}); kprint("Int Type: {s} \n", .{@tagName(int_type_en)}); kprint("el: {d} \n", .{temp_context.el}); kprint("esr_el1: 0x{x} \n", .{temp_context.esr_el1}); kprint("far_el1: 0x{x} \n", .{temp_context.far_el1}); kprint("elr_el1: 0x{x} \n", .{temp_context.elr_el1}); kprint("- sys regs: \n", .{}); kprint("sp: 0x{x} \n", .{temp_context.sp_el1}); kprint("sp_el0: 0x{x} \n", .{temp_context.sp_el0}); kprint("spSel: {d} \n", .{temp_context.sp_sel}); kprint("lr(x30): 0x{x} \n", .{temp_context.x30}); kprint("x0: 0x{x}, x1: 0x{x}, x2: 0x{x}, x3: 0x{x}, x4: 0x{x} \n", .{ temp_context.x0, temp_context.x1, temp_context.x2, temp_context.x3, temp_context.x4 }); kprint("x5: 0x{x}, x6: 0x{x}, x7: 0x{x}, x8: 0x{x}, x9: 0x{x} \n", .{ temp_context.x5, temp_context.x6, temp_context.x7, temp_context.x8, temp_context.x9 }); kprint("x10: 0x{x}, x11: 0x{x}, x12: 0x{x}, x13: 0x{x}, x14: 0x{x} \n", .{ temp_context.x10, temp_context.x11, temp_context.x12, temp_context.x13, temp_context.x14 }); kprint("x15: 0x{x}, x16: 0x{x}, x17: 0x{x}, x18: 0x{x}, x19: 0x{x} \n", .{ temp_context.x15, temp_context.x16, temp_context.x17, temp_context.x18, temp_context.x19 }); kprint("x20: 0x{x}, x21: 0x{x}, x22: 0x{x}, x23: 0x{x}, x24: 0x{x} \n", .{ temp_context.x20, temp_context.x21, temp_context.x22, temp_context.x23, temp_context.x24 }); kprint("x25: 0x{x}, x26: 0x{x}, x27: 0x{x}, x28: 0x{x}, x29: 0x{x} \n", .{ temp_context.x25, temp_context.x26, temp_context.x27, temp_context.x28, temp_context.x29 }); if (il == 1) { kprint("32 bit instruction trapped \n", .{}); } else { kprint("16 bit instruction trapped \n", .{}); } kprint(".........sync temp_context............\n", .{}); bl_utils.panic(); }
0
repos/MinimalRoboticsPlatform/src
repos/MinimalRoboticsPlatform/src/kpi/timerKpi.zig
const std = @import("std"); const Scheduler = @import("sharedKernelServices").Scheduler; const arm = @import("arm"); const CpuContext = arm.cpuContext.CpuContext; // global user required since timer is handleTimerIrq is called from the exception vector table extern var scheduler: *Scheduler; pub fn TimerKpi( comptime Context: type, comptime TimerError: type, comptime initTimer: fn (context: Context) TimerError!void, comptime handleTimerTick: fn (context: Context) TimerError!void, comptime timer_name: []const u8, ) type { return struct { const Self = @This(); pub const Error = TimerError; context: Context, timer_name: []const u8, pub fn init(context: Context) Self { return .{ .context = context, .timer_name = timer_name, }; } pub fn initTimerDriver(self: Self) Error!void { try initTimer(self.context); } pub fn timerTick(self: Self, irq_context: *CpuContext) Error!void { try handleTimerTick(self.context); scheduler.timerIntEvent(irq_context); } }; }
0
repos/MinimalRoboticsPlatform/src
repos/MinimalRoboticsPlatform/src/kpi/kpi.zig
pub const TimerKpi = @import("timerKpi.zig").TimerKpi; pub const SecondaryInterruptControllerKpi = @import("secondaryInterruptControllerKpi.zig").SecondaryInterruptControllerKpi;
0
repos/MinimalRoboticsPlatform/src
repos/MinimalRoboticsPlatform/src/kpi/secondaryInterruptControllerKpi.zig
const std = @import("std"); const arm = @import("arm"); const cpuContext = arm.cpuContext; pub fn SecondaryInterruptControllerKpi( comptime Context: type, comptime IcError: type, comptime initIcDriver_: fn (context: Context) IcError!void, comptime addIcHandler_: fn (context: Context, handler_fn: *const fn (cpu_context: *cpuContext.CpuContext) void) IcError!void, comptime RegMap_: type, ) type { return struct { const Self = @This(); pub const Error = IcError; pub const RegMap = RegMap_; context: Context, pub fn init(context: Context) Self { return .{ .context = context, }; } pub fn initIcDriver(self: Self) Error!void { try initIcDriver_(self.context); } pub fn addIcHandler(self: Self, handler_fn: *const fn (cpu_context: *cpuContext.CpuContext) void) Error!void { try addIcHandler_(self.context, handler_fn); } }; }
0
repos/MinimalRoboticsPlatform/src
repos/MinimalRoboticsPlatform/src/boards/qemuVirt.zig
pub const boardConfig = @import("configTemplates").boardConfigTemplate; const kpi = @import("kpi"); const timerDriver = @import("timerDriver"); const genericTimer = timerDriver.genericTimer; // mmu starts at lvl1 for which 0xFFFFFF8000000000 is the lowest possible va const vaStart: usize = 0xFFFFFF8000000000; pub const config = boardConfig.BoardConfig{ .board_name = "qemuVirt", .mem = boardConfig.BoardConfig.BoardMemLayout{ .va_start = vaStart, .bl_stack_size = 0x10000, .k_stack_size = 0x10000, .app_stack_size = 0x20000, .app_vm_mem_size = 0x1000000, .rom_size = 0x40000000, // since the bootloader is loaded at 0x no bl_load_addr is required // (currently only supported for boot without rom) .bl_load_addr = null, // according to qemu docs ram starts at 1gib .ram_start_addr = 0x40000000, // the ram_size needs to be greater or equal to: kernel_space_size + user_space_size .ram_size = 0x80000000, // the kernel space starts at ram_start or bl_load_addr .kernel_space_size = 0x60000000, .user_space_size = 0x20000000, .va_kernel_space_gran = boardConfig.Granule.Fourk, .va_kernel_space_page_table_capacity = 0x40000000, .va_user_space_gran = boardConfig.Granule.Fourk, .va_user_space_page_table_capacity = 0x40000000, .storage_start_addr = 0, .storage_size = 0, }, .static_memory_reserves = boardConfig.BoardConfig.StaticMemoryReserves{ .ksemaphore_max_process_in_queue = 1000, .semaphore_max_process_in_queue = 1000, .mutex_max_process_in_queue = 1000, .topics_max_process_in_queue = 1000, }, .scheduler_freq_in_hertz = 250, }; pub const GenericTimerType = genericTimer.GenericTimer(null, config.scheduler_freq_in_hertz); var genericTimerInst = GenericTimerType.init(); pub const GenericTimerKpiType = kpi.TimerKpi(*GenericTimerType, GenericTimerType.Error, GenericTimerType.setupGt, GenericTimerType.timerInt, GenericTimerType.timer_name); pub const driver = boardConfig.Driver(GenericTimerKpiType, null){ .timerDriver = GenericTimerKpiType.init(&genericTimerInst), .secondaryInterruptConrtollerDriver = null, }; pub fn PeriphConfig(comptime addr_space: boardConfig.AddrSpace) type { const new_ttbr1_device_base_ = 0x30000000; comptime var device_base_mapping_bare: usize = 0x8000000; // in ttbr1 all periph base is mapped to 0x40000000 if (addr_space.isKernelSpace()) device_base_mapping_bare = config.mem.va_start + new_ttbr1_device_base_; return struct { pub const device_base_size: usize = 0xA000000; pub const device_base: usize = device_base_mapping_bare; pub const new_ttbr1_device_base = new_ttbr1_device_base_; pub const Pl011 = struct { pub const base_address: u64 = device_base + 0x1000000; pub const base_clock: u64 = 0x16e3600; // 9600 slower baud pub const baudrate: u32 = 115200; pub const data_bits: u32 = 8; pub const stop_bits: u32 = 1; }; pub const GicV2 = struct { pub const base_address: u64 = device_base + 0; }; }; }
0
repos/MinimalRoboticsPlatform/src
repos/MinimalRoboticsPlatform/src/boards/raspi3b.zig
pub const boardConfig = @import("configTemplates").boardConfigTemplate; const kpi = @import("kpi"); const timerDriver = @import("timerDriver"); const bcm2835Timer = timerDriver.bcm2835Timer; const genericTimer = timerDriver.genericTimer; const bcm2835IntController = @import("interruptControllerDriver").bcm2835InterruptController; // mmu starts at lvl1 for which 0xFFFFFF8000000000 is the lowest possible va const vaStart: usize = 0xFFFFFF8000000000; pub const config = boardConfig.BoardConfig{ .board_name = "raspi3b", .mem = .{ .va_start = vaStart, .bl_stack_size = 0x10000, .k_stack_size = 0x10000, .app_stack_size = 0x20000, .app_vm_mem_size = 0x1000000, .rom_size = null, .bl_load_addr = 0x80000, // the raspberries addressable memory is all ram .ram_start_addr = 0, // the ram_size needs to be greater or equal to: kernel_space_size + user_space_size + (bl_load_addr or rom_size) .ram_size = 0x40000000, .kernel_space_size = 0x20000000, .user_space_size = 0x20000000, // has to be Fourk since without a rom the kernel is positioned at a (addr % 2mb) != 0, so a 4kb granule is required .va_kernel_space_gran = boardConfig.Granule.Fourk, .va_kernel_space_page_table_capacity = 0x40000000, .va_user_space_gran = boardConfig.Granule.Fourk, .va_user_space_page_table_capacity = 0x40000000, .storage_start_addr = 0, .storage_size = 0, }, .static_memory_reserves = boardConfig.BoardConfig.StaticMemoryReserves{ .ksemaphore_max_process_in_queue = 1000, .semaphore_max_process_in_queue = 1000, .mutex_max_process_in_queue = 1000, .topics_max_process_in_queue = 1000, }, .scheduler_freq_in_hertz = 250, }; // --- driver --- pub const GenericTimerType = genericTimer.GenericTimer(null, config.scheduler_freq_in_hertz); var genericTimerInst = GenericTimerType.init(); pub const Bcm2835TimerType = bcm2835Timer.Bcm2835Timer(PeriphConfig(.ttbr1).Timer.base_address, config.scheduler_freq_in_hertz); var bcm2835TimerInst = Bcm2835TimerType.init(); pub const GenericTimerKpiType = kpi.TimerKpi(*GenericTimerType, GenericTimerType.Error, GenericTimerType.setupGt, GenericTimerType.timerInt, GenericTimerType.timer_name); pub const Bcm2835TimerKpiType = kpi.TimerKpi(*Bcm2835TimerType, Bcm2835TimerType.Error, Bcm2835TimerType.initTimer, Bcm2835TimerType.handleTimerIrq, Bcm2835TimerType.timer_name); // interrupt controller const Bcm2835InterruptControllerType = bcm2835IntController.InterruptController(PeriphConfig(.ttbr1).InterruptController.base_address); pub const SecondaryInterruptControllerKpiType = kpi.SecondaryInterruptControllerKpi(*Bcm2835InterruptControllerType, Bcm2835InterruptControllerType.Error, Bcm2835InterruptControllerType.initIc, Bcm2835InterruptControllerType.addIcHandler, Bcm2835InterruptControllerType.RegMap); var secondaryInterruptControllerInst = Bcm2835InterruptControllerType.init(); pub const driver = boardConfig.Driver(GenericTimerKpiType, SecondaryInterruptControllerKpiType){ .timerDriver = GenericTimerKpiType.init(&genericTimerInst), // .timerDriver = Bcm2835TimerKpiType.init(&bcm2835TimerInst), .secondaryInterruptConrtollerDriver = SecondaryInterruptControllerKpiType.init(&secondaryInterruptControllerInst), }; // -- driver -- pub fn PeriphConfig(comptime addr_space: boardConfig.AddrSpace) type { const new_ttbr1_device_base_ = 0x30000000; const device_base_mapping_bare: usize = 0x3f000000; comptime var device_base_mapping_new: usize = undefined; if (addr_space.isKernelSpace()) { device_base_mapping_new = config.mem.va_start + new_ttbr1_device_base_; } else device_base_mapping_new = device_base_mapping_bare; return struct { pub const device_base_size: usize = 0xA000000; pub const new_ttbr1_device_base: usize = new_ttbr1_device_base_; pub const device_base: usize = device_base_mapping_new; pub const Pl011 = struct { pub const base_address: u64 = device_base + 0x201000; // config pub const base_clock: u64 = 0x124f800; // 9600 slower baud pub const baudrate: u32 = 115200; pub const data_bits: u32 = 8; pub const stop_bits: u32 = 1; }; pub const Timer = struct { pub const base_address: usize = device_base + 0x00003000; }; pub const ArmGenericTimer = struct { pub const base_address: usize = device_base + 0x1000040; }; pub const InterruptController = struct { pub const base_address: usize = device_base + 0x0000b200; }; pub const GicV2 = struct { pub const base_address: u64 = device_base + 0; }; }; }
0
repos/MinimalRoboticsPlatform/src/boards/drivers
repos/MinimalRoboticsPlatform/src/boards/drivers/interruptController/interruptController.zig
pub const bcm2835InterruptController = @import("bcm2835InterruptController.zig");
0
repos/MinimalRoboticsPlatform/src/boards/drivers
repos/MinimalRoboticsPlatform/src/boards/drivers/interruptController/bcm2835InterruptController.zig
const std = @import("std"); const board = @import("board"); const arm = @import("arm"); const cpuContext = arm.cpuContext; pub fn InterruptController(comptime base_address: usize) type { // const base_address = @import("board").PeriphConfig(addr_space).InterruptController.base_address; return struct { const Self = @This(); pub const Error = anyerror; pub const RegMap = struct { pub const pendingBasic = @as(*volatile u32, @ptrFromInt(base_address + 0)); pub const pendingIrq1 = @as(*volatile u32, @ptrFromInt(base_address + 0x4)); pub const pendingIrq2 = @as(*volatile u32, @ptrFromInt(base_address + 0x8)); pub const enableIrq1 = @as(*volatile u32, @ptrFromInt(base_address + 0x10)); pub const enableIrq2 = @as(*volatile u32, @ptrFromInt(base_address + 0x14)); pub const enableIrqBasic = @as(*volatile u32, @ptrFromInt(base_address + 0x18)); }; handler_fn: ?*const fn (cpu_context: *cpuContext.CpuContext) void, pub fn init() Self { return .{ .handler_fn = null, }; } pub fn initIc(self: *Self) Error!void { _ = self; // enabling all irq types // enalbles system timer RegMap.enableIrq1.* = 1 << 1; // RegMap.enableIrq2.* = 1 << 1; // RegMap.enableIrqBasic.* = 1 << 1; } pub fn addIcHandler(self: *Self, handler_fn: *const fn (cpu_context: *cpuContext.CpuContext) void) Error!void { self.handler_fn = handler_fn; } }; }
0
repos/MinimalRoboticsPlatform/src/boards/drivers
repos/MinimalRoboticsPlatform/src/boards/drivers/bootInit/raspi3b_boot.S
.section ".text.boot" .equ AArch64_EL1_SP1, 0x05 // EL1h // how to get from el3 to el1 is described here: https://developer.arm.com/documentation/102437/0100/Changing-Exception-levels .globl _start _start: // checking for secure state mrs x1, scr_el3 tbnz x1, 0, proc_hang mrs x0, mpidr_el1 and x0, x0,#0xFF // Check processor id cbz x0, master // Hang for all non-primary CPU b proc_hang el1_entry_aarch64: ldr x0, = _exception_vector_table msr vbar_el1, x0 isb // Enable FP/SIMD for el1 mov x0, #3 << 20 msr cpacr_el1, x0 // clear bss section adr x0, _bss_start adr x1, _bss_end sub x1, x1, x0 bl memzero isb bl bl_main master: // disabling mmu mov x1, #0x0 msr sctlr_el1, x1 isb // Configure SCR_EL3 // -----------------dd mov w1, #0 // Initial value of register is unknown orr w1, w1, #(1 << 11) // set ST bit (disable trapping of timer control registers) orr w1, w1, #(1 << 10) // set RW bit (next lower EL in aarch64) // orr w1, w1, #(1 << 3) // Set EA bit (SError routed to EL3) // orr w1, w1, #(1 << 2) // Set FIQ bit (FIQs routed to EL3) // orr w1, w1, #(1 << 1) // Set IRQ bit (IRQs routed to EL3) msr SCR_EL3, x1 // Initialize SCTLR_EL1 // -------------------- // SCTLR_EL1 has an unknown reset value and must be configured // before we can enter EL1 msr SCTLR_EL1, xzr ldr x0, =el1_entry_aarch64 ldr x1, =AArch64_EL1_SP1 msr ELR_EL3, x0 // where to branch to when exception completes msr SPSR_EL3, x1 // set the program state for this point to a known value eret proc_hang: b proc_hang .globl memzero memzero: str xzr, [x0], #8 subs x1, x1, #8 b.gt memzero br lr
0
repos/MinimalRoboticsPlatform/src/boards/drivers
repos/MinimalRoboticsPlatform/src/boards/drivers/bootInit/qemuVirt_boot.S
.section ".text.boot" .globl _start _start: mrs x0, mpidr_el1 and x0, x0, #0xFF // Check processor id cbz x0, master // Hang for all non-primary CPU // mov w1, #0 // orr w1, w1, #(1 << 3) // orr w1, w1, #(1 << 4) // orr w1, w1, #(1 << 5) // msr HCR_EL2, x1 b proc_hang // virt does directly boot to el1 on startup master: // setting up vector table (https://github.com/Xilinx/embeddedsw/blob/master/lib/bsp/standalone/src/arm/ARMv8/64bit/armclang/boot.S) ldr x0, =_exception_vector_table msr vbar_el1, x0 isb // disabling mmu mov x1, #0x0 msr sctlr_el1, x1 isb // Enable FP/SIMD for el1 mov x0, #3 << 20 msr cpacr_el1, x0 // clear bss section adr x0, _bss_start adr x1, _bss_end sub x1, x1, x0 bl memzero isb bl bl_main proc_hang: b proc_hang .globl memzero memzero: str xzr, [x0], #8 subs x1, x1, #8 b.gt memzero br lr
0
repos/MinimalRoboticsPlatform/src/boards/drivers
repos/MinimalRoboticsPlatform/src/boards/drivers/timer/timer.zig
pub const bcm2835Timer = @import("bcm2835Timer.zig"); pub const genericTimer = @import("genericTimer.zig");
0
repos/MinimalRoboticsPlatform/src/boards/drivers
repos/MinimalRoboticsPlatform/src/boards/drivers/timer/genericTimer.zig
const std = @import("std"); const utils = @import("utils"); const periph = @import("periph"); const kprint = periph.uart.UartWriter(.ttbr1).kprint; pub fn GenericTimer(comptime base_address: ?usize, comptime scheduler_freq_in_hertz: usize) type { _ = base_address; return struct { const Self = @This(); pub const Error = anyerror; pub const timer_name = "arm_gt"; timerVal: usize, pub fn init() Self { return .{ .timerVal = 0, }; } pub fn getFreq() usize { return asm ("mrs %[curr], CNTFRQ_EL0" : [curr] "=r" (-> usize), ); } // initialize gic controller pub fn setupGt(self: *Self) !void { const cnt_freq = getFreq(); const expire_count = utils.calcTicksFromHertz(cnt_freq, scheduler_freq_in_hertz); self.timerVal = expire_count; asm volatile ( \\msr CNTP_TVAL_EL0, %[cval] \\mov x0, 1 \\msr CNTP_CTL_EL0, x0 : : [cval] "r" (self.timerVal), : "x0" ); } pub fn timerInt(self: *Self) !void { asm volatile ( \\msr CNTP_TVAL_EL0, %[cval] \\mov x0, 1 \\msr CNTP_CTL_EL0, x0 : : [cval] "r" (self.timerVal), : "x0" ); } pub fn isEnabled(self: *Self) !bool { _ = self; const icprendr: u64 = asm ("mrs %[curr], CNTP_CTL_EL0" : [curr] "=r" (-> u64), ); if (icprendr & (1 << 0) != 0) { return true; } // kprint("is pending {b} \n", .{icprendr}); return false; } }; }
0
repos/MinimalRoboticsPlatform/src/boards/drivers
repos/MinimalRoboticsPlatform/src/boards/drivers/timer/bcm2835Timer.zig
const utils = @import("utils"); const std = @import("std"); pub fn Bcm2835Timer(comptime base_address: ?usize, comptime scheduler_freq_in_hertz: usize) type { return struct { const Self = @This(); pub const Error = anyerror; pub const timer_name = "bcm2835_timer"; // raspberry 3b available timers: system timer (this one), arm timer, free runnning timer // raspberry system timer frequency is 1 Mhz var cnt_freq: u32 = 1000000; var increasePerTick: u32 = 0; pub const RegMap = struct { pub const timerCs = @as(*volatile u32, @ptrFromInt(base_address.? + 0x0)); pub const timerLo = @as(*volatile u32, @ptrFromInt(base_address.? + 0x4)); pub const timerHi = @as(*volatile u32, @ptrFromInt(base_address.? + 0x8)); pub const timerC0 = @as(*volatile u32, @ptrFromInt(base_address.? + 0xc)); pub const timerC1 = @as(*volatile u32, @ptrFromInt(base_address.? + 0x10)); pub const timerClo = @as(*volatile u32, @ptrFromInt(base_address.? + 0x4)); }; // address values pub const RegValues = struct { // System Timer Controll State irq clear vals pub const timerCsM0: u32 = 1 << 0; pub const timerCsM1: u32 = 1 << 1; pub const timerCsM2: u32 = 1 << 2; pub const timerCsM3: u32 = 1 << 3; }; timerVal: u32, initialTimerHi: u32, pub fn init() Self { return .{ .timerVal = 0, .initialTimerHi = 0, }; } pub fn initTimer(self: *Self) Error!void { self.initialTimerHi = RegMap.timerHi.*; self.timerVal = RegMap.timerLo.*; increasePerTick = @as(u32, @truncate(utils.calcTicksFromHertz(cnt_freq, scheduler_freq_in_hertz))); self.timerVal += increasePerTick; RegMap.timerC1.* = self.timerVal; } // the qemu system timer is weird. It only triggers an interrupt if timerC1 is == timerLo instead of timerC1 is <= timerLo. // Qemu devs stated that this is intended and what the documentation is saying, but are also doubting that this is the physical bcm2835 implementation // more on that issue here: https://gitlab.com/qemu-project/qemu/-/issues/1651 // also I'm unsure how overflows are handled since it's not described in the docs properly pub fn handleTimerIrq(self: *Self) Error!void { self.timerVal = RegMap.timerLo.* + increasePerTick; if (self.initialTimerHi != RegMap.timerHi.*) { self.timerVal = RegMap.timerLo.*; self.timerVal += increasePerTick; self.initialTimerHi = RegMap.timerHi.*; } RegMap.timerC1.* = self.timerVal; RegMap.timerCs.* = RegMap.timerCs.* | RegValues.timerCsM1; } pub fn isEnabled(self: *Self) !bool { _ = self; if (RegMap.timerCs.* & RegValues.timerCsM1 != 0) { return true; } return false; } }; }
0
repos/MinimalRoboticsPlatform/src
repos/MinimalRoboticsPlatform/src/appLib/utils.zig
const std = @import("std");
0
repos/MinimalRoboticsPlatform/src
repos/MinimalRoboticsPlatform/src/appLib/Semaphore.zig
const std = @import("std"); const board = @import("board"); const sysCalls = @import("userSysCallInterface.zig"); const kprint = sysCalls.SysCallPrint.kprint; // max_process_waiting defines how many processes can be put into the waiting queue pub fn Semaphore(comptime max_process_waiting: ?usize) type { const max_process_waiting_queue = max_process_waiting orelse board.config.static_memory_reserves.semaphore_max_process_in_queue; return struct { const Self = @This(); const Error = error{ OutOfStaticMem, }; waiting_processes: [max_process_waiting_queue]?u16, i: isize, locked_tasks_index: u16, pub fn init(s: isize) Self { return .{ .waiting_processes = [_]?u16{0} ** max_process_waiting_queue, .locked_tasks_index = 0, .i = s, }; } pub fn wait(self: *Self, halting_pid: ?u16) !void { try sysCalls.increaseCurrTaskPreemptCounter(); var to_halt_proc: u16 = undefined; if (halting_pid == null) to_halt_proc = (try sysCalls.getPid()) else to_halt_proc = halting_pid.?; if (self.i < 1) { self.locked_tasks_index += 1; // kprint("ERR: {d} > {d}", .{ self.locked_tasks_index, self.waiting_processes.len }); if (self.waiting_processes.len > self.locked_tasks_index) return Error.OutOfStaticMem; self.waiting_processes[self.locked_tasks_index] = to_halt_proc; try sysCalls.haltProcess(to_halt_proc); } self.i -= 1; } pub fn signal(self: *Self) !void { if (self.i < 1) { if (self.waiting_processes[self.locked_tasks_index]) |locked_pid| { self.locked_tasks_index -= 1; try sysCalls.continueProcess(locked_pid); } self.i += 1; } try sysCalls.decreaseCurrTaskPreemptCounter(); } }; }
0
repos/MinimalRoboticsPlatform/src
repos/MinimalRoboticsPlatform/src/appLib/SharedMemTopicsInterface.zig
const sharedKernelServices = @import("sharedKernelServices"); const env = @import("environment"); const std = @import("std"); const utils = @import("utils"); const board = @import("board"); const Semaphore = @import("Semaphore.zig"); const sysCalls = @import("userSysCallInterface.zig"); const kprint = sysCalls.SysCallPrint.kprint; const alignForward = std.mem.alignForward; const Topic = @import("sharedServices").Topic(Semaphore); pub const SharedMemTopicsInterface = struct { const Error = error{ TopicIdNotFound, StatusInterfaceMissmatch, }; topics: [env.env_config.countTopics()]Topic, mem_pool: []u8, pub fn init() !SharedMemTopicsInterface { var topics = [_]Topic{undefined} ** env.env_config.countTopics(); var accumulatedTopicsBuffSize: usize = 0; for (&env.env_config.status_control) |*status_control_conf| { if (status_control_conf.*.status_type == .topic) { accumulatedTopicsBuffSize += status_control_conf.topic_conf.?.buffer_size + @sizeOf(usize); } } const pages_req = (try std.math.mod(usize, alignForward(usize, accumulatedTopicsBuffSize, 8), board.config.mem.va_user_space_gran.page_size)) + 1; var fixedTopicMemPoolInterface: []u8 = undefined; fixedTopicMemPoolInterface.ptr = @as([*]u8, @ptrFromInt(0x20000000)); fixedTopicMemPoolInterface.len = pages_req * board.config.mem.va_user_space_gran.page_size; var used_topics_mem: usize = 0; var i: usize = 0; for (&env.env_config.status_control) |*status_control_conf| { if (status_control_conf.*.status_type == .topic) { const topic_read_write_buff_ptr = @as(*volatile usize, @ptrFromInt(@intFromPtr(fixedTopicMemPoolInterface.ptr) + used_topics_mem)); topic_read_write_buff_ptr.* = 0; // + @sizeOf(usize) bytes for the buff_state topics[i] = Topic.init(fixedTopicMemPoolInterface[used_topics_mem + @sizeOf(usize) .. used_topics_mem + status_control_conf.topic_conf.?.buffer_size], topic_read_write_buff_ptr, status_control_conf.id, status_control_conf.topic_conf.?.buffer_type); used_topics_mem += status_control_conf.topic_conf.?.buffer_size; i += 1; } } return .{ .topics = topics, .mem_pool = fixedTopicMemPoolInterface, }; } pub fn read(self: *SharedMemTopicsInterface, comptime name: []const u8, ret_buff: []u8) !usize { const status = try env.env_config.getStatusInfo(name); if (status.type != null) return Error.StatusInterfaceMissmatch; if (self.findTopicById(status.id)) |index| { return self.topics[index].read(ret_buff); } else return Error.TopicIdNotFound; } pub fn write(self: *SharedMemTopicsInterface, comptime name: []const u8, data: []u8) !usize { const status = try env.env_config.getStatusInfo(name); if (status.type != null) return Error.StatusInterfaceMissmatch; if (self.findTopicById(status.id)) |index| { return self.topics[index].write(data); } else return Error.TopicIdNotFound; } // returns index fn findTopicById(self: *SharedMemTopicsInterface, id: usize) ?usize { for (&self.topics, 0..) |*topic, i| { if (topic.id == id) return i; } return null; } };
0
repos/MinimalRoboticsPlatform/src
repos/MinimalRoboticsPlatform/src/appLib/appLib.zig
pub const AppAllocator = @import("AppAllocator.zig").AppAllocator; pub const sysCalls = @import("userSysCallInterface.zig"); pub const Semaphore = @import("Semaphore.zig").Semaphore; pub const Mutex = @import("Mutex.zig").Mutex; pub const SharedMemTopicsInterface = @import("SharedMemTopicsInterface.zig").SharedMemTopicsInterface; pub const utils = @import("utils.zig");
0
repos/MinimalRoboticsPlatform/src
repos/MinimalRoboticsPlatform/src/appLib/Mutex.zig
const std = @import("std"); const board = @import("board"); const sysCalls = @import("userSysCallInterface.zig"); const kprint = sysCalls.SysCallPrint.kprint; pub const Mutex = struct { const Error = error{ OutOfStaticMem, }; waiting_processes: [board.config.static_memory_reserves.mutex_max_process_in_queue]u16, last_waiting_proc_index: usize, curr_lock_owner_pid: usize, locked: std.atomic.Atomic(bool), pub fn init() Mutex { return .{ .waiting_processes = [_]u16{0} ** board.config.static_memory_reserves.mutex_max_process_in_queue, .last_waiting_proc_index = 0, .curr_lock_owner_pid = 0, .locked = std.atomic.Atomic(bool).init(false), }; } pub fn lock(self: *Mutex) !void { sysCalls.increaseCurrTaskPreemptCounter(); const my_pid = sysCalls.getPid(); if (self.locked.load(.Unordered)) { if (self.last_waiting_proc_index > self.waiting_processes.len) return Error.OutOfStaticMem; sysCalls.haltProcess(my_pid); self.waiting_processes[self.last_waiting_proc_index] = my_pid; self.last_waiting_proc_index += 1; } self.curr_lock_owner_pid = my_pid; self.locked.store(true, .Unordered); } pub fn unlock(self: *Mutex) void { if (self.locked.load(.Unordered) and self.last_waiting_proc_index > 0 and self.curr_lock_owner_pid == sysCalls.getPid()) { sysCalls.continueProcess(self.waiting_processes[self.last_waiting_proc_index]); self.curr_lock_owner_pid = self.waiting_processes[self.last_waiting_proc_index]; self.last_waiting_proc_index -= 1; } self.locked.store(false, .Unordered); sysCalls.decreaseCurrTaskPreemptCounter(); } };
0
repos/MinimalRoboticsPlatform/src
repos/MinimalRoboticsPlatform/src/appLib/userSysCallInterface.zig
const std = @import("std"); const board = @import("board"); const env = @import("environment"); const alignForward = std.mem.alignForward; const AppAllocator = @import("AppAllocator.zig").AppAllocator; const Mutex = @import("Mutex.zig").Mutex; const utils = @import("utils"); const sysCalls = @import("userSysCallInterface.zig"); const kprint = sysCalls.SysCallPrint.kprint; const Error = error{ SleepDelayTooShortForScheduler, SysCallError, StatusInterfaceMissmatch, StatusTypeMissmatch }; pub const SysCallPrint = struct { const Self = @This(); pub const Writer = std.io.Writer(*Self, error{}, appendWrite); pub fn writer(self: *Self) Writer { return .{ .context = self }; } fn callKernelPrint(data: [*]const u8, len: usize) void { asm volatile ( // args \\mov x0, %[data_addr] \\mov x1, %[len] // sys call id \\mov x8, #0 \\svc #0 : : [data_addr] "r" (@intFromPtr(data)), [len] "r" (len), : "x0", "x1", "x8" ); // asm volatile ("brk 0xdead"); } /// Same as `append` except it returns the number of bytes written, which is always the same /// as `m.len`. The purpose of this function existing is to match `std.io.Writer` API. fn appendWrite(self: *Self, data: []const u8) error{}!usize { _ = self; // asm volatile ("brk 0xdead"); callKernelPrint(data.ptr, data.len); return data.len; } pub fn kprint(comptime print_string: []const u8, args: anytype) void { var tempW: SysCallPrint = undefined; std.fmt.format(tempW.writer(), print_string, args) catch |err| { @panic(err); }; } }; pub fn killTask(pid: usize) noreturn { asm volatile ( // args \\mov x0, %[pid] // sys call id \\mov x8, #1 \\svc #0 : : [pid] "r" (pid), : "x0", "x8" ); while (true) {} } // pub fn forkProcess(pid: usize) void { // asm volatile ( // // args // \\mov x0, %[pid] // // sys call id // \\mov x8, #2 // \\svc #0 // : // : [pid] "r" (pid), // : "x0", "x8" // ); // } fn checkForError(x0: usize) !usize { if (@as(isize, @intCast(x0)) < 0) { return Error.SysCallError; } return x0; } pub fn getPid() !u16 { const ret = asm ( \\mov x8, #3 \\svc #0 \\mov %[curr], x0 : [curr] "=r" (-> usize), : : "x0", "x8" ); return @as(u16, @truncate(try checkForError(ret))); } pub fn killTaskRecursively(starting_pid: usize) !void { const ret = asm volatile ( // args \\mov x0, %[pid] // sys call id \\mov x8, #4 \\svc #0 \\mov %[ret], x0 : [ret] "=r" (-> usize), : [pid] "r" (starting_pid), : "x0", "x8" ); _ = try checkForError(ret); } // creates thread for current process pub fn createThread(thread_stack_mem: []u8, thread_fn: anytype, args: anytype) !void { var thread_stack_start: []u8 = undefined; thread_stack_start.ptr = @as([*]u8, @ptrFromInt(@intFromPtr(thread_stack_mem.ptr) + thread_stack_mem.len)); thread_stack_start.len = thread_stack_mem.len; var arg_mem: []const u8 = undefined; arg_mem.ptr = @as([*]const u8, @ptrCast(@alignCast(&args))); arg_mem.len = @sizeOf(@TypeOf(args)); std.mem.copy(u8, thread_stack_start, arg_mem); const ret = asm volatile ( // args \\mov x0, %[entry_fn_ptr] \\mov x1, %[thread_stack] \\mov x2, %[args_addr] \\mov x3, %[thread_fn_ptr] // sys call id \\mov x8, #6 \\svc #0 \\mov %[ret], x0 : [ret] "=r" (-> usize), : [entry_fn_ptr] "r" (@intFromPtr(&(ThreadInstance(thread_fn, @TypeOf(args)).threadEntry))), [thread_stack] "r" (@intFromPtr(thread_stack_start.ptr) - alignForward(usize, @sizeOf(@TypeOf(args)), 16)), [args_addr] "r" (@intFromPtr(thread_stack_start.ptr)), [thread_fn_ptr] "r" (@intFromPtr(&thread_fn)), : "x0", "x1", "x2", "x3", "x8" ); _ = try checkForError(ret); } // provides a generic entry function (generic in regard to the thread and argument function since @call builtin needs them to properly invoke the thread start) fn ThreadInstance(comptime thread_fn: anytype, comptime Args: type) type { const ThreadFn = @TypeOf(thread_fn); return struct { // todo => I removed callconv(.C), still safe? fn threadEntry(entry_fn: *ThreadFn, entry_args: *Args) void { @call(.auto, entry_fn, entry_args.*); } }; } pub fn sleep(delay_in_nano_secs: usize) !void { const delay_in_hertz = try std.math.divTrunc(usize, delay_in_nano_secs, std.time.ns_per_s); const delay_sched_intervals = board.config.scheduler_freq_in_hertz / delay_in_hertz; if (board.config.scheduler_freq_in_hertz < delay_in_hertz) return Error.SleepDelayTooShortForScheduler; const ret = asm volatile ( // args \\mov x0, %[delay] // sys call id \\mov x8, #7 \\svc #0 \\mov %[ret], x0 : [ret] "=r" (-> usize), : [delay] "r" (delay_sched_intervals), : "x0", "x8" ); _ = try checkForError(ret); } pub fn haltProcess(pid: usize) !void { const ret = asm volatile ( // args \\mov x0, %[pid] // sys call id \\mov x8, #8 \\svc #0 \\mov %[ret], x0 : [ret] "=r" (-> usize), : [pid] "r" (pid), : "x0", "x8" ); _ = try checkForError(ret); } pub fn continueProcess(pid: usize) !void { const ret = asm volatile ( // args \\mov x0, %[pid] // sys call id \\mov x8, #9 \\svc #0 \\mov %[ret], x0 : [ret] "=r" (-> usize), : [pid] "r" (pid), : "x0", "x8" ); _ = try checkForError(ret); } pub fn pushToTopic(comptime name: []const u8, data: []u8) !usize { const status = try env.env_config.getStatusInfo(name); if (status.type != null) return Error.StatusInterfaceMissmatch; const data_ptr: usize = @intFromPtr(data.ptr); const data_len = data.len; const ret = asm volatile ( // args \\mov x0, %[id] \\mov x1, %[data_ptr] \\mov x2, %[data_len] // sys call id \\mov x8, #12 \\svc #0 \\mov %[ret], x0 : [ret] "=r" (-> usize), : [id] "r" (status.id), [data_ptr] "r" (data_ptr), [data_len] "r" (data_len), : "x0", "x1", "x2", "x8" ); return checkForError(ret); } pub fn popFromTopic(comptime name: []const u8, ret_buff: []u8) !usize { const status = try env.env_config.getStatusInfo(name); if (status.type != null) return Error.StatusInterfaceMissmatch; const ret = asm volatile ( // args \\mov x0, %[id] \\mov x1, %[data_len] \\mov x2, %[ret_buff] // sys call id \\mov x8, #13 \\svc #0 \\mov %[ret], x0 : [ret] "=r" (-> usize), : [id] "r" (status.id), [data_len] "r" (ret_buff.len), [ret_buff] "r" (@intFromPtr(ret_buff.ptr)), : "x0", "x1", "x2", "x8" ); return checkForError(ret); } pub fn waitForTopicUpdate(comptime name: []const u8) !void { const status = try env.env_config.getStatusInfo(name); const pid = getPid(); const ret = asm volatile ( // args \\mov x0, %[topic_id] \\mov x1, %[pid] // sys call id \\mov x8, #14 \\svc #0 \\mov %[ret], x0 : [ret] "=r" (-> usize), : [topic_id] "r" (status.id), [pid] "r" (pid), : "x0", "x1", "x8" ); _ = try checkForError(ret); } pub fn increaseCurrTaskPreemptCounter() !void { const ret = asm volatile ( // args // sys call id \\mov x8, #15 \\svc #0 \\mov %[ret], x0 : [ret] "=r" (-> usize), : : "x8" ); _ = try checkForError(ret); } pub fn decreaseCurrTaskPreemptCounter() !void { const ret = asm volatile ( // args // sys call id \\mov x8, #16 \\svc #0 \\mov %[ret], x0 : [ret] "=r" (-> usize), : : "x8" ); _ = try checkForError(ret); } pub fn updateStatus(comptime name: []const u8, value: anytype) !void { const status = try env.env_config.getStatusInfo(name); if (status.type == null) return Error.StatusInterfaceMissmatch; if (@TypeOf(value) != status.type.?) return Error.StatusTypeMissmatch; const ret = asm volatile ( // args // sys call id \\mov x0, %[id] \\mov x1, %[val_addr] \\mov x8, #17 \\svc #0 \\mov %[ret], x0 : [ret] "=r" (-> usize), : [id] "r" (status.id), [val_addr] "r" (&value), : "x8" ); _ = try checkForError(ret); } pub fn readStatus(comptime T: type, comptime name: []const u8) !T { const status = try env.env_config.getStatusInfo(name); if (status.type == null) return Error.StatusInterfaceMissmatch; if (T != status.type.?) return Error.StatusTypeMissmatch; var ret_buff: status.type.? = undefined; const ret = asm volatile ( // args \\mov x0, %[id] \\mov x1, %[ret_buff] // sys call id \\mov x8, #18 \\svc #0 \\mov %[ret], x0 : [ret] "=r" (-> usize), : [id] "r" (status.id), [ret_buff] "r" (@intFromPtr(&ret_buff)), : "x0", "x1", "x8" ); _ = try checkForError(ret); return ret_buff; }
0
repos/MinimalRoboticsPlatform/src
repos/MinimalRoboticsPlatform/src/appLib/AppAllocator.zig
const std = @import("std"); const board = @import("board"); const alignForward = std.mem.alignForward; const utils = @import("utils"); const appAllocatorChunkSize = 0x10000; pub const AppAllocator = struct { const Error = error{ OutOfChunks, OutOfMem, AddrNotInMem, AddrNotValid, MemBaseNotAligned, NoHeapStartLabel }; const maxChunks = @divExact(board.config.mem.app_vm_mem_size, appAllocatorChunkSize); mem_base: usize, kernel_mem: [maxChunks]bool, used_chunks: usize, pub fn init(mem_base: ?usize) !AppAllocator { var heap_start: usize = undefined; if (mem_base == null) { const _heap_start: usize = @intFromPtr(@extern(?*u8, .{ .name = "_heap_start" }) orelse return Error.NoHeapStartLabel); heap_start = _heap_start; } else heap_start = mem_base.?; if (heap_start % 8 != 0) return Error.MemBaseNotAligned; const ka = AppAllocator{ .kernel_mem = [_]bool{false} ** maxChunks, // can currently only increase and indicates at which point findFree() is required .used_chunks = 0, .mem_base = heap_start, }; return ka; } pub fn alloc(self: *AppAllocator, comptime T: type, n: usize, alignment: ?usize) ![]T { var alignm: usize = @alignOf(T); if (alignment) |a| alignm = a; const size = @sizeOf(T) * n; const req_chunks = try std.math.divCeil(usize, size, appAllocatorChunkSize); if (try self.findFree(self.used_chunks, size)) |free_mem_first_chunk| { for (self.kernel_mem[free_mem_first_chunk .. free_mem_first_chunk + req_chunks]) |*chunk| { chunk.* = true; } const alloc_addr = self.mem_base + (free_mem_first_chunk * appAllocatorChunkSize); var aligned_alloc_slice = @as([*]T, @ptrFromInt(alignForward(usize, alloc_addr, alignm))); return aligned_alloc_slice[0 .. n - 1]; } else if (self.used_chunks + req_chunks > maxChunks) { return Error.OutOfMem; } const first_chunk = self.used_chunks; const last_chunk = self.used_chunks + req_chunks; self.used_chunks += req_chunks; for (self.kernel_mem[first_chunk..last_chunk]) |*chunk| { chunk.* = true; } const alloc_addr = self.mem_base + (first_chunk * appAllocatorChunkSize); const aligned_alloc_slice = @as([*]T, @ptrFromInt(alignForward(usize, alloc_addr, alignm))); return aligned_alloc_slice[0 .. n - 1]; } /// finds continous free memory in fragmented kernel memory; marks returned memory as not free! pub fn findFree(self: *AppAllocator, to_chunk: usize, req_size: usize) !?usize { var continous_chunks: usize = 0; const req_chunks = (try std.math.divCeil(usize, req_size, appAllocatorChunkSize)); for (self.kernel_mem, 0..) |chunk, i| { if (i >= to_chunk) { return null; } if (!chunk) { continous_chunks += 1; } else { continous_chunks = 0; } if (continous_chunks >= req_chunks) { var first_chunk = i; if (i > 0) first_chunk -= req_chunks; return first_chunk; } } return null; } pub fn free(self: *AppAllocator, to_free: anytype) !void { const Slice = @typeInfo(@TypeOf(to_free)).Pointer; const byte_slice = std.mem.sliceAsBytes(to_free); const size = byte_slice.len + if (Slice.sentinel != null) @sizeOf(Slice.child) else 0; if (size == 0) return; // compensating for alignment var addr_unaligned = @intFromPtr(byte_slice.ptr); if (addr_unaligned == self.mem_base) addr_unaligned -= (try std.math.mod(usize, @intFromPtr(byte_slice.ptr), appAllocatorChunkSize)); if (addr_unaligned > (self.mem_base + (maxChunks * appAllocatorChunkSize))) return Error.AddrNotInMem; const i_chunk_to_free: usize = (try std.math.divCeil(usize, std.math.sub(usize, addr_unaligned, self.mem_base) catch { return Error.AddrNotInMem; }, appAllocatorChunkSize)) - 1; const n_chunks_to_free: usize = try std.math.divCeil(usize, size, appAllocatorChunkSize); for (&self.kernel_mem[i_chunk_to_free .. i_chunk_to_free + n_chunks_to_free]) |*chunk| { chunk.* = false; } } };
0
repos/MinimalRoboticsPlatform/src
repos/MinimalRoboticsPlatform/src/utils/utils.zig
const std = @import("std"); const board = @import("board"); pub const Error = error{ SchedulerFreqTooLow, }; pub fn calcTicksFromHertz(timer_freq_in_hertz: usize, wanted_freq_in_hertz: usize) usize { // todo => restore line below // if (wanted_freq_in_hertz > timer_freq_in_hertz) return Error.SchedulerFreqTooLow; // todo => use std divtrunct not / return timer_freq_in_hertz / wanted_freq_in_hertz; } pub inline fn toTtbr1(comptime T: type, inp: T) T { switch (@typeInfo(T)) { .Pointer => { return @as(T, @ptrFromInt(@intFromPtr(inp) | board.config.mem.va_start)); }, .Int => { return inp | board.config.mem.va_start; }, else => @compileError("mmu address translation: not supported type"), } } pub inline fn toTtbr0(comptime T: type, inp: T) T { switch (@typeInfo(T)) { .Pointer => { return @as(T, @ptrFromInt(@intFromPtr(inp) & ~(board.config.mem.va_start))); }, .Int => { return inp & ~(board.config.mem.va_start); }, else => @compileError("mmu address translation: not supported type"), } }
0
repos/MinimalRoboticsPlatform/src
repos/MinimalRoboticsPlatform/src/arm/gicv2.zig
const std = @import("std"); const arm = @import("arm"); const mmu = @import("mmu.zig"); const AddrSpace = @import("board").boardConfig.AddrSpace; // identifiers for the vector table addr_handler call pub const ExceptionType = enum(u64) { el1Sync = 0x1, el1Irq = 0x2, el1Fiq = 0x3, el1Err = 0x4, el1Sp0Sync = 0x5, el1Sp0Irq = 0x6, el1Sp0Fiq = 0x7, el1Sp0Err = 0x8, el0Sync = 0x9, el0Irq = 0xA, el0Fiq = 0xB, el0Err = 0xC, el032Sync = 0xD, el032Irq = 0xE, el032Fiq = 0xF, el032Err = 0x10, }; export const el1Sync = ExceptionType.el1Sync; export const el1Err = ExceptionType.el1Err; export const el1Fiq = ExceptionType.el1Fiq; export const el1Irq = ExceptionType.el1Irq; export const el1Sp0Sync = ExceptionType.el1Sp0Sync; export const el1Sp0Irq = ExceptionType.el1Sp0Irq; export const el1Sp0Fiq = ExceptionType.el1Sp0Fiq; export const el1Sp0Err = ExceptionType.el1Sp0Err; export const el0Sync = ExceptionType.el0Sync; export const el0Irq = ExceptionType.el0Irq; export const el0Fiq = ExceptionType.el0Fiq; export const el0Err = ExceptionType.el0Err; export const el032Sync = ExceptionType.el032Sync; export const el032Irq = ExceptionType.el032Irq; export const el032Fiq = ExceptionType.el032Fiq; export const el032Err = ExceptionType.el032Err; pub fn Gic(comptime addr_space: AddrSpace) type { const gicCfg = @import("board").PeriphConfig(addr_space).GicV2; return struct { // initialize gic controller pub fn init() !void { Gicc.init(); try Gicd.init(); } pub const itargetsrPerReg = 4; pub const isenablerPerReg = 32; pub const isdisablerPerReg = 32; pub const icpendrPerReg = 32; pub const icfgrPerReg = 16; pub const intPerReg = 32; // 32 interrupts per reg pub const ipriorityPerReg = 4; // 4 priority per reg pub const icenablerPerReg = 32; pub const intNoPpi0 = 32; pub const intNoSpi0 = 16; // 8.8 The GIC Distributor register map pub const GicdRegMap = struct { pub const gicdBase = gicCfg.base_address; // gicd mmio base address // Enables interrupts and affinity routing pub const ctlr = @as(*volatile u32, @ptrFromInt(gicdBase + 0x0)); // Deactivates the corresponding interrupt. These registers are used when saving and restoring GIC state. pub const intType = @as(*volatile u32, @ptrFromInt(gicdBase + 0x004)); // distributor implementer identification register pub const iidr = @as(*volatile u32, @ptrFromInt(gicdBase + 0x008)); // Controls whether the corresponding interrupt is in Group 0 or Group 1. pub const igroupr = @as(*volatile u32, @ptrFromInt(gicdBase + 0x080)); // interrupt set-enable registers pub const isenabler = @as(*volatile u32, @ptrFromInt(gicdBase + 0x100)); // Disables forwarding of the corresponding interrupt to the CPU interfaces. pub const icenabler = @as(*volatile u32, @ptrFromInt(gicdBase + 0x180)); // interrupt set-pending registers pub const ispendr = @as(*volatile u32, @ptrFromInt(gicdBase + 0x200)); // Removes the pending state from the corresponding interrupt. pub const icpendr = @as(*volatile u32, @ptrFromInt(gicdBase + 0x280)); pub const isactiver = @as(*volatile u32, @ptrFromInt(gicdBase + 0x300)); // Deactivates the corresponding interrupt. These registers are used when saving and restoring GIC state. pub const icactiver = @as(*volatile u32, @ptrFromInt(gicdBase + 0x380)); // interrupt priority registers pub const ipriorityr = @as(*volatile u32, @ptrFromInt(gicdBase + 0x400)); // interrupt processor targets registers pub const itargetsr = @as(*volatile u32, @ptrFromInt(gicdBase + 0x800)); // Determines whether the corresponding interrupt is edge-triggered or level-sensitive pub const icfgr = @as(*volatile u32, @ptrFromInt(gicdBase + 0xc00)); // software generated interrupt register pub const nscar = @as(*volatile u32, @ptrFromInt(gicdBase + 0xe00)); // sgi clear-pending registers pub const cpendsgir = @as(*volatile u32, @ptrFromInt(gicdBase + 0xf10)); // sgi set-pending registers pub const spendsgir = @as(*volatile u32, @ptrFromInt(gicdBase + 0xf20)); pub const sgir = @as(*volatile u32, @ptrFromInt(0xf00)); }; // 8.12 the gic cpu interface register map pub const GiccRegMap = struct { pub const giccBase = gicCfg.base_address + 0x10000; // gicc mmio base address // cpu interface control register pub const ctlr = @as(*volatile u32, @ptrFromInt(giccBase + 0x000)); // interrupt priority mask register pub const pmr = @as(*volatile u32, @ptrFromInt(giccBase + 0x004)); // binary point register pub const bpr = @as(*volatile u32, @ptrFromInt(giccBase + 0x008)); // interrupt acknowledge register pub const iar = @as(*volatile u32, @ptrFromInt(giccBase + 0x00c)); // end of interrupt register pub const eoir = @as(*volatile u32, @ptrFromInt(giccBase + 0x010)); // running priority register pub const rpr = @as(*volatile u32, @ptrFromInt(giccBase + 0x014)); // highest pending interrupt register pub const hpir = @as(*volatile u32, @ptrFromInt(giccBase + 0x018)); // aliased binary point register pub const abpr = @as(*volatile u32, @ptrFromInt(giccBase + 0x01c)); // cpu interface identification register pub const iidr = @as(*volatile u32, @ptrFromInt(giccBase + 0x0fc)); }; pub const GicdRegValues = struct { pub const itargetsrCore0TargetBmap = 0x01010101; // cpu interface 0 // 8.9.4 gicd_ctlr, distributor control register pub const gicdCtlrEnable = 0x1; // enable gicd pub const gicdCtlrDisable = 0; // disable gicd // 8.9.7 gicd_icfgr<n>, interrupt configuration registers pub const gicdIcfgrLevel = 0; // level-sensitive pub const gicdIcfgrEdge = 0x2; // edge-triggered }; pub const GiccRegValues = struct { // gicc.. // 8.13.14 gicc_pmr, cpu interface priority mask register pub const giccPmrPrioMin = 0xff; // the lowest level mask pub const giccPmrPrioHigh = 0x0; // the highest level mask // 8.13.7 gicc_ctlr, cpu interface control register pub const giccCtlrEnable = 0x1; // enable gicc pub const giccCtlrDisable = 0x0; // disable gicc // 8.13.6 gicc_bpr, cpu interface binary point register // in systems that support only one security state, when gicc_ctlr.cbpr == 0, this register determines only group 0 interrupt preemption. pub const giccBprNoGroup = 0x0; // handle all interrupts // 8.13.11 gicc_iar, cpu interface interrupt acknowledge register pub const giccIarIntrIdmask = 0x3ff; // 0-9 bits means interrupt id pub const giccIarSpuriousIntr = 0x3ff; // 1023 means spurious interrupt }; pub const InterruptIds = enum(u32) { non_secure_physical_timer = 30, }; pub const Gicc = struct { // initialize gic controller fn init() void { // disable cpu interface GiccRegMap.ctlr.* = GiccRegValues.giccCtlrDisable; // set the priority level as the lowest priority // note: higher priority corresponds to a lower priority field value in the gic_pmr. // in addition to this, writing 255 to the gicc_pmr always sets it to the largest supported priority field value. GiccRegMap.pmr.* = GiccRegValues.giccPmrPrioMin; // handle all of interrupts in a single group GiccRegMap.bpr.* = GiccRegValues.giccBprNoGroup; // clear all of the active interrupts var pending_irq: u32 = 0; while (pending_irq != GiccRegValues.giccIarSpuriousIntr) : (pending_irq = GiccRegMap.iar.* & GiccRegValues.giccIarSpuriousIntr) { GiccRegMap.eoir.* = GiccRegMap.iar.*; } // enable cpu interface GiccRegMap.ctlr.* = GiccRegValues.giccCtlrEnable; } // send end of interrupt to irq line for gic // ctrlr irq controller Configrmation // irq irq number pub fn gicv2Eoi(irq: u32) void { Gicd.gicdClearPending(irq); } // find pending irq // irqp an irq number to be processed pub fn gicv2FindPendingIrq() ![@bitSizeOf(usize)]u32 { var ret_array = [_]u32{0} ** @bitSizeOf(usize); var i: u32 = 0; var i_found: u32 = 0; while (@bitSizeOf(usize) > i) : (i += 1) { if (try Gicd.gicdProbePending(i)) { ret_array[i_found] = i; i_found += 1; } } return ret_array; } }; pub const Gicd = struct { // init the gic distributor fn init() !void { var i: u32 = 0; var irq_num: u32 = 0; // diable distributor GicdRegMap.ctlr.* = GiccRegValues.giccCtlrDisable; // disable all irqs & clear pending irq_num = try std.math.divExact(u32, @bitSizeOf(usize) + intPerReg, intPerReg); while (irq_num > i) : (i += 1) { (try calcReg(GicdRegMap.icenabler, i, icenablerPerReg)).* = ~@as(u32, 0); (try calcReg(GicdRegMap.icpendr, i, icpendrPerReg)).* = ~@as(u32, 0); } i = 0; // set all of interrupt priorities as the lowest priority irq_num = try std.math.divExact(u32, @bitSizeOf(usize) + ipriorityPerReg, ipriorityPerReg); while (irq_num > i) : (i += 1) { (try calcReg(GicdRegMap.ipriorityr, i, ipriorityPerReg)).* = ~@as(u32, 0); } i = 0; // set target of all of shared arm to processor 0 i = try std.math.divExact(u32, intNoSpi0, itargetsrPerReg); while ((try std.math.divExact(u32, @bitSizeOf(usize) + itargetsrPerReg, itargetsrPerReg)) > i) : (i += 1) { (try calcReg(GicdRegMap.itargetsr, i, itargetsrPerReg)).* = @as(u32, GicdRegValues.itargetsrCore0TargetBmap); } // set trigger type for all armeral interrupts level triggered i = try std.math.divExact(u32, intNoPpi0, icfgrPerReg); while ((try std.math.divExact(u32, @bitSizeOf(usize) + icfgrPerReg, icfgrPerReg)) > i) : (i += 1) { (try calcReg(GicdRegMap.icfgr, i, icfgrPerReg)).* = GicdRegValues.gicdIcfgrLevel; } // enable distributor GicdRegMap.ctlr.* = GicdRegValues.gicdCtlrEnable; } pub fn gicdEnableInt(irq_id: InterruptIds) !void { const clear_ena_bit = try calcShift(@intFromEnum(irq_id), isenablerPerReg); const reg = try calcReg(GicdRegMap.isenabler, @intFromEnum(irq_id), isenablerPerReg); reg.* = reg.* | (@as(u32, 1) << clear_ena_bit); } pub fn gicdDisableInt(irq_id: InterruptIds) !void { // irq_id mod 32 const clear_ena_bit = try calcShift(@intFromEnum(irq_id), isdisablerPerReg); const reg = try calcReg(GicdRegMap.icenabler, @intFromEnum(irq_id), isdisablerPerReg); reg.* = reg.* << clear_ena_bit; } pub fn gicdClearPending(irq_id: InterruptIds) !void { // irq_id mod 32 const clear_ena_bit = try calcShift(@intFromEnum(irq_id), icpendrPerReg); const reg = try calcReg(GicdRegMap.icpendr, @intFromEnum(irq_id), icpendrPerReg); reg.* = reg.* << clear_ena_bit; } pub fn gicdProbePending(irq_id: u32) !bool { // irq_id mod 32 const clear_ena_ind = try calcShift(irq_id, icpendrPerReg); const cleared_ena_bit = @as(u32, 1) << clear_ena_ind; const is_pending = (try calcReg(GicdRegMap.icpendr, irq_id, icpendrPerReg)).* & cleared_ena_bit; return is_pending != 0; } // from the gicv2 docs: // For interrupt ID m, when DIV and MOD are the integer division and modulo operations: // • the corresponding GICD_ICENABLERn number, n, is given by m = n DIV 32 (32 ints per reg) // • the offset of the required GICD_ICENABLERn is (0x180 + (4*n)) // • the bit number of the required Clear-enable bit in this register is m MOD 32 (calcShift...) fn calcReg(addr_start: *volatile u32, irq_id: u32, n_per_reg: u32) !*volatile u32 { return @as(*volatile u32, @ptrFromInt(@intFromPtr(addr_start) + try std.math.divFloor(u32, irq_id, n_per_reg))); } fn calcShift(irq_id: u32, n_per_reg: u32) !u5 { return @as(u5, @truncate(try std.math.mod(u32, irq_id, n_per_reg))); } // set an interrupt target processor // irq irq number // p target processor mask // 0x1 processor 0 // 0x2 processor 1 // 0x4 processor 2 // 0x8 processor 3 pub fn gicdSetTarget(irq_id: InterruptIds, p: u32) !void { const reg = try calcReg(GicdRegMap.itargetsr, @intFromEnum(irq_id), itargetsrPerReg); const shift = try calcShift(@intFromEnum(irq_id), itargetsrPerReg) * 8; var update_val: u32 = reg.*; update_val &= ~(@as(u32, 0xff) << shift); update_val |= p << shift; reg.* = update_val; } // set an interrupt priority // irq irq number // prio interrupt priority in arm specific expression pub fn gicdSetPriority(irq_id: InterruptIds, prio: u8) !void { const reg = try calcReg(GicdRegMap.ipriorityr, @intFromEnum(irq_id), ipriorityPerReg); const prio_shift = @as(u3, @truncate((try std.math.mod(u32, @intFromEnum(irq_id), ipriorityPerReg)) * 8)); var update_val = reg.*; update_val &= ~(@as(u32, @intCast(0xff)) << prio_shift); update_val |= prio << prio_shift; reg.* = update_val; } // configure irq // irq irq number // config configuration value for gicd_icfgr pub fn gicdConfig(irq_id: InterruptIds, config: u32) !void { const reg = try calcReg(GicdRegMap.icfgr, @intFromEnum(irq_id), icfgrPerReg); const shift = try calcShift(@intFromEnum(irq_id), icfgrPerReg) * 2; // gicd_icfgr has 16 fields, each field has 2bits. var update_val = reg.*; update_val &= ~((@as(u32, 0x03)) << shift); // clear the field update_val |= ((@as(u32, config)) << shift); // set the value to the field correponding to irq reg.* = update_val; } }; }; }
0
repos/MinimalRoboticsPlatform/src
repos/MinimalRoboticsPlatform/src/arm/cpuContext.zig
const std = @import("std"); const periph = @import("periph"); const kprint = periph.uart.UartWriter(.ttbr1).kprint; pub const CpuContext = packed struct { // debug info int_type: usize, el: usize, far_el1: usize, esr_el1: usize, sp_sel: usize, // sys regs sp_el0: usize, elr_el1: usize, fp: usize, sp_el1: usize, // gp regs x30: usize, x29: usize, x28: usize, x27: usize, x26: usize, x25: usize, x24: usize, x23: usize, x22: usize, x21: usize, x20: usize, x19: usize, x18: usize, x17: usize, x16: usize, x15: usize, x14: usize, x13: usize, x12: usize, x11: usize, x10: usize, x9: usize, x8: usize, x7: usize, x6: usize, x5: usize, x4: usize, x3: usize, x2: usize, x1: usize, x0: usize, // smid regs q31: f128, q30: f128, q29: f128, q28: f128, q27: f128, q26: f128, q25: f128, q24: f128, q23: f128, q22: f128, q21: f128, q20: f128, q19: f128, q18: f128, q17: f128, q16: f128, q15: f128, q14: f128, q13: f128, q12: f128, q11: f128, q10: f128, q9: f128, q8: f128, q7: f128, q6: f128, q5: f128, q4: f128, q3: f128, q2: f128, q1: f128, q0: f128, pub fn init() CpuContext { return std.mem.zeroInit(CpuContext, .{}); } // the labels are not functions since fns would manipulate the sp which needs to stay the same // since the CpuState is pushed there // _restoreContextFromSp restores sp to sp_el0 if SpSel is sp_el1 and the otherway around // that way all registers can be restored without clobbers. Requires that SpSel is set to a different one then // currently selected. comptime { asm ( \\.globl _restoreContextFromSp \\_restoreContextFromSp: // pop and discard debug info \\ldp x0, x1, [sp], #16 \\ldp x0, x1, [sp], #16 \\ldp x0, x2, [sp], #16 // sys regs \\ldp x0, x1, [sp], #16 \\msr elr_el1, x0 \\mov fp, x1 \\ldp x1, x30, [sp], #16 // * loading context struct sp to correct el sp * \\mrs x0, spsel // spsel == 0 \\cmp x0, #0 \\beq load_sp_to_el1 // spsel == 1 \\msr sp_el0, x2 \\b skip_sp_to_el1_load // spsel == 0 \\load_sp_to_el1: \\msr spsel, #1 \\mov sp, x1 \\msr spsel, #0 \\skip_sp_to_el1_load: // * * // gp regs \\ldp x29, x28, [sp], #16 \\ldp x27, x26, [sp], #16 \\ldp x25, x24, [sp], #16 \\ldp x23, x22, [sp], #16 \\ldp x21, x20, [sp], #16 \\ldp x19, x18, [sp], #16 \\ldp x17, x16, [sp], #16 \\ldp x15, x14, [sp], #16 \\ldp x13, x12, [sp], #16 \\ldp x11, x10, [sp], #16 \\ldp x9, x8, [sp], #16 \\ldp x7, x6, [sp], #16 \\ldp x5, x4, [sp], #16 \\ldp x3, x2, [sp], #16 \\ldp x1, x0, [sp], #16 // smid regs \\ldp q31, q30, [sp], #32 \\ldp q29, q28, [sp], #32 \\ldp q27, q26, [sp], #32 \\ldp q25, q24, [sp], #32 \\ldp q23, q22, [sp], #32 \\ldp q21, q20, [sp], #32 \\ldp q19, q18, [sp], #32 \\ldp q17, q16, [sp], #32 \\ldp q15, q14, [sp], #32 \\ldp q13, q12, [sp], #32 \\ldp q11, q10, [sp], #32 \\ldp q9, q8, [sp], #32 \\ldp q7, q6, [sp], #32 \\ldp q5, q4, [sp], #32 \\ldp q3, q2, [sp], #32 \\ldp q1, q0, [sp], #32 \\eret ); asm ( \\.globl _restoreContextWithoutSwitchFromSp \\_restoreContextWithoutSwitchFromSp: // pop and discard debug info \\ldp x0, x1, [sp], #16 \\ldp x0, x1, [sp], #16 \\ldp x0, x1, [sp], #16 // sys regs // \\msr sp_el0, x1 \\ldp x0, x1, [sp], #16 \\msr elr_el1, x0 \\mov fp, x1 \\ldp x1, x30, [sp], #16 // \\mov sp, x1 // gp regs \\ldp x29, x28, [sp], #16 \\ldp x27, x26, [sp], #16 \\ldp x25, x24, [sp], #16 \\ldp x23, x22, [sp], #16 \\ldp x21, x20, [sp], #16 \\ldp x19, x18, [sp], #16 \\ldp x17, x16, [sp], #16 \\ldp x15, x14, [sp], #16 \\ldp x13, x12, [sp], #16 \\ldp x11, x10, [sp], #16 \\ldp x9, x8, [sp], #16 \\ldp x7, x6, [sp], #16 \\ldp x5, x4, [sp], #16 \\ldp x3, x2, [sp], #16 \\ldp x1, x0, [sp], #16 // smid regs \\ldp q31, q30, [sp], #32 \\ldp q29, q28, [sp], #32 \\ldp q27, q26, [sp], #32 \\ldp q25, q24, [sp], #32 \\ldp q23, q22, [sp], #32 \\ldp q21, q20, [sp], #32 \\ldp q19, q18, [sp], #32 \\ldp q17, q16, [sp], #32 \\ldp q15, q14, [sp], #32 \\ldp q13, q12, [sp], #32 \\ldp q11, q10, [sp], #32 \\ldp q9, q8, [sp], #32 \\ldp q7, q6, [sp], #32 \\ldp q5, q4, [sp], #32 \\ldp q3, q2, [sp], #32 \\ldp q1, q0, [sp], #32 \\eret ); // _saveCurrContextOnStack is now embedded in bl&kernel exc_vector.S since zig cannot init global assembler // macros which are required since a label jump would trash the link register // asm ( // \\.globl _saveCurrContextOnStack .... } };
0
repos/MinimalRoboticsPlatform/src
repos/MinimalRoboticsPlatform/src/arm/processor.zig
const board = @import("board"); const std = @import("std"); const AddrSpace = board.boardConfig.AddrSpace; pub const ExceptionLevels = enum { el0, el1, el2, el3 }; pub const ProccessorRegMap = struct { pub const TcrReg = packed struct { t0sz: u6 = 0, reserved0: bool = false, epd0: bool = false, irgno0: u2 = 0, orgn0: u2 = 0, sh0: u2 = 0, tg0: u2 = 0, t1sz: u6 = 0, a1: bool = false, epd1: bool = false, irgn1: u2 = 0, orgn1: u2 = 0, sh1: u2 = 0, tg1: u2 = 0, ips: u3 = 0, reserved1: bool = false, as: bool = false, tbi0: bool = false, tbi1: bool = false, ha: bool = false, hd: bool = false, hpd0: bool = false, hpd1: bool = false, hwu059: bool = false, hwu060: bool = false, hwu061: bool = false, hwu062: bool = false, hwu159: bool = false, hwu160: bool = false, hwu161: bool = false, hwu162: bool = false, tbid0: bool = false, tbid1: bool = false, nfd0: bool = false, nfd1: bool = false, e0pd0: bool = false, e0pd1: bool = false, tcma0: bool = false, tcma1: bool = false, ds: bool = false, reserved2: u4 = 0, pub fn asInt(self: TcrReg) usize { return @as(u64, @bitCast(self)); } pub inline fn setTcrEl(comptime el: ExceptionLevels, val: usize) void { asm volatile ("msr tcr_" ++ @tagName(el) ++ ", %[val]" : : [val] "r" (val), ); } pub fn readTcrEl(comptime el: ExceptionLevels) usize { const x: usize = asm ("mrs %[curr], tcr_" ++ @tagName(el) : [curr] "=r" (-> usize), ); return x; } pub fn calcTxSz(gran: board.boardConfig.Granule.GranuleParams) u6 { // in bits const addr_space_indicator = 12; const addr_bsize = @bitSizeOf(usize); const bits_per_level = std.math.log2(gran.table_size); const n_lvl = @intFromEnum(gran.lvls_required) + 1; return @as(u6, @truncate(addr_bsize - (addr_space_indicator + (n_lvl * bits_per_level)))); } }; pub const Esr_el1 = struct { pub const Ifsc = enum(u6) { addrSizeFaultLvl0 = 0b000000, // Address size fault, level 0 of translation or translation table base register. addrSizeFaultLvl1 = 0b000001, // Address size fault, level 1. addrSizeFaultLvl2 = 0b000010, // Address size fault, level 2. addrSizeFaultLvl3 = 0b000011, // Address size fault, level 3. transFaultLvl0 = 0b000100, // Translation fault, level 0. transFaultLvl1 = 0b000101, // Translation fault, level 1. transFaultLvl2 = 0b000110, // Translation fault, level 2. transFaultLvl3 = 0b000111, // Translation fault, level 3. accessFlagFaultLvl1 = 0b001001, // Access flag fault, level 1. accessFlagFaultLvl2 = 0b001010, accessFlagFaultLvl3 = 0b001011, accessFlagFaultLvl0 = 0b001000, permFaultLvl0 = 0b001100, permFaultLvl1 = 0b001101, permFaultLvl2 = 0b001110, permFaultLvl3 = 0b001111, syncExternalAbortNotOnTableWalk = 0b010000, syncExternalAbortNotOnTableWalkLvlN1 = 0b010011, // Synchronous External abort on translation table walk or hardware update of translation table, level -1. syncExternalAbortOnTableWalkLvl0 = 0b010100, // Synchronous External abort on translation table walk or hardware update of translation table, level 0. syncExternalAbortOnTableWalkLvl1 = 0b010101, // Synchronous External abort on translation table walk or hardware update of translation table, level 1. syncExternalAbortOnTableWalkLvl2 = 0b010110, // Synchronous External abort on translation table walk or hardware update of translation table, level 2. syncExternalAbortOnTableWalkLvl3 = 0b010111, // Synchronous External abort on translation table walk or hardware update of translation table, level 3. syncParityOrEccErrOnMemAccessOrWalk = 0b011000, // Synchronous parity or ECC error on memory access, not on translation table walk. syncParityOrEccErrOnMemAccessOrWalkLvlN1 = 0b011011, // Synchronous parity or ECC error on memory access on translation table walk or hardware update of translation table, level -1. syncParityOrEccErrOnMemAccessOrWalkLvl0 = 0b011100, // Synchronous parity or ECC error on memory access on translation table walk or hardware update of translation table, level 0. syncParityOrEccErrOnMemAccessOrWalkLvl1 = 0b011101, // Synchronous parity or ECC error on memory access on translation table walk or hardware update of translation table, level 1. syncParityOrEccErrOnMemAccessOrWalkLvl2 = 0b011110, // Synchronous parity or ECC error on memory access on translation table walk or hardware update of translation table, level 2. syncParityOrEccErrOnMemAccessOrWalkLvl3 = 0b011111, // Synchronous parity or ECC error on memory access on translation table walk or hardware update of translation table, level 3. granuleProtectionFaultOnWalkLvlN1 = 0b100011, // Granule Protection Fault on translation table walk or hardware update of translation table, level -1. granuleProtectionFaultOnWalkLvl0 = 0b100100, // Granule Protection Fault on translation table walk or hardware update of translation table, level 0. granuleProtectionFaultOnWalkLvl1 = 0b100101, // Granule Protection Fault on translation table walk or hardware update of translation table, level 1. granuleProtectionFaultOnWalkLvl2 = 0b100110, // Granule Protection Fault on translation table walk or hardware update of translation table, level 2. granuleProtectionFaultOnWalkLvl3 = 0b100111, // Granule Protection Fault on translation table walk or hardware update of translation table, level 3. granuleProtectionFaultNotOnWalk = 0b101000, // Granule Protection Fault, not on translation table walk or hardware update of translation table. addrSizeFaukltLvlN1 = 0b101001, // Address size fault, level -1. transFaultLvlN1 = 0b101011, // Translation fault, level -1. tlbConflictAbort = 0b110000, // TLB conflict abort. unsupportedAtomicHardwareUpdateFault = 0b110001, // Unsupported atomic hardware update fault. }; pub const ExceptionClass = enum(u6) { trappedWF = 0b000001, trappedMCR = 0b000011, trappedMcrr = 0b000100, trappedMCRWithAcc = 0b000101, trappedLdcStcAcc = 0b000110, sveAsmidFpAcc = 0b000111, trappedLdStInst = 0b001010, trappedMrrcWithAcc = 0b001100, branchTargetExc = 0b001101, illegalExecState = 0b001110, svcInstExcAArch32 = 0b010001, svcInstExAArch64 = 0b010101, trappedMsrMrsSiAarch64 = 0b011000, sveFuncTrappedAcc = 0b011001, excFromPointerAuthInst = 0b011100, instAbortFromLowerExcLvl = 0b100000, instAbortTakenWithoutExcLvlChange = 0b100001, pcAlignFaultExc = 0b100010, dataAbortFromLowerExcLvl = 0b100100, dataAbortWithoutExcLvlChange = 0b100101, spAlignmentFaultExc = 0b100110, trappedFpExcAarch32 = 0b101000, trappedFpExcAarch64 = 0b101100, brkPExcFromLowerExcLvl = 0b101111, brkPExcWithoutExcLvlChg = 0b110001, softwStepExcpFromLowerExcLvl = 0b110010, softwStepExcTakenWithoutExcLvlChange = 0b110011, watchPointExcpFromALowerExcLvl = 0b110100, watchPointExcpWithoutTakenWithoutExcLvlChange = 0b110101, bkptInstExecAarch32 = 0b111000, bkptInstExecAarch64 = 0b111100, }; }; pub const SpsrReg = packed struct { pub inline fn setSpsrReg(comptime el: ExceptionLevels, val: usize) void { asm volatile ("msr spsr_" ++ @tagName(el) ++ ", %[val]" : : [val] "r" (val), ); } pub inline fn readSpsrReg(comptime el: ExceptionLevels) usize { return asm volatile ("mrs %[curr], spsr_" ++ @tagName(el) : [curr] "=r" (-> usize), ); } }; pub const MairReg = packed struct { attr0: u8 = 0, attr1: u8 = 0, attr2: u8 = 0, attr3: u8 = 0, attr4: u8 = 0, attr5: u8 = 0, attr6: u8 = 0, attr7: u8 = 0, pub fn asInt(self: MairReg) usize { return @as(u64, @bitCast(self)); } pub inline fn setMairEl(comptime el: ExceptionLevels, val: usize) void { asm volatile ("msr mair_" ++ @tagName(el) ++ ", %[val]" : : [val] "r" (val), ); } pub fn readTcrEl(comptime el: ExceptionLevels) usize { const x: usize = asm ("mrs %[curr], mair_" ++ @tagName(el) : [curr] "=r" (-> usize), ); return x; } }; pub const SctlrEl = struct { pub inline fn setSctlrEl(comptime el: ExceptionLevels, val: usize) void { asm volatile ("msr sctlr_" ++ @tagName(el) ++ ", %[val]" : : [val] "r" (val), ); } pub fn readSctlrEl(comptime el: ExceptionLevels) usize { const x: usize = asm ("mrs %[curr], sctlr_" ++ @tagName(el) : [curr] "=r" (-> usize), ); return x; } }; // enables for el0/1 for el1 pub inline fn enableMmu(comptime el: ExceptionLevels) void { // var val = SctlrEl.readSctlrEl(el); const val = 1 << 0; SctlrEl.setSctlrEl(el, val); asm volatile ("isb"); } pub inline fn disableMmu(comptime el: ExceptionLevels) void { var val = SctlrEl.readSctlrEl(el); val &= ~(1 << 0); SctlrEl.setSctlrEl(el, val); asm volatile ("isb"); } pub inline fn setSp(addr: usize) void { asm volatile ("mov sp, %[addr]" : : [addr] "r" (addr), ); isb(); } pub inline fn branchToAddr(addr: usize) void { asm volatile ("br %[pc_addr]" : : [pc_addr] "r" (addr), ); } pub fn invalidateMmuTlbEl1() void { // https://developer.arm.com/documentation/ddi0488/c/system-control/aarch64-register-summary/aarch64-tlb-maintenance-operations asm volatile ("TLBI VMALLE1IS"); } pub fn setTTBR1(addr: usize) void { asm volatile ("msr ttbr1_el1, %[addr]" : : [addr] "r" (addr), ); } pub fn setTTBR0(addr: usize) void { asm volatile ("msr ttbr0_el1, %[addr]" : : [addr] "r" (addr), ); } pub fn readTTBR0() usize { return asm ("mrs %[curr], ttbr0_el1" : [curr] "=r" (-> usize), ); } pub fn readTTBR1() usize { return asm ("mrs %[curr], ttbr1_el1" : [curr] "=r" (-> usize), ); } pub fn invalidateCache() void { asm volatile ("IC IALLUIS"); } pub fn invalidateOldPageTableEntries() void { const ttbr1: usize = asm ("mrs %[curr], ttbr1_el1" : [curr] "=r" (-> usize), ); const ttbr0: usize = asm ("mrs %[curr], ttbr0_el1" : [curr] "=r" (-> usize), ); asm volatile ("dc civac, %[addr]" : : [addr] "r" (ttbr0), ); asm volatile ("dc civac, %[addr]" : : [addr] "r" (ttbr1), ); } pub inline fn isb() void { asm volatile ("isb"); } pub inline fn dsb() void { asm volatile ("dsb SY"); } pub inline fn setExceptionVec(exc_vec_addr: usize) void { // .foramt(.{@tagName(exc_lvl)}) std.fmt.comptimePrint() asm volatile ("msr vbar_el1, %[exc_vec]" : : [exc_vec] "r" (exc_vec_addr), ); asm volatile ("isb"); } pub inline fn exceptionSvc() void { // Supervisor call. generates an exception targeting exception level 1 (EL1). asm volatile ("svc #0xdead"); } pub fn getCurrentEl() usize { const x: usize = asm ("mrs %[curr], CurrentEL" : [curr] "=r" (-> usize), ); return x >> 2; } pub fn getCurrentSp() usize { const x: usize = asm ("mov %[curr], sp" : [curr] "=r" (-> usize), ); return x; } // ! is inlined and volatile ! pub inline fn getCurrentPc() usize { return asm volatile ("adr %[pc], ." : [pc] "=r" (-> usize), ); } pub inline fn setSpsel(exc_l: ExceptionLevels) void { asm volatile ("msr spsel, %[el]" : : [el] "r" (@intFromEnum(exc_l)), ); } pub inline fn nop() void { asm volatile ("nop"); } // has to happen at el3 pub fn isSecState(el: ExceptionLevels) bool { if (el != .elr) @compileError("can only read security state in el3"); // reading NS bit const x: usize = asm ("mrs %[curr], scr_el3" : [curr] "=r" (-> usize), ); return (x & (1 << 0)) != 0; } pub fn panic() noreturn { while (true) {} } pub const DaifReg = packed struct(u4) { debug: bool, serr: bool, irqs: bool, fiqs: bool, pub fn setDaifClr(daif_config: DaifReg) void { asm volatile ("msr daifclr, %[conf]" : : [conf] "I" (daif_config), ); } pub fn setDaif(daif_config: DaifReg) void { asm volatile ("msr daifset, %[conf]" : : [conf] "I" (daif_config), ); } pub fn enableIrq() callconv(.C) void { asm volatile ("msr daifclr, %[conf]" : : [conf] "I" (DaifReg{ .debug = false, .serr = false, .irqs = true, .fiqs = false }), ); } pub fn disableIrq() callconv(.C) void { asm volatile ("msr daifset, %[conf]" : : [conf] "I" (DaifReg{ .debug = false, .serr = false, .irqs = true, .fiqs = false }), ); } }; }; comptime { @export(ProccessorRegMap.DaifReg.enableIrq, .{ .name = "enableIrq", .linkage = .Strong }); @export(ProccessorRegMap.DaifReg.disableIrq, .{ .name = "disableIrq", .linkage = .Strong }); }
0
repos/MinimalRoboticsPlatform/src
repos/MinimalRoboticsPlatform/src/arm/arm.zig
const board = @import("board"); pub const mmu = @import("mmu.zig"); pub const gicv2 = @import("gicv2.zig"); pub const processor = @import("processor.zig"); pub const cpuContext = @import("cpuContext.zig");
0
repos/MinimalRoboticsPlatform/src
repos/MinimalRoboticsPlatform/src/arm/mmu.zig
const std = @import("std"); const board = @import("board"); const utils = @import("utils"); const kprint = @import("periph").uart.UartWriter(.ttbr1).kprint; const ProccessorRegMap = @import("processor.zig").ProccessorRegMap; const Granule = board.boardConfig.Granule; const GranuleParams = board.boardConfig.Granule.GranuleParams; const TransLvl = board.boardConfig.TransLvl; pub const Mapping = struct { mem_size: usize, pointing_addr_start: usize, virt_addr_start: usize, granule: GranuleParams, addr_space: board.boardConfig.AddrSpace, // currently only supported for sections flags_last_lvl: TableDescriptorAttr, flags_non_last_lvl: TableDescriptorAttr, }; const Error = error{ FlagConfigErr, PageTableConfigErr, }; // In addition to an output address, a translation table descriptor that refers to a page or region of memory // includes fields that define properties of the target memory region. These fields can be classified as // address map control, access control, and region attribute fields. pub const TableDescriptorAttr = packed struct { // block indicates next trans lvl (or physical for sections) and page the last trans lvl (with physical addr) pub const DescType = enum(u1) { block = 0, page = 1 }; // redirects read from mem tables to mairx reg (domain) pub const AttrIndex = enum(u3) { mair0 = 0, mair1 = 1, mair2 = 2, mair3 = 3, mair4 = 4, mair5 = 5, mair6 = 6, mair7 = 7 }; pub const Sharability = enum(u2) { non_sharable = 0, unpredictable = 1, outer_sharable = 2, innner_sharable = 3 }; // for Non-secure stage 1 of the EL1&0 translation regime pub const Stage1AccessPerm = enum(u2) { only_el1_read_write = 0, read_write = 1, only_el1_read_only = 2, read_only = 3 }; // for Non-secure EL1&0 stage 2 translation regime pub const Stage2AccessPerm = enum(u2) { none = 0, read_only = 1, write_only = 2, read_write = 3 }; // for secure EL2&3 translation regime pub const SecureAccessPerm = enum(u2) { read_write = 0, read_only = 3 }; // https://armv8-ref.codingbelief.com/en/chapter_d4/d43_1_vmsav8-64_translation_table_descriptor_formats.html // https://armv8-ref.codingbelief.com/en/chapter_d4/d43_2_armv8_translation_table_level_3_descriptor_formats.html // identifies whether the descriptor is valid, and is 1 for a valid descriptor. valid: bool = true, // identifies the descriptor type, and is encoded as: descType: DescType = .block, // 4 following are onl important for block entries // https://armv8-ref.codingbelief.com/en/chapter_d4/d43_3_memory_attribute_fields_in_the_vmsav8-64_translation_table_formats_descriptors.html attrIndex: AttrIndex = .mair0, // For memory accesses from Secure state, specifies whether the output address is in the Secure or Non-secure address map ns: bool = false, // depends on translation level (Stage2AccessPerm, Stage1AccessPerm, SecureAccessPerm) accessPerm: Stage1AccessPerm = .read_only, sharableAttr: Sharability = .non_sharable, // The access flag indicates when a page or section of memory is accessed for the first time since the // Access flag in the corresponding translation table descriptor was set to 0. accessFlag: bool = true, // the not global bit. Determines whether the TLB descriptor applies to all ASID values, or only to the current ASID value notGlobal: bool = false, // upper attr following address: u39 = 0, // indicating that the translation table descriptor is one of a contiguous set or descriptors, that might be cached in a single TLB descriptor contiguous: bool = false, // priviledeg execute-never bit. Determines whether the region is executable at EL1 pxn: bool = false, // execute-never bit. Determines whether the region is executable uxn: bool = false, _padding2: u10 = 0, pub fn asInt(self: TableDescriptorAttr) usize { return @as(u64, @bitCast(self)); } }; pub fn PageTable(comptime total_mem_size: usize, comptime gran: GranuleParams) !type { const req_table_total = try calctotalTablesReq(gran, total_mem_size); return struct { const Self = @This(); pub const totaPageTableSize = req_table_total * gran.table_size; lma_offset: usize, total_size: usize, page_table_gran: GranuleParams, page_table: *volatile [req_table_total][gran.table_size]usize, pub fn init(page_tables: *volatile [req_table_total * gran.table_size]usize, lma_offset: usize) !Self { return Self{ .lma_offset = lma_offset, .total_size = total_mem_size, .page_table_gran = gran, .page_table = @as(*volatile [req_table_total][gran.table_size]usize, @ptrCast(page_tables)), }; } fn calcTransLvlDescriptorSize(mapping: Mapping, lvl: TransLvl) usize { return std.math.pow(usize, mapping.granule.table_size, @intFromEnum(mapping.granule.lvls_required) - @intFromEnum(lvl)) * mapping.granule.page_size; } pub fn mapMem(self: *Self, mapping_without_adjusted_flags: Mapping) !void { var mapping = mapping_without_adjusted_flags; if (std.meta.eql(mapping.granule, board.boardConfig.Granule.FourkSection)) mapping.flags_last_lvl.descType = .block; if (std.meta.eql(mapping.granule, board.boardConfig.Granule.Fourk)) mapping.flags_last_lvl.descType = .page; mapping.flags_non_last_lvl.descType = .page; if (!std.meta.eql(mapping.granule, gran)) return Error.PageTableConfigErr; var table_offset: usize = 0; var i_lvl: usize = 0; var phys_count = mapping.pointing_addr_start | mapping.flags_last_lvl.asInt(); while (i_lvl <= @intFromEnum(mapping.granule.lvls_required)) : (i_lvl += 1) { const curr_lvl_desc_size = calcTransLvlDescriptorSize(mapping, @as(TransLvl, @enumFromInt(i_lvl))); var next_lvl_desc_size: usize = 0; var vas_next_offset_in_tables: usize = 0; if (i_lvl != @intFromEnum(mapping.granule.lvls_required)) { next_lvl_desc_size = calcTransLvlDescriptorSize(mapping, @as(TransLvl, @enumFromInt(i_lvl + 1))); vas_next_offset_in_tables = try std.math.divFloor(usize, try std.math.divExact(usize, mapping.virt_addr_start, next_lvl_desc_size), mapping.granule.table_size); } const vas_offset_in_descriptors = try std.math.divFloor(usize, mapping.virt_addr_start, curr_lvl_desc_size); const vas_offset_in_tables = try std.math.divFloor(usize, vas_offset_in_descriptors, mapping.granule.table_size); const vas_offset_in_descriptors_rest = try std.math.mod(usize, vas_offset_in_descriptors, mapping.granule.table_size); const to_map_in_descriptors = try std.math.divCeil(usize, mapping.mem_size + mapping.virt_addr_start, curr_lvl_desc_size); const to_map_in_tables = try std.math.divCeil(usize, to_map_in_descriptors, mapping.granule.table_size); const to_map_in_descriptors_rest = try std.math.mod(usize, to_map_in_descriptors, mapping.granule.table_size); const total_mem_size_padding_in_descriptors = try std.math.divFloor(usize, total_mem_size, curr_lvl_desc_size); var total_mem_size_padding_in_tables = try std.math.divFloor(usize, total_mem_size_padding_in_descriptors, mapping.granule.table_size); if (total_mem_size_padding_in_tables >= to_map_in_tables) total_mem_size_padding_in_tables -= to_map_in_tables; var i_table: usize = vas_offset_in_tables; var i_descriptor: usize = vas_offset_in_descriptors_rest; var left_descriptors: usize = 0; while (i_table < to_map_in_tables) : (i_table += 1) { // if last table is reached, only write the to_map_in_descriptors_rest left_descriptors = mapping.granule.table_size; // explicitely casting to signed bc substraction could result in negative num. if (i_table == @as(i128, to_map_in_tables - 1) and to_map_in_descriptors_rest != 0) left_descriptors = to_map_in_descriptors_rest; while (i_descriptor < left_descriptors) : (i_descriptor += 1) { // last lvl translation links to physical mem if (i_lvl == @intFromEnum(mapping.granule.lvls_required)) { self.page_table[table_offset + i_table][i_descriptor] = phys_count; phys_count += mapping.granule.page_size; } else { if (vas_next_offset_in_tables >= i_descriptor) vas_next_offset_in_tables -= i_descriptor; var link_to_table_addr = utils.toTtbr0(usize, @intFromPtr(&self.page_table[table_offset + to_map_in_tables + i_descriptor + vas_next_offset_in_tables + total_mem_size_padding_in_tables])) + self.lma_offset; if (i_lvl == @intFromEnum(TransLvl.first_lvl) or i_lvl == @intFromEnum(TransLvl.second_lvl)) link_to_table_addr |= mapping.flags_non_last_lvl.asInt(); self.page_table[table_offset + i_table][i_descriptor] = link_to_table_addr; } } i_descriptor = 0; } table_offset += i_table + total_mem_size_padding_in_tables; } } }; } fn calctotalTablesReq(comptime granule: Granule.GranuleParams, comptime mem_size: usize) !usize { const req_descriptors = try std.math.divExact(usize, mem_size, granule.page_size); var req_table_total_: usize = 0; var ci_lvl: usize = 1; while (ci_lvl <= @intFromEnum(granule.lvls_required) + 1) : (ci_lvl += 1) { req_table_total_ += try std.math.divCeil(usize, req_descriptors, std.math.pow(usize, granule.table_size, ci_lvl)); } return req_table_total_; }
0
repos
repos/Zprob/README.md
# Zprob A simple console progress bar for Zig(no dependencies required). Only tested on zig 0.13.0. ## Usage only need import `Zprob.zig`(in `src` folder) and use `Zprob` struct. run `zig build run` to see `example.zig`'s output. `example.zig`: ```zig const std = @import("std"); const Zprob = @import("Zprob.zig"); pub fn main() !void { // Get a new Zprob instance. // The capacity is set to 100. // The output file is set to the standard output. var zprob = Zprob{ .capacity = 100, .out = &std.io.getStdOut() }; // Reset(initialize) the progress bar. // Must be called just before the loop. zprob.Reset(); for (0..100) |i| { _ = i; // Because write to the standard output may fail, we use `try`. // Can't use `defer` here because return value is not `void`. try zprob.Update(1, "test"); } // Reuse the Zprob instance. zprob.Resize(1000); var b: u32 = 0; while (b < 1000) : (b += 1) { var buffer: [10]u8 = undefined; const curr_number_str = std.fmt.bufPrint(buffer[0..], "{}", .{b}) catch unreachable; // Update the progress bar with description. try zprob.Update(1, curr_number_str); std.time.sleep(10_000_000); } zprob.Reset(); b = 0; while (b < 1000) : (try zprob.Update(1, "")) { b += 1; std.time.sleep(10_000_000); } } ```
0
repos
repos/Zprob/build.zig.zon
.{ .name = "Zprob", .version = "0.1.0", .minimum_zig_version = "0.13.0", .dependencies = .{}, .paths = .{ "build.zig", "build.zig.zon", "src", // For example... //"LICENSE", //"README.md", }, }
0
repos
repos/Zprob/build.zig
const std = @import("std"); pub fn build(b: *std.Build) void { const target = b.standardTargetOptions(.{}); const optimize = b.standardOptimizeOption(.{}); const exe = b.addExecutable(.{ .name = "Zprob", .root_source_file = b.path("src/exsample.zig"), .target = target, .optimize = optimize, }); b.installArtifact(exe); const run_cmd = b.addRunArtifact(exe); run_cmd.step.dependOn(b.getInstallStep()); if (b.args) |args| { run_cmd.addArgs(args); } const run_step = b.step("run", "Run the exsample"); run_step.dependOn(&run_cmd.step); }
0
repos/Zprob
repos/Zprob/src/exsample.zig
const std = @import("std"); const Zprob = @import("Zprob.zig"); pub fn main() !void { // Get a new Zprob instance. // The capacity is set to 100. // The output file is set to the standard output. var zprob = Zprob{ .capacity = 100, .out = &std.io.getStdOut() }; // Reset(initialize) the progress bar. // Must be called just before the loop. zprob.Reset(); for (0..100) |i| { _ = i; // Because write to the standard output may fail, we use `try`. // Can't use `defer` here because return value is not `void`. try zprob.Update(1, "test"); } // Reuse the Zprob instance. zprob.Resize(1000); var b: u32 = 0; while (b < 1000) : (b += 1) { var buffer: [10]u8 = undefined; const curr_number_str = std.fmt.bufPrint(buffer[0..], "{}", .{b}) catch unreachable; // Update the progress bar with description. try zprob.Update(1, curr_number_str); std.time.sleep(10_000_000); } zprob.Reset(); b = 0; while (b < 1000) : (try zprob.Update(1, "")) { b += 1; std.time.sleep(10_000_000); } }
0
repos/Zprob
repos/Zprob/src/Zprob.zig
//! A simple console progress bar for Zig. /// The length of range to iterate. capacity: u32 = 0, /// File to write the progress bar to, usually `std.io.getStdOut()`. /// Must be set before calling `Update`. out: ?*const std.fs.File = null, progress: u32 = 0, start_time: i64 = 0, p: u8 = 0, bar: [bar_len]u8 = init_bar(), const bar_len = 112; const ZprobError = error{ OutFileNotSet, }; inline fn init_bar() [bar_len]u8 { var bar: [bar_len]u8 = [_]u8{0} ** bar_len; const head = "\r[\x1b[46m\x1b[0m"; for (head, 0..) |c, i| { bar[i] = c; } for (0..100) |i| { bar[i + 11] = ' '; } bar[bar_len - 1] = ']'; return bar; } /// Update the progress bar's status. /// `count` is the number of items processed in this iteration. /// `desc` is the description text to show of the current iteration. pub fn Update(self: *Self, count: u32, desc: []const u8) anyerror!void { if (self.capacity == 0) { return self.UpdateBar(100, desc); } else { self.progress += count; if (self.progress >= self.capacity) { self.progress = self.capacity; } const p: u8 = @intCast(self.progress * 100 / self.capacity); return self.UpdateBar(p, desc); } } inline fn UpdateBar(self: *Self, p: u8, desc: []const u8) anyerror!void { self.p = p; for (0..p) |i| { self.bar[i + 7] = ' '; } var buffer: [100]u8 = undefined; const number_str = std.fmt.bufPrint(buffer[0..], "{}/{}|", .{ self.progress, self.capacity }) catch unreachable; var len = self.SetString(number_str, 0); len = self.SetString(self.GetSpeed(), len); self.SetChar('|', len); len += 1; len = self.SetString(desc, len); const tail = "\x1b[0m"; self.SetStringForce(tail, p + 7); if (self.out == null) { return ZprobError.OutFileNotSet; } else { try self.out.?.*.writer().print("{s}", .{self.bar}); if (self.progress == self.capacity) { try self.out.?.*.writer().print("\n", .{}); } } } fn GetSpeed(self: *Self) []const u8 { const time_cost: i64 = std.time.milliTimestamp() - self.start_time; var buffer: [100]u8 = undefined; var per: f64 = @as(f64, @floatFromInt(time_cost)) / @as(f64, @floatFromInt(self.progress * 1000)); const flag: bool = per < 1; per = if (flag) 1.0 / per else per; const left: f64 = @as(f64, @floatFromInt(self.capacity - self.progress)) / per; if (flag) { return std.fmt.bufPrint(buffer[0..], "{d:.2}it/s,{d:.2}s left", .{ per, left }) catch unreachable; } else { return std.fmt.bufPrint(buffer[0..], "{d:.2}s/it,{d:.2}s left", .{ per, left }) catch unreachable; } } inline fn SetString(self: *Self, s: []const u8, i: u8) u8 { for (s, 0..) |c, j| { self.SetChar(c, @intCast(j + i)); } return @intCast(s.len + i); } inline fn SetChar(self: *Self, c: u8, i: u8) void { if (i >= self.p) { self.bar[i + 11] = c; } else { self.bar[i + 7] = c; } } inline fn SetStringForce(self: *Self, s: []const u8, i: u8) void { for (s, 0..) |c, j| { self.bar[i + j] = c; } } /// Reset status, must be called just before the loop, or use Resize instead. /// This will reset the progress to 0 and start the timer. pub fn Reset(self: *Self) void { self.progress = 0; self.bar = init_bar(); self.start_time = std.time.milliTimestamp(); } /// Resize the capacity of the progress bar, will reset the status as well. pub fn Resize(self: *Self, len: u32) void { self.capacity = len; self.Reset(); } const std = @import("std"); const Self = @This();
0
repos
repos/zig_learn_opengl/README.md
# [**Learn OpenGL**](https://learnopengl.com/) using [Zig](https://ziglang.org/). Windowing library: [mach/glfw - Ziggified GLFW bindings](https://github.com/hexops/mach-glfw) by slimsag (Stephen Gutekanst). OpenGL bindings for Zig were generated by the [zig-opengl](https://github.com/MasterQ32/zig-opengl) project by MasterQ32 (Felix Queißner). [zstbi](https://github.com/michal-z/zig-gamedev/tree/main/libs/zstbi) - stb image bindings, [zmath](https://github.com/michal-z/zig-gamedev/tree/main/libs/zmath) - SIMD math library, provided by [Michal Ziulek](https://github.com/michal-z), part of the [zig-gamedev](https://github.com/michal-z/zig-gamedev) project. Sample programs can be used together with the reference book: [Learn OpenGL - Graphics Programming](https://learnopengl.com/) by [Joey de Vries](http://joeydevries.com/#home). --- Zig Language installation [How-to instructions](https://ziglang.org/learn/getting-started/). --- ## **I. Getting Started** ### Hello Triangle - [**hello_triangle**](src/getting_started/hello_triangle/): Minimal setup for drawing a trianlge on screen.<br />`zig build hello_triangle-run` <br /><a href="src/getting_started/hello_triangle"><img src="src/getting_started/hello_triangle/image.png" alt="hello triangle" height="200"></a> - [**hello_rectangle**](src/getting_started/hello_rectangle/): Draw a rectangle efficiently with indexed rendering using the **'Element Buffer Object'**. <br />`zig build hello_rectangle-run` <br /><a href="src/getting_started/hello_rectangle"><img src="src/getting_started/hello_rectangle/image.png" alt="hello triangle" height="200"></a> ### Shaders - [**shaders**](src/getting_started/shaders/): Little programs that rest on the GPU <br /> `zig build shaders-run` <br /><a href="src/getting_started/shaders"><img src="src/getting_started/shaders/image.png" alt="shaders" height="200"></a> [Shader](src/common/shader.zig) struct mirrors the C++ Shader Class in the book. ### Textures - [**textures**](src/getting_started/textures/): Decorate objects with textures <br /> `zig build textures-run` <br /><a href="src/getting_started/textures"><img src="src/getting_started/textures/image.png" alt="textures" height="200"></a> ### Transformations - [**Transformations**](src/getting_started/transformations/): Apply a transformation matrix to vertex data <br /> `zig build transformations-run` <br /><a href="src/getting_started/transformations"><img src="src/getting_started/transformations/image.png" alt="transformations" height="200"></a> ### Coordinate Systems - [**Coordinate systems**](src/getting_started/coordinate_systems/): Model, View, Projection matrices <br /> `zig build coordinate_systems-run` <br /><a href="src/getting_started/coordinate_systems"><img src="src/getting_started/coordinate_systems/image.png" alt="coordinate_systems" height="200"></a> ### Camera - [**Camera rotation**](src/getting_started/camera_rotate/): Camera rotation around world origin <br /> `zig build camera_rotate-run` - [**Simple camera**](src/getting_started/simple_camera/): Fly-like camera <br /> `zig build simple_camera-run` ## **II. Lighting** ### Basic Lighting - [**Basic Lighting**](src/getting_started/basic_lighting/): Phong lighting model <br /> `zig build basic_lighting-run` <br /><a href="src/getting_started/basic_lighting"><img src="src/getting_started/basic_lighting/image.png" alt="basic_lighting" height="200"></a>
0
repos
repos/zig_learn_opengl/build.zig
const std = @import("std"); const glfw = @import("libs/mach-glfw/build.zig"); const zstbi = @import("libs/zstbi/build.zig"); const zmath = @import("libs/zmath/build.zig"); fn installExe(b: *std.build.Builder, exe: *std.build.LibExeObjStep, comptime name: []const u8, dependencies: []const ExeDependency) !void { exe.want_lto = false; if (exe.optimize == .ReleaseFast) exe.strip = true; for (dependencies) |dep| { exe.addModule(dep.name, dep.module); } try glfw.link(b, exe, .{}); zstbi.link(exe); const install = b.step(name, "Build '" ++ name); install.dependOn(&b.addInstallArtifact(exe).step); const run_step = b.step(name ++ "-run", "Run " ++ name); const run_cmd = exe.run(); run_cmd.step.dependOn(install); run_step.dependOn(&run_cmd.step); b.getInstallStep().dependOn(install); } pub fn build(b: *std.Build) !void { const options = Options{ .build_mode = b.standardOptimizeOption(.{}), .target = b.standardTargetOptions(.{}), }; // Modules const zmath_module = zmath.package(b, .{}).module; const zstbi_module = zstbi.package(b, .{}).module; const glfw_module = glfw.module(b); const gl_module = b.createModule(.{ .source_file = .{ .path = "libs/gl.zig" }, .dependencies = &.{} }); const shader_module = b.createModule(.{ .source_file = .{ .path = "libs/Shader.zig" }, .dependencies = &.{.{ .name = "gl", .module = gl_module }} }); const common_module = b.createModule(.{ .source_file = .{ .path = "libs/common.zig" }, .dependencies = &.{} }); const camera_module = b.createModule(.{ .source_file = .{ .path = "libs/Camera.zig" }, .dependencies = &.{ .{ .name = "gl", .module = gl_module }, .{ .name = "Shader", .module = shader_module }, .{ .name = "zmath", .module = zmath_module }, .{ .name = "common", .module = common_module } } }); // Dependencies const exe_dependencies: []const ExeDependency = &.{ .{ .name = "zmath", .module = zmath_module }, .{ .name = "zstbi", .module = zstbi_module }, .{ .name = "gl", .module = gl_module }, .{ .name = "glfw", .module = glfw_module }, .{ .name = "Shader", .module = shader_module }, .{ .name = "common", .module = common_module }, .{ .name = "Camera", .module = camera_module } }; const hello_triangle = @import("src/getting_started/hello_triangle/build.zig"); const hello_rectangle = @import("src/getting_started/hello_rectangle/build.zig"); const shaders = @import("src/getting_started/shaders/build.zig"); const textures = @import("src/getting_started/textures/build.zig"); const transformations = @import("src/getting_started/transformations/build.zig"); const coordinate_systems = @import("src/getting_started/coordinate_systems/build.zig"); const camera_rotate = @import("src/getting_started/camera_rotate/build.zig"); const simple_camera = @import("src/getting_started/simple_camera/build.zig"); const basic_lighting = @import("src/getting_started/basic_lighting/build.zig"); try installExe(b, hello_triangle.build(b, options), "hello_triangle", exe_dependencies); try installExe(b, hello_rectangle.build(b, options), "hello_rectangle", exe_dependencies); try installExe(b, shaders.build(b, options), "shaders", exe_dependencies); try installExe(b, textures.build(b, options), "textures", exe_dependencies); try installExe(b, transformations.build(b, options), "transformations", exe_dependencies); try installExe(b, coordinate_systems.build(b, options), "coordinate_systems", exe_dependencies); try installExe(b, camera_rotate.build(b, options), "camera_rotate", exe_dependencies); try installExe(b, simple_camera.build(b, options), "simple_camera", exe_dependencies); try installExe(b, basic_lighting.build(b, options), "basic_lighting", exe_dependencies); } pub const Options = struct { build_mode: std.builtin.Mode, target: std.zig.CrossTarget, }; pub const ExeDependency = struct { name: []const u8, module: *std.Build.Module, };
0
repos/zig_learn_opengl/src/getting_started
repos/zig_learn_opengl/src/getting_started/transformations/main.zig
const std = @import("std"); const math = std.math; const glfw = @import("glfw"); const zstbi = @import("zstbi"); const zm = @import("zmath"); const gl = @import("gl"); const Shader = @import("Shader"); const common = @import("common"); const WindowSize = struct { pub const width: u32 = 800; pub const height: u32 = 600; }; pub fn main() !void { // glfw: initialize and configure // ------------------------------ if (!glfw.init(.{})) { std.log.err("GLFW initialization failed", .{}); return; } defer glfw.terminate(); // glfw window creation // -------------------- const window = glfw.Window.create(WindowSize.width, WindowSize.height, "mach-glfw + zig-opengl", null, null, .{ .opengl_profile = .opengl_core_profile, .context_version_major = 4, .context_version_minor = 1, }) orelse { std.log.err("GLFW Window creation failed", .{}); return; }; defer window.destroy(); glfw.makeContextCurrent(window); glfw.Window.setFramebufferSizeCallback(window, framebuffer_size_callback); // Load all OpenGL function pointers // --------------------------------------- const proc: glfw.GLProc = undefined; try gl.load(proc, glGetProcAddress); var gpa = std.heap.GeneralPurposeAllocator(.{}){}; var allocator = gpa.allocator(); var arena_allocator_state = std.heap.ArenaAllocator.init(allocator); defer arena_allocator_state.deinit(); const arena = arena_allocator_state.allocator(); // create shader program var shader_program: Shader = Shader.create(arena, "content/shader.vs", "content/shader.fs"); // set up vertex data (and buffer(s)) and configure vertex attributes // ------------------------------------------------------------------ const vertices = [_]f32{ // positions // colors // texture coords 0.5, 0.5, 0.0, 1.0, 0.0, 0.0, 1.0, 1.0, // top right 0.5, -0.5, 0.0, 0.0, 1.0, 0.0, 1.0, 0.0, // bottom right -0.5, -0.5, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, // bottom left -0.5, 0.5, 0.0, 1.0, 1.0, 0.0, 0.0, 1.0, // top left }; const indices = [_]c_uint{ // note that we start from 0! 0, 1, 3, // first triangle 1, 2, 3, // second triangle }; var VBO: c_uint = undefined; var VAO: c_uint = undefined; var EBO: c_uint = undefined; gl.genVertexArrays(1, &VAO); defer gl.deleteVertexArrays(1, &VAO); gl.genBuffers(1, &VBO); defer gl.deleteBuffers(1, &VBO); gl.genBuffers(1, &EBO); defer gl.deleteBuffers(1, &EBO); // bind the Vertex Array Object first, then bind and set vertex buffer(s), and then configure vertex attributes(s). gl.bindVertexArray(VAO); gl.bindBuffer(gl.ARRAY_BUFFER, VBO); // Fill our buffer with the vertex data gl.bufferData(gl.ARRAY_BUFFER, @sizeOf(f32) * vertices.len, &vertices, gl.STATIC_DRAW); gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, EBO); gl.bufferData(gl.ELEMENT_ARRAY_BUFFER, 6 * @sizeOf(c_uint), &indices, gl.STATIC_DRAW); // vertex gl.vertexAttribPointer(0, 3, gl.FLOAT, gl.FALSE, 8 * @sizeOf(f32), null); gl.enableVertexAttribArray(0); // colors const col_offset: [*c]c_uint = (3 * @sizeOf(f32)); gl.vertexAttribPointer(1, 3, gl.FLOAT, gl.FALSE, 8 * @sizeOf(f32), col_offset); gl.enableVertexAttribArray(1); // texture coords const tex_offset: [*c]c_uint = (6 * @sizeOf(f32)); gl.vertexAttribPointer(2, 2, gl.FLOAT, gl.FALSE, 8 * @sizeOf(f32), tex_offset); gl.enableVertexAttribArray(2); // zstbi: loading an image. zstbi.init(allocator); defer zstbi.deinit(); const image1_path = common.pathToContent(arena, "content/container.jpg") catch unreachable; var image1 = try zstbi.Image.init(&image1_path, 0); defer image1.deinit(); std.debug.print("\nImage 1 info:\n\n img width: {any}\n img height: {any}\n nchannels: {any}\n", .{ image1.width, image1.height, image1.num_components }); zstbi.setFlipVerticallyOnLoad(true); const image2_path = common.pathToContent(arena, "content/awesomeface.png") catch unreachable; var image2 = try zstbi.Image.init(&image2_path, 0); defer image2.deinit(); std.debug.print("\nImage 2 info:\n\n img width: {any}\n img height: {any}\n nchannels: {any}\n", .{ image2.width, image2.height, image2.num_components }); // Create and bind texture1 resource var texture1: c_uint = undefined; gl.genTextures(1, &texture1); gl.activeTexture(gl.TEXTURE0); // activate the texture unit first before binding texture gl.bindTexture(gl.TEXTURE_2D, texture1); // set the texture1 wrapping parameters gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.REPEAT); // set texture wrapping to GL_REPEAT (default wrapping method) gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.REPEAT); // set texture1 filtering parameters gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR_MIPMAP_LINEAR); gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR); // Generate the texture1 gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGB, @intCast(c_int, image1.width), @intCast(c_int, image1.height), 0, gl.RGB, gl.UNSIGNED_BYTE, @ptrCast([*c]const u8, image1.data)); gl.generateMipmap(gl.TEXTURE_2D); // Texture2 var texture2: c_uint = undefined; gl.genTextures(1, &texture2); gl.activeTexture(gl.TEXTURE1); // activate the texture unit first before binding texture gl.bindTexture(gl.TEXTURE_2D, texture2); // set the texture1 wrapping parameters gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.REPEAT); // set texture wrapping to GL_REPEAT (default wrapping method) gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.REPEAT); // set texture1 filtering parameters gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR_MIPMAP_LINEAR); gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR); // Generate the texture1 gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGB, @intCast(c_int, image2.width), @intCast(c_int, image2.height), 0, gl.RGBA, gl.UNSIGNED_BYTE, @ptrCast([*c]const u8, image2.data)); gl.generateMipmap(gl.TEXTURE_2D); shader_program.use(); shader_program.setInt("texture1", 0); shader_program.setInt("texture2", 1); while (!window.shouldClose()) { processInput(window); gl.clearColor(0.0, 0.0, 0.0, 0.0); gl.clear(gl.COLOR_BUFFER_BIT); gl.activeTexture(gl.TEXTURE0); gl.bindTexture(gl.TEXTURE_2D, texture1); gl.activeTexture(gl.TEXTURE1); gl.bindTexture(gl.TEXTURE_2D, texture2); gl.bindVertexArray(VAO); // Construction of the tranformation matrix const rotZ = zm.rotationZ(@floatCast(f32, glfw.getTime())); const scale = zm.scaling(0.5, 0.5, 0.5); const transformM = zm.mul(rotZ, scale); var transform: [16]f32 = undefined; zm.storeMat(&transform, transformM); // Sending our transformation matrix to our vertex shader const transformLoc = gl.getUniformLocation(shader_program.ID, "transform"); gl.uniformMatrix4fv(transformLoc, 1, gl.FALSE, &transform); gl.drawElements(gl.TRIANGLES, 6, gl.UNSIGNED_INT, null); window.swapBuffers(); glfw.pollEvents(); } } fn glGetProcAddress(p: glfw.GLProc, proc: [:0]const u8) ?gl.FunctionPointer { _ = p; return glfw.getProcAddress(proc); } fn framebuffer_size_callback(window: glfw.Window, width: u32, height: u32) void { _ = window; gl.viewport(0, 0, @intCast(c_int, width), @intCast(c_int, height)); } fn processInput(window: glfw.Window) void { if (glfw.Window.getKey(window, glfw.Key.escape) == glfw.Action.press) { _ = glfw.Window.setShouldClose(window, true); } }
0
repos/zig_learn_opengl/src/getting_started
repos/zig_learn_opengl/src/getting_started/transformations/build.zig
const std = @import("std"); const Options = @import("../../../build.zig").Options; inline fn thisDir() []const u8 { return comptime std.fs.path.dirname(@src().file) orelse "."; } const content_dir = "content/"; pub fn build(b: *std.Build, options: Options) *std.build.CompileStep { const exe = b.addExecutable(.{ .name = "transformations", .root_source_file = .{ .path = thisDir() ++ "/main.zig" }, .target = options.target, .optimize = options.build_mode, }); const install_content_step = b.addInstallDirectory(.{ .source_dir = thisDir() ++ "/" ++ content_dir, .install_dir = .{ .custom = "" }, .install_subdir = "bin/" ++ content_dir, }); exe.step.dependOn(&install_content_step.step); return exe; }
0
repos/zig_learn_opengl/src/getting_started/transformations
repos/zig_learn_opengl/src/getting_started/transformations/content/shader.fs
#version 330 core out vec4 FragColor; in vec3 ourColor; in vec2 texCoord; uniform sampler2D texture1; uniform sampler2D texture2; void main() { FragColor = mix(texture(texture1, texCoord),texture(texture2, texCoord), 0.5f) * vec4(ourColor, 1.0f); };
0
repos/zig_learn_opengl/src/getting_started/transformations
repos/zig_learn_opengl/src/getting_started/transformations/content/shader.vs
#version 330 core layout (location = 0) in vec3 aPos; layout (location = 1) in vec3 aColor; layout (location = 2) in vec2 aTexCoord; out vec3 ourColor; out vec2 texCoord; uniform mat4 transform; void main() { gl_Position = transform * vec4(aPos, 1.0f); ourColor = aColor; texCoord = aTexCoord; }
0
repos/zig_learn_opengl/src/getting_started
repos/zig_learn_opengl/src/getting_started/camera_rotate/main.zig
const std = @import("std"); const math = std.math; const glfw = @import("glfw"); const zstbi = @import("zstbi"); const zm = @import("zmath"); const gl = @import("gl"); const Shader = @import("Shader"); const common = @import("common"); const WindowSize = struct { pub const width: u32 = 800; pub const height: u32 = 600; }; pub fn main() !void { // glfw: initialize and configure // ------------------------------ if (!glfw.init(.{})) { std.log.err("GLFW initialization failed", .{}); return; } defer glfw.terminate(); // glfw window creation // -------------------- const window = glfw.Window.create(WindowSize.width, WindowSize.height, "mach-glfw + zig-opengl", null, null, .{ .opengl_profile = .opengl_core_profile, .context_version_major = 4, .context_version_minor = 1, }) orelse { std.log.err("GLFW Window creation failed", .{}); return; }; defer window.destroy(); glfw.makeContextCurrent(window); glfw.Window.setFramebufferSizeCallback(window, framebuffer_size_callback); // Load all OpenGL function pointers // --------------------------------------- const proc: glfw.GLProc = undefined; try gl.load(proc, glGetProcAddress); var gpa = std.heap.GeneralPurposeAllocator(.{}){}; var allocator = gpa.allocator(); var arena_allocator_state = std.heap.ArenaAllocator.init(allocator); defer arena_allocator_state.deinit(); const arena = arena_allocator_state.allocator(); // create shader program var shader_program: Shader = Shader.create(arena, "content/shader.vs", "content/shader.fs"); // set up vertex data (and buffer(s)) and configure vertex attributes // ------------------------------------------------------------------ const vertices_2D = [_]f32{ // positions // colors // texture coords 0.5, 0.5, 0.0, 1.0, 0.0, 0.0, 1.0, 1.0, // top right 0.5, -0.5, 0.0, 0.0, 1.0, 0.0, 1.0, 0.0, // bottom right -0.5, -0.5, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, // bottom left -0.5, 0.5, 0.0, 1.0, 1.0, 0.0, 0.0, 1.0, // top left }; _ = vertices_2D; const vertices_3D = [_]f32{ -0.5, -0.5, -0.5, 0.0, 0.0, 0.5, -0.5, -0.5, 1.0, 0.0, 0.5, 0.5, -0.5, 1.0, 1.0, 0.5, 0.5, -0.5, 1.0, 1.0, -0.5, 0.5, -0.5, 0.0, 1.0, -0.5, -0.5, -0.5, 0.0, 0.0, -0.5, -0.5, 0.5, 0.0, 0.0, 0.5, -0.5, 0.5, 1.0, 0.0, 0.5, 0.5, 0.5, 1.0, 1.0, 0.5, 0.5, 0.5, 1.0, 1.0, -0.5, 0.5, 0.5, 0.0, 1.0, -0.5, -0.5, 0.5, 0.0, 0.0, -0.5, 0.5, 0.5, 1.0, 0.0, -0.5, 0.5, -0.5, 1.0, 1.0, -0.5, -0.5, -0.5, 0.0, 1.0, -0.5, -0.5, -0.5, 0.0, 1.0, -0.5, -0.5, 0.5, 0.0, 0.0, -0.5, 0.5, 0.5, 1.0, 0.0, 0.5, 0.5, 0.5, 1.0, 0.0, 0.5, 0.5, -0.5, 1.0, 1.0, 0.5, -0.5, -0.5, 0.0, 1.0, 0.5, -0.5, -0.5, 0.0, 1.0, 0.5, -0.5, 0.5, 0.0, 0.0, 0.5, 0.5, 0.5, 1.0, 0.0, -0.5, -0.5, -0.5, 0.0, 1.0, 0.5, -0.5, -0.5, 1.0, 1.0, 0.5, -0.5, 0.5, 1.0, 0.0, 0.5, -0.5, 0.5, 1.0, 0.0, -0.5, -0.5, 0.5, 0.0, 0.0, -0.5, -0.5, -0.5, 0.0, 1.0, -0.5, 0.5, -0.5, 0.0, 1.0, 0.5, 0.5, -0.5, 1.0, 1.0, 0.5, 0.5, 0.5, 1.0, 0.0, 0.5, 0.5, 0.5, 1.0, 0.0, -0.5, 0.5, 0.5, 0.0, 0.0, -0.5, 0.5, -0.5, 0.0, 1.0, }; const cube_positions = [_][3]f32{ .{ 0.0, 0.0, 0.0 }, .{ 2.0, 5.0, -15.0 }, .{ -1.5, -2.2, -2.5 }, .{ -3.8, -2.0, -12.3 }, .{ 2.4, -0.4, -3.5 }, .{ -1.7, 3.0, -7.5 }, .{ 1.3, -2.0, -2.5 }, .{ 1.5, 2.0, -2.5 }, .{ 1.5, 0.2, -1.5 }, .{ -1.3, 1.0, -1.5 }, }; var VBO: c_uint = undefined; var VAO: c_uint = undefined; gl.genVertexArrays(1, &VAO); defer gl.deleteVertexArrays(1, &VAO); gl.genBuffers(1, &VBO); defer gl.deleteBuffers(1, &VBO); // bind the Vertex Array Object first, then bind and set vertex buffer(s), and then configure vertex attributes(s). gl.bindVertexArray(VAO); gl.bindBuffer(gl.ARRAY_BUFFER, VBO); // Fill our buffer with the vertex data gl.bufferData(gl.ARRAY_BUFFER, @sizeOf(f32) * vertices_3D.len, &vertices_3D, gl.STATIC_DRAW); // vertex gl.vertexAttribPointer(0, 3, gl.FLOAT, gl.FALSE, 5 * @sizeOf(f32), null); gl.enableVertexAttribArray(0); // texture coords const tex_offset: [*c]c_uint = (3 * @sizeOf(f32)); gl.vertexAttribPointer(1, 2, gl.FLOAT, gl.FALSE, 5 * @sizeOf(f32), tex_offset); gl.enableVertexAttribArray(1); // zstbi: loading an image. zstbi.init(allocator); defer zstbi.deinit(); const image1_path = common.pathToContent(arena, "content/container.jpg") catch unreachable; var image1 = try zstbi.Image.init(&image1_path, 0); defer image1.deinit(); std.debug.print( "\nImage 1 info:\n\n img width: {any}\n img height: {any}\n nchannels: {any}\n", .{ image1.width, image1.height, image1.num_components }, ); zstbi.setFlipVerticallyOnLoad(true); const image2_path = common.pathToContent(arena, "content/awesomeface.png") catch unreachable; var image2 = try zstbi.Image.init(&image2_path, 0); defer image2.deinit(); std.debug.print( "\nImage 2 info:\n\n img width: {any}\n img height: {any}\n nchannels: {any}\n", .{ image2.width, image2.height, image2.num_components }, ); // Create and bind texture1 resource var texture1: c_uint = undefined; gl.genTextures(1, &texture1); gl.activeTexture(gl.TEXTURE0); // activate the texture unit first before binding texture gl.bindTexture(gl.TEXTURE_2D, texture1); // set the texture1 wrapping parameters gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.REPEAT); // set texture wrapping to GL_REPEAT (default wrapping method) gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.REPEAT); // set texture1 filtering parameters gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR_MIPMAP_LINEAR); gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR); // Generate the texture1 gl.texImage2D( gl.TEXTURE_2D, 0, gl.RGB, @intCast(c_int, image1.width), @intCast(c_int, image1.height), 0, gl.RGB, gl.UNSIGNED_BYTE, @ptrCast([*c]const u8, image1.data), ); gl.generateMipmap(gl.TEXTURE_2D); // Texture2 var texture2: c_uint = undefined; gl.genTextures(1, &texture2); gl.activeTexture(gl.TEXTURE1); // activate the texture unit first before binding texture gl.bindTexture(gl.TEXTURE_2D, texture2); // set the texture1 wrapping parameters gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.REPEAT); // set texture wrapping to GL_REPEAT (default wrapping method) gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.REPEAT); // set texture1 filtering parameters gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR_MIPMAP_LINEAR); gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR); // Generate the texture1 gl.texImage2D( gl.TEXTURE_2D, 0, gl.RGB, @intCast(c_int, image2.width), @intCast(c_int, image2.height), 0, gl.RGBA, gl.UNSIGNED_BYTE, @ptrCast([*c]const u8, image2.data), ); gl.generateMipmap(gl.TEXTURE_2D); // Enable OpenGL depth testing (use Z-buffer information) gl.enable(gl.DEPTH_TEST); shader_program.use(); shader_program.setInt("texture1", 0); shader_program.setInt("texture2", 1); // Create the transformation matrices: // Degree to radians conversion factor const rad_conversion = math.pi / 180.0; // Buffer to store Model matrix var model: [16]f32 = undefined; // View matrix var view: [16]f32 = undefined; // Buffer to store Orojection matrix (in render loop) var proj: [16]f32 = undefined; while (!window.shouldClose()) { processInput(window); gl.clearColor(0.0, 0.0, 0.0, 0.0); gl.clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT); gl.activeTexture(gl.TEXTURE0); gl.bindTexture(gl.TEXTURE_2D, texture1); gl.activeTexture(gl.TEXTURE1); gl.bindTexture(gl.TEXTURE_2D, texture2); gl.bindVertexArray(VAO); // Projection matrix const projM = x: { var window_size = window.getSize(); var fov = @intToFloat(f32, window_size.width) / @intToFloat(f32, window_size.height); var projM = zm.perspectiveFovRhGl(45.0 * rad_conversion, fov, 0.1, 100.0); break :x projM; }; zm.storeMat(&proj, projM); shader_program.setMat4f("projection", proj); // View matrix: Camera const radius: f32 = 10.0; const camX: f32 = @floatCast(f32, @sin(glfw.getTime())) * radius; const camZ: f32 = @floatCast(f32, @cos(glfw.getTime())) * radius; const viewM = zm.lookAtRh( zm.loadArr3(.{ camX, 0.0, camZ }), zm.loadArr3(.{ 0.0, 0.0, 0.0 }), zm.loadArr3(.{ 0.0, 1.0, 0.0 }), ); zm.storeMat(&view, viewM); shader_program.setMat4f("view", view); for (cube_positions, 0..) |cube_position, i| { // Model matrix const cube_trans = zm.translation(cube_position[0], cube_position[1], cube_position[2]); const rotation_direction = (((@mod(@intToFloat(f32, i + 1), 2.0)) * 2.0) - 1.0); const cube_rot = zm.matFromAxisAngle( zm.f32x4(1.0, 0.3, 0.5, 1.0), @floatCast(f32, glfw.getTime()) * 55.0 * rotation_direction * rad_conversion, ); const modelM = zm.mul(cube_rot, cube_trans); zm.storeMat(&model, modelM); shader_program.setMat4f("model", model); gl.drawArrays(gl.TRIANGLES, 0, 36); } window.swapBuffers(); glfw.pollEvents(); } } fn glGetProcAddress(p: glfw.GLProc, proc: [:0]const u8) ?gl.FunctionPointer { _ = p; return glfw.getProcAddress(proc); } fn framebuffer_size_callback(window: glfw.Window, width: u32, height: u32) void { _ = window; gl.viewport(0, 0, @intCast(c_int, width), @intCast(c_int, height)); } fn processInput(window: glfw.Window) void { if (glfw.Window.getKey(window, glfw.Key.escape) == glfw.Action.press) { _ = glfw.Window.setShouldClose(window, true); } }
0
repos/zig_learn_opengl/src/getting_started
repos/zig_learn_opengl/src/getting_started/camera_rotate/build.zig
const std = @import("std"); const Options = @import("../../../build.zig").Options; inline fn thisDir() []const u8 { return comptime std.fs.path.dirname(@src().file) orelse "."; } const content_dir = "content/"; pub fn build(b: *std.Build, options: Options) *std.build.CompileStep { const exe = b.addExecutable(.{ .name = "camera_rotate", .root_source_file = .{ .path = thisDir() ++ "/main.zig" }, .target = options.target, .optimize = options.build_mode, }); const install_content_step = b.addInstallDirectory(.{ .source_dir = thisDir() ++ "/" ++ content_dir, .install_dir = .{ .custom = "" }, .install_subdir = "bin/" ++ content_dir, }); exe.step.dependOn(&install_content_step.step); return exe; }
0
repos/zig_learn_opengl/src/getting_started/camera_rotate
repos/zig_learn_opengl/src/getting_started/camera_rotate/content/shader.fs
#version 330 core out vec4 FragColor; in vec2 texCoord; uniform sampler2D texture1; uniform sampler2D texture2; void main() { FragColor = mix(texture(texture1, texCoord),texture(texture2, texCoord), 0.5f); };
0
repos/zig_learn_opengl/src/getting_started/camera_rotate
repos/zig_learn_opengl/src/getting_started/camera_rotate/content/shader.vs
#version 330 core layout (location = 0) in vec3 aPos; layout (location = 1) in vec2 aTexCoord; out vec2 texCoord; uniform mat4 model; uniform mat4 view; uniform mat4 projection; void main() { gl_Position = projection * view * model * vec4(aPos, 1.0f); texCoord = aTexCoord; }
0
repos/zig_learn_opengl/src/getting_started
repos/zig_learn_opengl/src/getting_started/shaders/main.zig
const std = @import("std"); const glfw = @import("glfw"); const gl = @import("gl"); const Shader = @import("Shader"); const WindowSize = struct { pub const width: u32 = 800; pub const height: u32 = 600; }; pub fn main() !void { // glfw: initialize and configure // ------------------------------ if (!glfw.init(.{})) { std.log.err("GLFW initialization failed", .{}); return; } defer glfw.terminate(); // glfw window creation // -------------------- const window = glfw.Window.create(WindowSize.width, WindowSize.height, "mach-glfw + zig-opengl", null, null, .{ .opengl_profile = .opengl_core_profile, .context_version_major = 4, .context_version_minor = 1, }) orelse { std.log.err("GLFW Window creation failed", .{}); return; }; defer window.destroy(); glfw.makeContextCurrent(window); glfw.Window.setFramebufferSizeCallback(window, framebuffer_size_callback); // Load all OpenGL function pointers // --------------------------------------- const proc: glfw.GLProc = undefined; try gl.load(proc, glGetProcAddress); var gpa = std.heap.GeneralPurposeAllocator(.{}){}; var allocator = gpa.allocator(); var arena_allocator_state = std.heap.ArenaAllocator.init(allocator); defer arena_allocator_state.deinit(); const arena_allocator = arena_allocator_state.allocator(); // create shader program var shader_program: Shader = Shader.create(arena_allocator, "shaders/shader_ex3.vs", "shaders/shader_ex3.fs"); // set up vertex data (and buffer(s)) and configure vertex attributes // ------------------------------------------------------------------ const vertices = [_]f32{ -0.5, -0.5, 0.0, 1.0, 0.0, 0.0, 0.5, -0.5, 0.0, 0.0, 1.0, 0.0, 0.0, 0.5, 0.0, 0.0, 0.0, 1.0, }; var VBO: c_uint = undefined; var VAO: c_uint = undefined; gl.genVertexArrays(1, &VAO); defer gl.deleteVertexArrays(1, &VAO); gl.genBuffers(1, &VBO); defer gl.deleteBuffers(1, &VBO); // bind the Vertex Array Object first, then bind and set vertex buffer(s), and then configure vertex attributes(s). gl.bindVertexArray(VAO); gl.bindBuffer(gl.ARRAY_BUFFER, VBO); // Fill our buffer with the vertex data gl.bufferData(gl.ARRAY_BUFFER, @sizeOf(f32) * vertices.len, &vertices, gl.STATIC_DRAW); // Specify and link our vertext attribute description gl.vertexAttribPointer(0, 3, gl.FLOAT, gl.FALSE, 6 * @sizeOf(f32), null); gl.enableVertexAttribArray(0); const offset: [*c]c_uint = (3 * @sizeOf(f32)); gl.vertexAttribPointer(1, 3, gl.FLOAT, gl.FALSE, 6 * @sizeOf(f32), offset); gl.enableVertexAttribArray(1); while (!window.shouldClose()) { processInput(window); gl.clearColor(0.0, 0.0, 0.0, 0.0); gl.clear(gl.COLOR_BUFFER_BIT); // update the uniform color const timeValue = glfw.getTime(); const offsetValue = @floatCast(f32, @sin(timeValue * 2) / 2.0 + 0.5); shader_program.setVec3f("offset", [3]f32{ offsetValue, offsetValue, offsetValue }); shader_program.use(); gl.bindVertexArray(VAO); gl.drawArrays(gl.TRIANGLES, 0, 3); window.swapBuffers(); glfw.pollEvents(); } } fn glGetProcAddress(p: glfw.GLProc, proc: [:0]const u8) ?gl.FunctionPointer { _ = p; return glfw.getProcAddress(proc); } fn framebuffer_size_callback(window: glfw.Window, width: u32, height: u32) void { _ = window; gl.viewport(0, 0, @intCast(c_int, width), @intCast(c_int, height)); } fn processInput(window: glfw.Window) void { if (glfw.Window.getKey(window, glfw.Key.escape) == glfw.Action.press) { _ = glfw.Window.setShouldClose(window, true); } }
0
repos/zig_learn_opengl/src/getting_started
repos/zig_learn_opengl/src/getting_started/shaders/build.zig
const std = @import("std"); const Options = @import("../../../build.zig").Options; inline fn thisDir() []const u8 { return comptime std.fs.path.dirname(@src().file) orelse "."; } const content_dir = "shaders/"; pub fn build(b: *std.Build, options: Options) *std.build.CompileStep { const exe = b.addExecutable(.{ .name = "shaders", .root_source_file = .{ .path = thisDir() ++ "/main.zig" }, .target = options.target, .optimize = options.build_mode, }); const install_content_step = b.addInstallDirectory(.{ .source_dir = thisDir() ++ "/" ++ content_dir, .install_dir = .{ .custom = "" }, .install_subdir = "bin/" ++ content_dir, }); exe.step.dependOn(&install_content_step.step); return exe; }
0
repos/zig_learn_opengl/src/getting_started/shaders
repos/zig_learn_opengl/src/getting_started/shaders/shaders/shader_ex3.fs
#version 330 core out vec4 FragColor; in vec3 ourColor; in vec3 vertPos; void main() { FragColor = vec4(vertPos, 1.0); };
0
repos/zig_learn_opengl/src/getting_started/shaders
repos/zig_learn_opengl/src/getting_started/shaders/shaders/shader.fs
#version 330 core out vec4 FragColor; in vec3 ourColor; void main() { FragColor = vec4(ourColor, 0.5); };
0
repos/zig_learn_opengl/src/getting_started/shaders
repos/zig_learn_opengl/src/getting_started/shaders/shaders/shader_ex3.vs
#version 330 core layout (location = 0) in vec3 aPos; layout (location = 1) in vec3 aColor; uniform vec3 offset; out vec3 ourColor; out vec3 vertPos; void main() { gl_Position = vec4(aPos * offset, 1.0f); ourColor = aColor; vertPos = aPos + offset; }
0
repos/zig_learn_opengl/src/getting_started/shaders
repos/zig_learn_opengl/src/getting_started/shaders/shaders/shader.vs
#version 330 core layout (location = 0) in vec3 aPos; layout (location = 1) in vec3 aColor; uniform vec3 offset; out vec3 ourColor; void main() { gl_Position = vec4(aPos + offset, 1.0f); ourColor = aColor; }
0
repos/zig_learn_opengl/src/getting_started
repos/zig_learn_opengl/src/getting_started/simple_camera/main.zig
const std = @import("std"); const math = std.math; const glfw = @import("glfw"); const zstbi = @import("zstbi"); const zm = @import("zmath"); const gl = @import("gl"); const Shader = @import("Shader"); const Camera = @import("Camera"); const common = @import("common"); // Camera const camera_pos = zm.loadArr3(.{ 0.0, 0.0, 5.0 }); var lastX: f64 = 0.0; var lastY: f64 = 0.0; var first_mouse = true; var camera = Camera.camera(camera_pos); // Timing var delta_time: f32 = 0.0; var last_frame: f32 = 0.0; const WindowSize = struct { pub const width: u32 = 800; pub const height: u32 = 600; }; pub fn main() !void { // glfw: initialize and configure // ------------------------------ if (!glfw.init(.{})) { std.log.err("GLFW initialization failed", .{}); return; } defer glfw.terminate(); // glfw window creation // -------------------- const window = glfw.Window.create(WindowSize.width, WindowSize.height, "mach-glfw + zig-opengl", null, null, .{ .opengl_profile = .opengl_core_profile, .context_version_major = 4, .context_version_minor = 1, }) orelse { std.log.err("GLFW Window creation failed", .{}); return; }; defer window.destroy(); glfw.makeContextCurrent(window); glfw.Window.setFramebufferSizeCallback(window, framebuffer_size_callback); // Capture mouse, disable cursor visibility glfw.Window.setInputMode(window, glfw.Window.InputMode.cursor, glfw.Window.InputModeCursor.disabled); glfw.Window.setCursorPosCallback(window, mouseCallback); glfw.Window.setScrollCallback(window, mouseScrollCallback); // Load all OpenGL function pointers // --------------------------------------- const proc: glfw.GLProc = undefined; try gl.load(proc, glGetProcAddress); var gpa = std.heap.GeneralPurposeAllocator(.{}){}; var allocator = gpa.allocator(); var arena_allocator_state = std.heap.ArenaAllocator.init(allocator); defer arena_allocator_state.deinit(); const arena = arena_allocator_state.allocator(); // create shader program var shader_program: Shader = Shader.create(arena, "content/shader.vs", "content/shader.fs"); // set up vertex data (and buffer(s)) and configure vertex attributes // ------------------------------------------------------------------ const vertices_2D = [_]f32{ // positions // colors // texture coords 0.5, 0.5, 0.0, 1.0, 0.0, 0.0, 1.0, 1.0, // top right 0.5, -0.5, 0.0, 0.0, 1.0, 0.0, 1.0, 0.0, // bottom right -0.5, -0.5, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, // bottom left -0.5, 0.5, 0.0, 1.0, 1.0, 0.0, 0.0, 1.0, // top left }; _ = vertices_2D; const vertices_3D = [_]f32{ -0.5, -0.5, -0.5, 0.0, 0.0, 0.5, -0.5, -0.5, 1.0, 0.0, 0.5, 0.5, -0.5, 1.0, 1.0, 0.5, 0.5, -0.5, 1.0, 1.0, -0.5, 0.5, -0.5, 0.0, 1.0, -0.5, -0.5, -0.5, 0.0, 0.0, -0.5, -0.5, 0.5, 0.0, 0.0, 0.5, -0.5, 0.5, 1.0, 0.0, 0.5, 0.5, 0.5, 1.0, 1.0, 0.5, 0.5, 0.5, 1.0, 1.0, -0.5, 0.5, 0.5, 0.0, 1.0, -0.5, -0.5, 0.5, 0.0, 0.0, -0.5, 0.5, 0.5, 1.0, 0.0, -0.5, 0.5, -0.5, 1.0, 1.0, -0.5, -0.5, -0.5, 0.0, 1.0, -0.5, -0.5, -0.5, 0.0, 1.0, -0.5, -0.5, 0.5, 0.0, 0.0, -0.5, 0.5, 0.5, 1.0, 0.0, 0.5, 0.5, 0.5, 1.0, 0.0, 0.5, 0.5, -0.5, 1.0, 1.0, 0.5, -0.5, -0.5, 0.0, 1.0, 0.5, -0.5, -0.5, 0.0, 1.0, 0.5, -0.5, 0.5, 0.0, 0.0, 0.5, 0.5, 0.5, 1.0, 0.0, -0.5, -0.5, -0.5, 0.0, 1.0, 0.5, -0.5, -0.5, 1.0, 1.0, 0.5, -0.5, 0.5, 1.0, 0.0, 0.5, -0.5, 0.5, 1.0, 0.0, -0.5, -0.5, 0.5, 0.0, 0.0, -0.5, -0.5, -0.5, 0.0, 1.0, -0.5, 0.5, -0.5, 0.0, 1.0, 0.5, 0.5, -0.5, 1.0, 1.0, 0.5, 0.5, 0.5, 1.0, 0.0, 0.5, 0.5, 0.5, 1.0, 0.0, -0.5, 0.5, 0.5, 0.0, 0.0, -0.5, 0.5, -0.5, 0.0, 1.0 }; const cube_positions = [_][3]f32{ .{ 0.0, 0.0, 0.0 }, .{ 2.0, 5.0, -15.0 }, .{ -1.5, -2.2, -2.5 }, .{ -3.8, -2.0, -12.3 }, .{ 2.4, -0.4, -3.5 }, .{ -1.7, 3.0, -7.5 }, .{ 1.3, -2.0, -2.5 }, .{ 1.5, 2.0, -2.5 }, .{ 1.5, 0.2, -1.5 }, .{ -1.3, 1.0, -1.5 } }; var VBO: c_uint = undefined; var VAO: c_uint = undefined; gl.genVertexArrays(1, &VAO); defer gl.deleteVertexArrays(1, &VAO); gl.genBuffers(1, &VBO); defer gl.deleteBuffers(1, &VBO); // bind the Vertex Array Object first, then bind and set vertex buffer(s), and then configure vertex attributes(s). gl.bindVertexArray(VAO); gl.bindBuffer(gl.ARRAY_BUFFER, VBO); // Fill our buffer with the vertex data gl.bufferData(gl.ARRAY_BUFFER, @sizeOf(f32) * vertices_3D.len, &vertices_3D, gl.STATIC_DRAW); // vertex gl.vertexAttribPointer(0, 3, gl.FLOAT, gl.FALSE, 5 * @sizeOf(f32), null); gl.enableVertexAttribArray(0); // texture coords const tex_offset: [*c]c_uint = (3 * @sizeOf(f32)); gl.vertexAttribPointer(1, 2, gl.FLOAT, gl.FALSE, 5 * @sizeOf(f32), tex_offset); gl.enableVertexAttribArray(1); // zstbi: loading an image. zstbi.init(allocator); defer zstbi.deinit(); const image1_path = common.pathToContent(arena, "content/container.jpg") catch unreachable; var image1 = try zstbi.Image.init(&image1_path, 0); defer image1.deinit(); std.debug.print("\nImage 1 info:\n\n img width: {any}\n img height: {any}\n nchannels: {any}\n", .{ image1.width, image1.height, image1.num_components }); zstbi.setFlipVerticallyOnLoad(true); const image2_path = common.pathToContent(arena, "content/awesomeface.png") catch unreachable; var image2 = try zstbi.Image.init(&image2_path, 0); defer image2.deinit(); std.debug.print("\nImage 2 info:\n\n img width: {any}\n img height: {any}\n nchannels: {any}\n", .{ image2.width, image2.height, image2.num_components }); // Create and bind texture1 resource var texture1: c_uint = undefined; gl.genTextures(1, &texture1); gl.activeTexture(gl.TEXTURE0); // activate the texture unit first before binding texture gl.bindTexture(gl.TEXTURE_2D, texture1); // set the texture1 wrapping parameters gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.REPEAT); // set texture wrapping to GL_REPEAT (default wrapping method) gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.REPEAT); // set texture1 filtering parameters gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR_MIPMAP_LINEAR); gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR); // Generate the texture1 gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGB, @intCast(c_int, image1.width), @intCast(c_int, image1.height), 0, gl.RGB, gl.UNSIGNED_BYTE, @ptrCast([*c]const u8, image1.data)); gl.generateMipmap(gl.TEXTURE_2D); // Texture2 var texture2: c_uint = undefined; gl.genTextures(1, &texture2); gl.activeTexture(gl.TEXTURE1); // activate the texture unit first before binding texture gl.bindTexture(gl.TEXTURE_2D, texture2); // set the texture1 wrapping parameters gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.REPEAT); // set texture wrapping to GL_REPEAT (default wrapping method) gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.REPEAT); // set texture1 filtering parameters gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR_MIPMAP_LINEAR); gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR); // Generate the texture1 gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGB, @intCast(c_int, image2.width), @intCast(c_int, image2.height), 0, gl.RGBA, gl.UNSIGNED_BYTE, @ptrCast([*c]const u8, image2.data)); gl.generateMipmap(gl.TEXTURE_2D); // Enable OpenGL depth testing (use Z-buffer information) gl.enable(gl.DEPTH_TEST); shader_program.use(); shader_program.setInt("texture1", 0); shader_program.setInt("texture2", 1); // Buffer to store Model matrix var model: [16]f32 = undefined; // View matrix var view: [16]f32 = undefined; // Buffer to store Orojection matrix (in render loop) var proj: [16]f32 = undefined; while (!window.shouldClose()) { // Time per frame const current_frame = @floatCast(f32, glfw.getTime()); delta_time = current_frame - last_frame; last_frame = current_frame; processInput(window); gl.clearColor(0.0, 0.0, 0.0, 0.0); gl.clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT); gl.activeTexture(gl.TEXTURE0); gl.bindTexture(gl.TEXTURE_2D, texture1); gl.activeTexture(gl.TEXTURE1); gl.bindTexture(gl.TEXTURE_2D, texture2); gl.bindVertexArray(VAO); // Projection matrix const projM = x: { const window_size = window.getSize(); const aspect = @intToFloat(f32, window_size.width) / @intToFloat(f32, window_size.height); var projM = zm.perspectiveFovRhGl(camera.zoom * common.RAD_CONVERSION, aspect, 0.1, 100.0); break :x projM; }; zm.storeMat(&proj, projM); shader_program.setMat4f("projection", proj); // View matrix: Camera const viewM = camera.getViewMatrix(); zm.storeMat(&view, viewM); shader_program.setMat4f("view", view); for (cube_positions, 0..) |cube_position, i| { // Model matrix const cube_trans = zm.translation(cube_position[0], cube_position[1], cube_position[2]); const rotation_direction = (((@mod(@intToFloat(f32, i + 1), 2.0)) * 2.0) - 1.0); const cube_rot = zm.matFromAxisAngle(zm.f32x4(1.0, 0.3, 0.5, 1.0), @floatCast(f32, glfw.getTime()) * 55.0 * rotation_direction * common.RAD_CONVERSION); const modelM = zm.mul(cube_rot, cube_trans); zm.storeMat(&model, modelM); shader_program.setMat4f("model", model); gl.drawArrays(gl.TRIANGLES, 0, 36); } window.swapBuffers(); glfw.pollEvents(); } } fn glGetProcAddress(p: glfw.GLProc, proc: [:0]const u8) ?gl.FunctionPointer { _ = p; return glfw.getProcAddress(proc); } fn framebuffer_size_callback(window: glfw.Window, width: u32, height: u32) void { _ = window; gl.viewport(0, 0, @intCast(c_int, width), @intCast(c_int, height)); } fn processInput(window: glfw.Window) void { if (glfw.Window.getKey(window, glfw.Key.escape) == glfw.Action.press) { _ = glfw.Window.setShouldClose(window, true); } if (glfw.Window.getKey(window, glfw.Key.w) == glfw.Action.press) { camera.processKeyboard(Camera.CameraMovement.FORWARD, delta_time); } if (glfw.Window.getKey(window, glfw.Key.s) == glfw.Action.press) { camera.processKeyboard(Camera.CameraMovement.BACKWARD, delta_time); } if (glfw.Window.getKey(window, glfw.Key.a) == glfw.Action.press) { camera.processKeyboard(Camera.CameraMovement.LEFT, delta_time); } if (glfw.Window.getKey(window, glfw.Key.d) == glfw.Action.press) { camera.processKeyboard(Camera.CameraMovement.RIGHT, delta_time); } } fn mouseCallback(window: glfw.Window, xpos: f64, ypos: f64) void { _ = window; if (first_mouse) { lastX = xpos; lastY = ypos; first_mouse = false; } var xoffset = xpos - lastX; var yoffset = ypos - lastY; lastX = xpos; lastY = ypos; camera.processMouseMovement(xoffset, yoffset, true); } fn mouseScrollCallback(window: glfw.Window, xoffset: f64, yoffset: f64) void { _ = window; _ = xoffset; camera.processMouseScroll(yoffset); }
0
repos/zig_learn_opengl/src/getting_started
repos/zig_learn_opengl/src/getting_started/simple_camera/build.zig
const std = @import("std"); const Options = @import("../../../build.zig").Options; inline fn thisDir() []const u8 { return comptime std.fs.path.dirname(@src().file) orelse "."; } const content_dir = "content/"; pub fn build(b: *std.build.Builder, options: Options) *std.build.CompileStep { const exe = b.addExecutable(.{ .name = "simple_camera", .root_source_file = .{ .path = thisDir() ++ "/main.zig" }, .target = options.target, .optimize = options.build_mode, }); const install_content_step = b.addInstallDirectory(.{ .source_dir = thisDir() ++ "/" ++ content_dir, .install_dir = .{ .custom = "" }, .install_subdir = "bin/" ++ content_dir, }); exe.step.dependOn(&install_content_step.step); return exe; }
0
repos/zig_learn_opengl/src/getting_started/simple_camera
repos/zig_learn_opengl/src/getting_started/simple_camera/content/shader.fs
#version 330 core out vec4 FragColor; in vec2 texCoord; uniform sampler2D texture1; uniform sampler2D texture2; void main() { FragColor = mix(texture(texture1, texCoord),texture(texture2, texCoord), 0.5f); };
0
repos/zig_learn_opengl/src/getting_started/simple_camera
repos/zig_learn_opengl/src/getting_started/simple_camera/content/shader.vs
#version 330 core layout (location = 0) in vec3 aPos; layout (location = 1) in vec2 aTexCoord; out vec2 texCoord; uniform mat4 model; uniform mat4 view; uniform mat4 projection; void main() { gl_Position = projection * view * model * vec4(aPos, 1.0f); texCoord = aTexCoord; }
0
repos/zig_learn_opengl/src/getting_started
repos/zig_learn_opengl/src/getting_started/textures/main.zig
const std = @import("std"); const glfw = @import("glfw"); const zstbi = @import("zstbi"); const gl = @import("gl"); const Shader = @import("Shader"); const common = @import("common"); const WindowSize = struct { pub const width: u32 = 800; pub const height: u32 = 600; }; pub fn main() !void { // glfw: initialize and configure // ------------------------------ if (!glfw.init(.{})) { std.log.err("GLFW initialization failed", .{}); return; } defer glfw.terminate(); // glfw window creation // -------------------- const window = glfw.Window.create(WindowSize.width, WindowSize.height, "mach-glfw + zig-opengl", null, null, .{ .opengl_profile = .opengl_core_profile, .context_version_major = 4, .context_version_minor = 1, }) orelse { std.log.err("GLFW Window creation failed", .{}); return; }; defer window.destroy(); glfw.makeContextCurrent(window); glfw.Window.setFramebufferSizeCallback(window, framebuffer_size_callback); // Load all OpenGL function pointers // --------------------------------------- const proc: glfw.GLProc = undefined; try gl.load(proc, glGetProcAddress); var gpa = std.heap.GeneralPurposeAllocator(.{}){}; var allocator = gpa.allocator(); var arena_allocator_state = std.heap.ArenaAllocator.init(allocator); defer arena_allocator_state.deinit(); const arena = arena_allocator_state.allocator(); // create shader program var shader_program: Shader = Shader.create( arena, "content/shader.vs", "content/shader.fs", ); // set up vertex data (and buffer(s)) and configure vertex attributes // ------------------------------------------------------------------ const vertices = [_]f32{ // positions // colors // texture coords 0.5, 0.5, 0.0, 1.0, 0.0, 0.0, 1.0, 1.0, // top right 0.5, -0.5, 0.0, 0.0, 1.0, 0.0, 1.0, 0.0, // bottom right -0.5, -0.5, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, // bottom left -0.5, 0.5, 0.0, 1.0, 1.0, 0.0, 0.0, 1.0, // top left }; const indices = [_]c_uint{ // note that we start from 0! 0, 1, 3, // first triangle 1, 2, 3, // second triangle }; var VBO: c_uint = undefined; var VAO: c_uint = undefined; var EBO: c_uint = undefined; gl.genVertexArrays(1, &VAO); defer gl.deleteVertexArrays(1, &VAO); gl.genBuffers(1, &VBO); defer gl.deleteBuffers(1, &VBO); gl.genBuffers(1, &EBO); defer gl.deleteBuffers(1, &EBO); // bind the Vertex Array Object first, then bind and set vertex buffer(s), and then configure vertex attributes(s). gl.bindVertexArray(VAO); gl.bindBuffer(gl.ARRAY_BUFFER, VBO); // Fill our buffer with the vertex data gl.bufferData(gl.ARRAY_BUFFER, @sizeOf(f32) * vertices.len, &vertices, gl.STATIC_DRAW); gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, EBO); gl.bufferData(gl.ELEMENT_ARRAY_BUFFER, 6 * @sizeOf(c_uint), &indices, gl.STATIC_DRAW); // vertex gl.vertexAttribPointer(0, 3, gl.FLOAT, gl.FALSE, 8 * @sizeOf(f32), null); gl.enableVertexAttribArray(0); // colors const col_offset: [*c]c_uint = (3 * @sizeOf(f32)); gl.vertexAttribPointer(1, 3, gl.FLOAT, gl.FALSE, 8 * @sizeOf(f32), col_offset); gl.enableVertexAttribArray(1); // texture coords const tex_offset: [*c]c_uint = (6 * @sizeOf(f32)); gl.vertexAttribPointer(2, 2, gl.FLOAT, gl.FALSE, 8 * @sizeOf(f32), tex_offset); gl.enableVertexAttribArray(2); // zstbi: loading an image. zstbi.init(allocator); defer zstbi.deinit(); const image1_path = common.pathToContent(arena, "content/container.jpg") catch unreachable; var image1 = try zstbi.Image.init(&image1_path, 0); defer image1.deinit(); std.debug.print( "\nImage 1 info:\n\n img width: {any}\n img height: {any}\n nchannels: {any}\n", .{ image1.width, image1.height, image1.num_components }, ); zstbi.setFlipVerticallyOnLoad(true); const image2_path = common.pathToContent(arena, "content/awesomeface.png") catch unreachable; var image2 = try zstbi.Image.init(&image2_path, 0); defer image2.deinit(); std.debug.print( "\nImage 2 info:\n\n img width: {any}\n img height: {any}\n nchannels: {any}\n", .{ image2.width, image2.height, image2.num_components }, ); // Create and bind texture1 resource var texture1: c_uint = undefined; gl.genTextures(1, &texture1); gl.activeTexture(gl.TEXTURE0); // activate the texture unit first before binding texture gl.bindTexture(gl.TEXTURE_2D, texture1); // set the texture1 wrapping parameters gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.REPEAT); // set texture wrapping to GL_REPEAT (default wrapping method) gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.REPEAT); // set texture1 filtering parameters gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR_MIPMAP_LINEAR); gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR); // Generate the texture1 gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGB, @intCast(c_int, image1.width), @intCast(c_int, image1.height), 0, gl.RGB, gl.UNSIGNED_BYTE, @ptrCast([*c]const u8, image1.data)); gl.generateMipmap(gl.TEXTURE_2D); // Texture2 var texture2: c_uint = undefined; gl.genTextures(1, &texture2); gl.activeTexture(gl.TEXTURE1); // activate the texture unit first before binding texture gl.bindTexture(gl.TEXTURE_2D, texture2); // set the texture1 wrapping parameters gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.REPEAT); // set texture wrapping to GL_REPEAT (default wrapping method) gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.REPEAT); // set texture1 filtering parameters gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR_MIPMAP_LINEAR); gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR); // Generate the texture1 gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGB, @intCast(c_int, image2.width), @intCast(c_int, image2.height), 0, gl.RGBA, gl.UNSIGNED_BYTE, @ptrCast([*c]const u8, image2.data)); gl.generateMipmap(gl.TEXTURE_2D); shader_program.use(); shader_program.setInt("texture1", 0); shader_program.setInt("texture2", 1); while (!window.shouldClose()) { processInput(window); gl.clearColor(0.0, 0.0, 0.0, 0.0); gl.clear(gl.COLOR_BUFFER_BIT); gl.activeTexture(gl.TEXTURE0); gl.bindTexture(gl.TEXTURE_2D, texture1); gl.activeTexture(gl.TEXTURE1); gl.bindTexture(gl.TEXTURE_2D, texture2); gl.bindVertexArray(VAO); gl.drawElements(gl.TRIANGLES, 6, gl.UNSIGNED_INT, null); window.swapBuffers(); glfw.pollEvents(); } } fn glGetProcAddress(p: glfw.GLProc, proc: [:0]const u8) ?gl.FunctionPointer { _ = p; return glfw.getProcAddress(proc); } fn framebuffer_size_callback(window: glfw.Window, width: u32, height: u32) void { _ = window; gl.viewport(0, 0, @intCast(c_int, width), @intCast(c_int, height)); } fn processInput(window: glfw.Window) void { if (glfw.Window.getKey(window, glfw.Key.escape) == glfw.Action.press) { _ = glfw.Window.setShouldClose(window, true); } }
0
repos/zig_learn_opengl/src/getting_started
repos/zig_learn_opengl/src/getting_started/textures/build.zig
const std = @import("std"); const Options = @import("../../../build.zig").Options; inline fn thisDir() []const u8 { return comptime std.fs.path.dirname(@src().file) orelse "."; } const content_dir = "content/"; pub fn build(b: *std.Build, options: Options) *std.build.CompileStep { const exe = b.addExecutable(.{ .name = "textures", .root_source_file = .{ .path = thisDir() ++ "/main.zig" }, .target = options.target, .optimize = options.build_mode, }); const install_content_step = b.addInstallDirectory(.{ .source_dir = thisDir() ++ "/" ++ content_dir, .install_dir = .{ .custom = "" }, .install_subdir = "bin/" ++ content_dir, }); exe.step.dependOn(&install_content_step.step); return exe; }
0
repos/zig_learn_opengl/src/getting_started/textures
repos/zig_learn_opengl/src/getting_started/textures/content/shader.fs
#version 330 core out vec4 FragColor; in vec3 ourColor; in vec2 texCoord; uniform sampler2D texture1; uniform sampler2D texture2; void main() { FragColor = mix(texture(texture1, texCoord),texture(texture2, texCoord), 0.5f) * vec4(ourColor, 1.0f); };
0
repos/zig_learn_opengl/src/getting_started/textures
repos/zig_learn_opengl/src/getting_started/textures/content/shader.vs
#version 330 core layout (location = 0) in vec3 aPos; layout (location = 1) in vec3 aColor; layout (location = 2) in vec2 aTexCoord; out vec3 ourColor; out vec2 texCoord; void main() { gl_Position = vec4(aPos, 1.0f); ourColor = aColor; texCoord = aTexCoord; }
0
repos/zig_learn_opengl/src/getting_started
repos/zig_learn_opengl/src/getting_started/coordinate_systems/main.zig
const std = @import("std"); const math = std.math; const glfw = @import("glfw"); const zstbi = @import("zstbi"); const zm = @import("zmath"); const gl = @import("gl"); const Shader = @import("Shader"); const common = @import("common"); const WindowSize = struct { pub const width: u32 = 800; pub const height: u32 = 600; }; pub fn main() !void { // glfw: initialize and configure // ------------------------------ if (!glfw.init(.{})) { std.log.err("GLFW initialization failed", .{}); return; } defer glfw.terminate(); // glfw window creation // -------------------- const window = glfw.Window.create(WindowSize.width, WindowSize.height, "mach-glfw + zig-opengl", null, null, .{ .opengl_profile = .opengl_core_profile, .context_version_major = 4, .context_version_minor = 1, }) orelse { std.log.err("GLFW Window creation failed", .{}); return; }; defer window.destroy(); glfw.makeContextCurrent(window); glfw.Window.setFramebufferSizeCallback(window, framebuffer_size_callback); // Load all OpenGL function pointers // --------------------------------------- const proc: glfw.GLProc = undefined; try gl.load(proc, glGetProcAddress); var gpa = std.heap.GeneralPurposeAllocator(.{}){}; var allocator = gpa.allocator(); var arena_allocator_state = std.heap.ArenaAllocator.init(allocator); defer arena_allocator_state.deinit(); const arena = arena_allocator_state.allocator(); // create shader program var shader_program: Shader = Shader.create(arena, "content/shader.vs", "content/shader.fs"); // set up vertex data (and buffer(s)) and configure vertex attributes // ------------------------------------------------------------------ const vertices_2D = [_]f32{ // positions // colors // texture coords 0.5, 0.5, 0.0, 1.0, 0.0, 0.0, 1.0, 1.0, // top right 0.5, -0.5, 0.0, 0.0, 1.0, 0.0, 1.0, 0.0, // bottom right -0.5, -0.5, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, // bottom left -0.5, 0.5, 0.0, 1.0, 1.0, 0.0, 0.0, 1.0, // top left }; _ = vertices_2D; const vertices_3D = [_]f32{ -0.5, -0.5, -0.5, 0.0, 0.0, 0.5, -0.5, -0.5, 1.0, 0.0, 0.5, 0.5, -0.5, 1.0, 1.0, 0.5, 0.5, -0.5, 1.0, 1.0, -0.5, 0.5, -0.5, 0.0, 1.0, -0.5, -0.5, -0.5, 0.0, 0.0, -0.5, -0.5, 0.5, 0.0, 0.0, 0.5, -0.5, 0.5, 1.0, 0.0, 0.5, 0.5, 0.5, 1.0, 1.0, 0.5, 0.5, 0.5, 1.0, 1.0, -0.5, 0.5, 0.5, 0.0, 1.0, -0.5, -0.5, 0.5, 0.0, 0.0, -0.5, 0.5, 0.5, 1.0, 0.0, -0.5, 0.5, -0.5, 1.0, 1.0, -0.5, -0.5, -0.5, 0.0, 1.0, -0.5, -0.5, -0.5, 0.0, 1.0, -0.5, -0.5, 0.5, 0.0, 0.0, -0.5, 0.5, 0.5, 1.0, 0.0, 0.5, 0.5, 0.5, 1.0, 0.0, 0.5, 0.5, -0.5, 1.0, 1.0, 0.5, -0.5, -0.5, 0.0, 1.0, 0.5, -0.5, -0.5, 0.0, 1.0, 0.5, -0.5, 0.5, 0.0, 0.0, 0.5, 0.5, 0.5, 1.0, 0.0, -0.5, -0.5, -0.5, 0.0, 1.0, 0.5, -0.5, -0.5, 1.0, 1.0, 0.5, -0.5, 0.5, 1.0, 0.0, 0.5, -0.5, 0.5, 1.0, 0.0, -0.5, -0.5, 0.5, 0.0, 0.0, -0.5, -0.5, -0.5, 0.0, 1.0, -0.5, 0.5, -0.5, 0.0, 1.0, 0.5, 0.5, -0.5, 1.0, 1.0, 0.5, 0.5, 0.5, 1.0, 0.0, 0.5, 0.5, 0.5, 1.0, 0.0, -0.5, 0.5, 0.5, 0.0, 0.0, -0.5, 0.5, -0.5, 0.0, 1.0, }; const cube_positions = [_][3]f32{ .{ 0.0, 0.0, 0.0 }, .{ 2.0, 5.0, -15.0 }, .{ -1.5, -2.2, -2.5 }, .{ -3.8, -2.0, -12.3 }, .{ 2.4, -0.4, -3.5 }, .{ -1.7, 3.0, -7.5 }, .{ 1.3, -2.0, -2.5 }, .{ 1.5, 2.0, -2.5 }, .{ 1.5, 0.2, -1.5 }, .{ -1.3, 1.0, -1.5 }, }; var VBO: c_uint = undefined; var VAO: c_uint = undefined; gl.genVertexArrays(1, &VAO); defer gl.deleteVertexArrays(1, &VAO); gl.genBuffers(1, &VBO); defer gl.deleteBuffers(1, &VBO); // bind the Vertex Array Object first, then bind and set vertex buffer(s), and then configure vertex attributes(s). gl.bindVertexArray(VAO); gl.bindBuffer(gl.ARRAY_BUFFER, VBO); // Fill our buffer with the vertex data gl.bufferData(gl.ARRAY_BUFFER, @sizeOf(f32) * vertices_3D.len, &vertices_3D, gl.STATIC_DRAW); // vertex gl.vertexAttribPointer(0, 3, gl.FLOAT, gl.FALSE, 5 * @sizeOf(f32), null); gl.enableVertexAttribArray(0); // texture coords const tex_offset: [*c]c_uint = (3 * @sizeOf(f32)); gl.vertexAttribPointer(1, 2, gl.FLOAT, gl.FALSE, 5 * @sizeOf(f32), tex_offset); gl.enableVertexAttribArray(1); // zstbi: loading an image. zstbi.init(allocator); defer zstbi.deinit(); const image1_path = common.pathToContent(arena, "content/container.jpg") catch unreachable; var image1 = try zstbi.Image.init(&image1_path, 0); defer image1.deinit(); std.debug.print("\nImage 1 info:\n\n img width: {any}\n img height: {any}\n nchannels: {any}\n", .{ image1.width, image1.height, image1.num_components }); zstbi.setFlipVerticallyOnLoad(true); const image2_path = common.pathToContent(arena, "content/awesomeface.png") catch unreachable; var image2 = try zstbi.Image.init(&image2_path, 0); defer image2.deinit(); std.debug.print("\nImage 2 info:\n\n img width: {any}\n img height: {any}\n nchannels: {any}\n", .{ image2.width, image2.height, image2.num_components }); // Create and bind texture1 resource var texture1: c_uint = undefined; gl.genTextures(1, &texture1); gl.activeTexture(gl.TEXTURE0); // activate the texture unit first before binding texture gl.bindTexture(gl.TEXTURE_2D, texture1); // set the texture1 wrapping parameters gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.REPEAT); // set texture wrapping to GL_REPEAT (default wrapping method) gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.REPEAT); // set texture1 filtering parameters gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR_MIPMAP_LINEAR); gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR); // Generate the texture1 gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGB, @intCast(c_int, image1.width), @intCast(c_int, image1.height), 0, gl.RGB, gl.UNSIGNED_BYTE, @ptrCast([*c]const u8, image1.data)); gl.generateMipmap(gl.TEXTURE_2D); // Texture2 var texture2: c_uint = undefined; gl.genTextures(1, &texture2); gl.activeTexture(gl.TEXTURE1); // activate the texture unit first before binding texture gl.bindTexture(gl.TEXTURE_2D, texture2); // set the texture1 wrapping parameters gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.REPEAT); // set texture wrapping to GL_REPEAT (default wrapping method) gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.REPEAT); // set texture1 filtering parameters gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR_MIPMAP_LINEAR); gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR); // Generate the texture1 gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGB, @intCast(c_int, image2.width), @intCast(c_int, image2.height), 0, gl.RGBA, gl.UNSIGNED_BYTE, @ptrCast([*c]const u8, image2.data)); gl.generateMipmap(gl.TEXTURE_2D); // Enable OpenGL depth testing (use Z-buffer information) gl.enable(gl.DEPTH_TEST); shader_program.use(); shader_program.setInt("texture1", 0); shader_program.setInt("texture2", 1); // Create the transformation matrices: // Degree to radians conversion factor const rad_conversion = math.pi / 180.0; // Buffer to store Model matrix var model: [16]f32 = undefined; // View matrix const viewM = zm.translation(0.0, 0.0, -5.0); var view: [16]f32 = undefined; zm.storeMat(&view, viewM); shader_program.setMat4f("view", view); // Buffer to store Orojection matrix (in render loop) var proj: [16]f32 = undefined; while (!window.shouldClose()) { processInput(window); gl.clearColor(0.0, 0.0, 0.0, 0.0); gl.clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT); gl.activeTexture(gl.TEXTURE0); gl.bindTexture(gl.TEXTURE_2D, texture1); gl.activeTexture(gl.TEXTURE1); gl.bindTexture(gl.TEXTURE_2D, texture2); gl.bindVertexArray(VAO); // Projection matrix const projM = x: { var window_size = window.getSize(); var fov = @intToFloat(f32, window_size.width) / @intToFloat(f32, window_size.height); var projM = zm.perspectiveFovRhGl(45.0 * rad_conversion, fov, 0.1, 100.0); break :x projM; }; zm.storeMat(&proj, projM); shader_program.setMat4f("projection", proj); for (cube_positions, 0..) |cube_position, i| { const cube_trans = zm.translation(cube_position[0], cube_position[1], cube_position[2]); const rotation_direction = (((@mod(@intToFloat(f32, i + 1), 2.0)) * 2.0) - 1.0); const cube_rot = zm.matFromAxisAngle( zm.f32x4(1.0, 0.3, 0.5, 1.0), @floatCast(f32, glfw.getTime()) * 55.0 * rotation_direction * rad_conversion, ); const modelM = zm.mul(cube_rot, cube_trans); zm.storeMat(&model, modelM); shader_program.setMat4f("model", model); gl.drawArrays(gl.TRIANGLES, 0, 36); } window.swapBuffers(); glfw.pollEvents(); } } fn glGetProcAddress(p: glfw.GLProc, proc: [:0]const u8) ?gl.FunctionPointer { _ = p; return glfw.getProcAddress(proc); } fn framebuffer_size_callback(window: glfw.Window, width: u32, height: u32) void { _ = window; gl.viewport(0, 0, @intCast(c_int, width), @intCast(c_int, height)); } fn processInput(window: glfw.Window) void { if (glfw.Window.getKey(window, glfw.Key.escape) == glfw.Action.press) { _ = glfw.Window.setShouldClose(window, true); } }
0
repos/zig_learn_opengl/src/getting_started
repos/zig_learn_opengl/src/getting_started/coordinate_systems/build.zig
const std = @import("std"); const Options = @import("../../../build.zig").Options; inline fn thisDir() []const u8 { return comptime std.fs.path.dirname(@src().file) orelse "."; } const content_dir = "content/"; pub fn build(b: *std.Build, options: Options) *std.build.CompileStep { const exe = b.addExecutable(.{ .name = "coordinate_system", .root_source_file = .{ .path = thisDir() ++ "/main.zig" }, .target = options.target, .optimize = options.build_mode, }); const install_content_step = b.addInstallDirectory(.{ .source_dir = thisDir() ++ "/" ++ content_dir, .install_dir = .{ .custom = "" }, .install_subdir = "bin/" ++ content_dir, }); exe.step.dependOn(&install_content_step.step); return exe; }
0
repos/zig_learn_opengl/src/getting_started/coordinate_systems
repos/zig_learn_opengl/src/getting_started/coordinate_systems/content/shader.fs
#version 330 core out vec4 FragColor; in vec2 texCoord; uniform sampler2D texture1; uniform sampler2D texture2; void main() { FragColor = mix(texture(texture1, texCoord),texture(texture2, texCoord), 0.5f); };
0
repos/zig_learn_opengl/src/getting_started/coordinate_systems
repos/zig_learn_opengl/src/getting_started/coordinate_systems/content/shader.vs
#version 330 core layout (location = 0) in vec3 aPos; layout (location = 1) in vec2 aTexCoord; out vec2 texCoord; uniform mat4 model; uniform mat4 view; uniform mat4 projection; void main() { gl_Position = projection * view * model * vec4(aPos, 1.0f); texCoord = aTexCoord; }
0
repos/zig_learn_opengl/src/getting_started
repos/zig_learn_opengl/src/getting_started/hello_rectangle/main.zig
const std = @import("std"); const glfw = @import("glfw"); const gl = @import("gl"); const vertexShaderSource = \\ #version 410 core \\ layout (location = 0) in vec3 aPos; \\ void main() \\ { \\ gl_Position = vec4(aPos.x, aPos.y, aPos.z, 1.0); \\ } ; const fragmentShaderSource = \\ #version 410 core \\ out vec4 FragColor; \\ void main() { \\ FragColor = vec4(1.0, 0.5, 0.2, 1.0); \\ } ; const WindowSize = struct { pub const width: u32 = 800; pub const height: u32 = 600; }; pub fn main() !void { // glfw: initialize and configure // ------------------------------ if (!glfw.init(.{})) { std.log.err("GLFW initialization failed", .{}); return; } defer glfw.terminate(); // glfw window creation // -------------------- const window = glfw.Window.create(WindowSize.width, WindowSize.height, "mach-glfw + zig-opengl", null, null, .{ .opengl_profile = .opengl_core_profile, .context_version_major = 4, .context_version_minor = 1, }) orelse { std.log.err("GLFW Window creation failed", .{}); return; }; defer window.destroy(); glfw.makeContextCurrent(window); glfw.Window.setFramebufferSizeCallback(window, framebuffer_size_callback); // Load all OpenGL function pointers // --------------------------------------- const proc: glfw.GLProc = undefined; try gl.load(proc, glGetProcAddress); // Create vertex shader var vertexShader: c_uint = undefined; vertexShader = gl.createShader(gl.VERTEX_SHADER); defer gl.deleteShader(vertexShader); // Attach the shader source to the vertex shader object and compile it gl.shaderSource(vertexShader, 1, @ptrCast([*c]const [*c]const u8, &vertexShaderSource), 0); gl.compileShader(vertexShader); // Check if vertex shader was compiled successfully var success: c_int = undefined; var infoLog: [512]u8 = [_]u8{0} ** 512; gl.getShaderiv(vertexShader, gl.COMPILE_STATUS, &success); if (success == 0) { gl.getShaderInfoLog(vertexShader, 512, 0, &infoLog); std.log.err("{s}", .{infoLog}); } // Fragment shader var fragmentShader: c_uint = undefined; fragmentShader = gl.createShader(gl.FRAGMENT_SHADER); defer gl.deleteShader(fragmentShader); gl.shaderSource(fragmentShader, 1, @ptrCast([*c]const [*c]const u8, &fragmentShaderSource), 0); gl.compileShader(fragmentShader); gl.getShaderiv(fragmentShader, gl.COMPILE_STATUS, &success); if (success == 0) { gl.getShaderInfoLog(fragmentShader, 512, 0, &infoLog); std.log.err("{s}", .{infoLog}); } // create a program object var shaderProgram: c_uint = undefined; shaderProgram = gl.createProgram(); defer gl.deleteProgram(shaderProgram); // attach compiled shader objects to the program object and link gl.attachShader(shaderProgram, vertexShader); gl.attachShader(shaderProgram, fragmentShader); gl.linkProgram(shaderProgram); // check if shader linking was successfull gl.getProgramiv(shaderProgram, gl.LINK_STATUS, &success); if (success == 0) { gl.getProgramInfoLog(shaderProgram, 512, 0, &infoLog); std.log.err("{s}", .{infoLog}); } // set up vertex data (and buffer(s)) and configure vertex attributes // ------------------------------------------------------------------ // const vertices = [9]f32{ -0.5, -0.5, 0.0, 0.5, -0.5, 0.0, 0.0, 0.5, 0.0 }; const vertices = [12]f32{ 0.5, 0.5, 0.0, // top right 0.5, -0.5, 0.0, // bottom right -0.5, -0.5, 0.0, // bottom left -0.5, 0.5, 0.0, // top left }; const indices = [6]c_uint{ // note that we start from 0! 0, 1, 3, // first triangle 1, 2, 3, // second triangle }; var VBO: c_uint = undefined; var VAO: c_uint = undefined; var EBO: c_uint = undefined; gl.genVertexArrays(1, &VAO); defer gl.deleteVertexArrays(1, &VAO); gl.genBuffers(1, &VBO); defer gl.deleteBuffers(1, &VBO); gl.genBuffers(1, &EBO); defer gl.deleteBuffers(1, &EBO); // bind the Vertex Array Object first, then bind and set vertex buffer(s), and then configure vertex attributes(s). gl.bindVertexArray(VAO); gl.bindBuffer(gl.ARRAY_BUFFER, VBO); // Fill our buffer with the vertex data gl.bufferData(gl.ARRAY_BUFFER, @sizeOf(f32) * vertices.len, &vertices, gl.STATIC_DRAW); // copy our index array in an element buffer for OpenGL to use gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, EBO); gl.bufferData(gl.ELEMENT_ARRAY_BUFFER, 6 * @sizeOf(c_uint), &indices, gl.STATIC_DRAW); // Specify and link our vertext attribute description gl.vertexAttribPointer(0, 3, gl.FLOAT, gl.FALSE, 3 * @sizeOf(f32), null); gl.enableVertexAttribArray(0); // note that this is allowed, the call to glVertexAttribPointer registered VBO as the vertex attribute's bound vertex buffer object so afterwards we can safely unbind gl.bindBuffer(gl.ARRAY_BUFFER, 0); // You can unbind the VAO afterwards so other VAO calls won't accidentally modify this VAO, but this rarely happens. Modifying other // VAOs requires a call to glBindVertexArray anyways so we generally don't unbind VAOs (nor VBOs) when it's not directly necessary. gl.bindVertexArray(0); gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, 0); // Wireframe mode gl.polygonMode(gl.FRONT_AND_BACK, gl.LINE); while (!window.shouldClose()) { processInput(window); gl.clearColor(0.2, 0.3, 0.3, 1.0); gl.clear(gl.COLOR_BUFFER_BIT); // Activate shaderProgram gl.useProgram(shaderProgram); gl.bindVertexArray(VAO); // seeing as we only have a single VAO there's no need to bind it every time, but we'll do so to keep things a bit more organized gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, EBO); gl.drawElements(gl.TRIANGLES, 6, gl.UNSIGNED_INT, null); gl.bindVertexArray(0); window.swapBuffers(); glfw.pollEvents(); } } fn glGetProcAddress(p: glfw.GLProc, proc: [:0]const u8) ?gl.FunctionPointer { _ = p; return glfw.getProcAddress(proc); } fn framebuffer_size_callback(window: glfw.Window, width: u32, height: u32) void { _ = window; gl.viewport(0, 0, @intCast(c_int, width), @intCast(c_int, height)); } fn processInput(window: glfw.Window) void { if (glfw.Window.getKey(window, glfw.Key.escape) == glfw.Action.press) { _ = glfw.Window.setShouldClose(window, true); } }
0
repos/zig_learn_opengl/src/getting_started
repos/zig_learn_opengl/src/getting_started/hello_rectangle/README.md
# Indexed drawing of a rectangle with Element Buffer Objects (EBO) aka (index buffer). From [Hello Triangle](https://learnopengl.com/Getting-started/Hello-Triangle) chapter: Element Buffer Objects section. ![wireframe rectangle](image.png)
0
repos/zig_learn_opengl/src/getting_started
repos/zig_learn_opengl/src/getting_started/hello_rectangle/build.zig
const std = @import("std"); const Options = @import("../../../build.zig").Options; inline fn thisDir() []const u8 { return comptime std.fs.path.dirname(@src().file) orelse "."; } pub fn build(b: *std.Build, options: Options) *std.build.CompileStep { const exe = b.addExecutable(.{ .name = "hello_rectangle", .root_source_file = .{ .path = thisDir() ++ "/main.zig" }, .target = options.target, .optimize = options.build_mode, }); return exe; }
0
repos/zig_learn_opengl/src/getting_started
repos/zig_learn_opengl/src/getting_started/basic_lighting/main.zig
const std = @import("std"); const math = std.math; const glfw = @import("glfw"); const zstbi = @import("zstbi"); const zm = @import("zmath"); const gl = @import("gl"); const Shader = @import("Shader"); const Camera = @import("Camera"); const common = @import("common"); // Camera const camera_pos = zm.loadArr3(.{ 0.0, 0.0, 5.0 }); var lastX: f64 = 0.0; var lastY: f64 = 0.0; var first_mouse = true; var camera = Camera.camera(camera_pos); // Timing var delta_time: f32 = 0.0; var last_frame: f32 = 0.0; // lighting var light_position = [_]f32{ 10.0, 10.0, 10.0 }; const WindowSize = struct { pub const width: u32 = 800; pub const height: u32 = 600; }; pub fn main() !void { // glfw: initialize and configure // ------------------------------ if (!glfw.init(.{})) { std.log.err("GLFW initialization failed", .{}); return; } defer glfw.terminate(); // glfw window creation // -------------------- const window = glfw.Window.create(WindowSize.width, WindowSize.height, "mach-glfw + zig-opengl", null, null, .{ .opengl_profile = .opengl_core_profile, .context_version_major = 4, .context_version_minor = 1, }) orelse { std.log.err("GLFW Window creation failed", .{}); return; }; defer window.destroy(); glfw.makeContextCurrent(window); glfw.Window.setFramebufferSizeCallback(window, framebuffer_size_callback); // Capture mouse, disable cursor visibility glfw.Window.setInputMode(window, glfw.Window.InputMode.cursor, glfw.Window.InputModeCursor.disabled); glfw.Window.setCursorPosCallback(window, mouseCallback); glfw.Window.setScrollCallback(window, mouseScrollCallback); // Load all OpenGL function pointers // --------------------------------------- const proc: glfw.GLProc = undefined; try gl.load(proc, glGetProcAddress); var gpa = std.heap.GeneralPurposeAllocator(.{}){}; var allocator = gpa.allocator(); var arena_allocator_state = std.heap.ArenaAllocator.init(allocator); defer arena_allocator_state.deinit(); const arena = arena_allocator_state.allocator(); // Enable OpenGL depth testing (use Z-buffer information) gl.enable(gl.DEPTH_TEST); // create shader program var shader_program: Shader = Shader.create(arena, "content/shader.vs", "content/shader.fs"); var light_shader: Shader = Shader.create(arena, "content/light_shader.vs", "content/light_shader.fs"); // set up vertex data (and buffer(s)) and configure vertex attributes // ------------------------------------------------------------------ const vertices_2D = [_]f32{ // positions // colors // texture coords 0.5, 0.5, 0.0, 1.0, 0.0, 0.0, 1.0, 1.0, // top right 0.5, -0.5, 0.0, 0.0, 1.0, 0.0, 1.0, 0.0, // bottom right -0.5, -0.5, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, // bottom left -0.5, 0.5, 0.0, 1.0, 1.0, 0.0, 0.0, 1.0, // top left }; _ = vertices_2D; const vertices_3D = [_]f32{ -0.5, -0.5, -0.5, 0.0, 0.0, -1.0, 0.5, -0.5, -0.5, 0.0, 0.0, -1.0, 0.5, 0.5, -0.5, 0.0, 0.0, -1.0, 0.5, 0.5, -0.5, 0.0, 0.0, -1.0, -0.5, 0.5, -0.5, 0.0, 0.0, -1.0, -0.5, -0.5, -0.5, 0.0, 0.0, -1.0, -0.5, -0.5, 0.5, 0.0, 0.0, 1.0, 0.5, -0.5, 0.5, 0.0, 0.0, 1.0, 0.5, 0.5, 0.5, 0.0, 0.0, 1.0, 0.5, 0.5, 0.5, 0.0, 0.0, 1.0, -0.5, 0.5, 0.5, 0.0, 0.0, 1.0, -0.5, -0.5, 0.5, 0.0, 0.0, 1.0, -0.5, 0.5, 0.5, -1.0, 0.0, 0.0, -0.5, 0.5, -0.5, -1.0, 0.0, 0.0, -0.5, -0.5, -0.5, -1.0, 0.0, 0.0, -0.5, -0.5, -0.5, -1.0, 0.0, 0.0, -0.5, -0.5, 0.5, -1.0, 0.0, 0.0, -0.5, 0.5, 0.5, -1.0, 0.0, 0.0, 0.5, 0.5, 0.5, 1.0, 0.0, 0.0, 0.5, 0.5, -0.5, 1.0, 0.0, 0.0, 0.5, -0.5, -0.5, 1.0, 0.0, 0.0, 0.5, -0.5, -0.5, 1.0, 0.0, 0.0, 0.5, -0.5, 0.5, 1.0, 0.0, 0.0, 0.5, 0.5, 0.5, 1.0, 0.0, 0.0, -0.5, -0.5, -0.5, 0.0, -1.0, 0.0, 0.5, -0.5, -0.5, 0.0, -1.0, 0.0, 0.5, -0.5, 0.5, 0.0, -1.0, 0.0, 0.5, -0.5, 0.5, 0.0, -1.0, 0.0, -0.5, -0.5, 0.5, 0.0, -1.0, 0.0, -0.5, -0.5, -0.5, 0.0, -1.0, 0.0, -0.5, 0.5, -0.5, 0.0, 1.0, 0.0, 0.5, 0.5, -0.5, 0.0, 1.0, 0.0, 0.5, 0.5, 0.5, 0.0, 1.0, 0.0, 0.5, 0.5, 0.5, 0.0, 1.0, 0.0, -0.5, 0.5, 0.5, 0.0, 1.0, 0.0, -0.5, 0.5, -0.5, 0.0, 1.0, 0.0, }; var VBO: c_uint = undefined; var VAO: c_uint = undefined; var light_VAO: c_uint = undefined; gl.genVertexArrays(1, &VAO); defer gl.deleteVertexArrays(1, &VAO); gl.genVertexArrays(1, &light_VAO); defer gl.deleteVertexArrays(1, &light_VAO); gl.genBuffers(1, &VBO); defer gl.deleteBuffers(1, &VBO); // bind the Vertex Array Object first, then bind and set vertex buffer(s), and then configure vertex attributes(s). gl.bindVertexArray(VAO); gl.bindBuffer(gl.ARRAY_BUFFER, VBO); // Fill our buffer with the vertex data gl.bufferData(gl.ARRAY_BUFFER, @sizeOf(f32) * vertices_3D.len, &vertices_3D, gl.STATIC_DRAW); // vertex gl.vertexAttribPointer(0, 3, gl.FLOAT, gl.FALSE, 6 * @sizeOf(f32), null); gl.enableVertexAttribArray(0); // normal attribute const normal_offset: [*c]c_uint = (3 * @sizeOf(f32)); gl.vertexAttribPointer(1, 3, gl.FLOAT, gl.FALSE, 6 * @sizeOf(f32), normal_offset); gl.enableVertexAttribArray(1); // Configure light VAO gl.bindVertexArray(light_VAO); gl.bindBuffer(gl.ARRAY_BUFFER, VBO); gl.vertexAttribPointer(0, 3, gl.FLOAT, gl.FALSE, 6 * @sizeOf(f32), null); gl.enableVertexAttribArray(0); // View matrix var view: [16]f32 = undefined; // Buffer to store Orojection matrix (in render loop) var proj: [16]f32 = undefined; var light_model: [16]f32 = undefined; while (!window.shouldClose()) { // Time per frame const current_frame = @floatCast(f32, glfw.getTime()); delta_time = current_frame - last_frame; last_frame = current_frame; processInput(window); gl.clearColor(0.0, 0.0, 0.0, 0.0); gl.clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT); light_position[0] = 1.0 + zm.sin(@floatCast(f32, glfw.getTime())) * 2.0; light_position[1] = 1.0 + zm.sin(@floatCast(f32, glfw.getTime()) / 2.0) * 1.0; shader_program.use(); shader_program.setVec3f("objectColor", .{ 1.0, 0.5, 0.31 }); shader_program.setVec3f("lightColor", .{ 1.0, 1.0, 1.0 }); shader_program.setVec3f("lightPos", light_position); shader_program.setVec3f("viewPos", zm.vecToArr3(camera.position)); // Projection matrix const projM = x: { const window_size = window.getSize(); const aspect = @intToFloat(f32, window_size.width) / @intToFloat(f32, window_size.height); var projM = zm.perspectiveFovRhGl(camera.zoom * common.RAD_CONVERSION, aspect, 0.1, 100.0); break :x projM; }; zm.storeMat(&proj, projM); shader_program.setMat4f("projection", proj); // View matrix: Camera const viewM = camera.getViewMatrix(); zm.storeMat(&view, viewM); shader_program.setMat4f("view", view); gl.bindVertexArray(VAO); gl.drawArrays(gl.TRIANGLES, 0, 36); const light_trans = zm.translation(light_position[0], light_position[1], light_position[2]); const light_modelM = zm.mul(light_trans, zm.scaling(0.2, 0.2, 0.2)); zm.storeMat(&light_model, light_modelM); light_shader.use(); light_shader.setMat4f("projection", proj); light_shader.setMat4f("view", view); light_shader.setMat4f("model", light_model); gl.bindVertexArray(light_VAO); gl.drawArrays(gl.TRIANGLES, 0, 36); window.swapBuffers(); glfw.pollEvents(); } } fn glGetProcAddress(p: glfw.GLProc, proc: [:0]const u8) ?gl.FunctionPointer { _ = p; return glfw.getProcAddress(proc); } fn framebuffer_size_callback(window: glfw.Window, width: u32, height: u32) void { _ = window; gl.viewport(0, 0, @intCast(c_int, width), @intCast(c_int, height)); } fn processInput(window: glfw.Window) void { if (glfw.Window.getKey(window, glfw.Key.escape) == glfw.Action.press) { _ = glfw.Window.setShouldClose(window, true); } if (glfw.Window.getKey(window, glfw.Key.w) == glfw.Action.press) { camera.processKeyboard(Camera.CameraMovement.FORWARD, delta_time); } if (glfw.Window.getKey(window, glfw.Key.s) == glfw.Action.press) { camera.processKeyboard(Camera.CameraMovement.BACKWARD, delta_time); } if (glfw.Window.getKey(window, glfw.Key.a) == glfw.Action.press) { camera.processKeyboard(Camera.CameraMovement.LEFT, delta_time); } if (glfw.Window.getKey(window, glfw.Key.d) == glfw.Action.press) { camera.processKeyboard(Camera.CameraMovement.RIGHT, delta_time); } } fn mouseCallback(window: glfw.Window, xpos: f64, ypos: f64) void { _ = window; if (first_mouse) { lastX = xpos; lastY = ypos; first_mouse = false; } var xoffset = xpos - lastX; var yoffset = ypos - lastY; lastX = xpos; lastY = ypos; camera.processMouseMovement(xoffset, yoffset, true); } fn mouseScrollCallback(window: glfw.Window, xoffset: f64, yoffset: f64) void { _ = window; _ = xoffset; camera.processMouseScroll(yoffset); }
0
repos/zig_learn_opengl/src/getting_started
repos/zig_learn_opengl/src/getting_started/basic_lighting/build.zig
const std = @import("std"); const Options = @import("../../../build.zig").Options; inline fn thisDir() []const u8 { return comptime std.fs.path.dirname(@src().file) orelse "."; } const content_dir = "content/"; pub fn build(b: *std.build.Builder, options: Options) *std.build.CompileStep { const exe = b.addExecutable(.{ .name = "basic_lighting", .root_source_file = .{ .path = thisDir() ++ "/main.zig" }, .target = options.target, .optimize = options.build_mode, }); const install_content_step = b.addInstallDirectory(.{ .source_dir = thisDir() ++ "/" ++ content_dir, .install_dir = .{ .custom = "" }, .install_subdir = "bin/" ++ content_dir, }); exe.step.dependOn(&install_content_step.step); return exe; }
0
repos/zig_learn_opengl/src/getting_started/basic_lighting
repos/zig_learn_opengl/src/getting_started/basic_lighting/content/light_shader.vs
#version 330 core layout (location = 0) in vec3 aPos; uniform mat4 model; uniform mat4 view; uniform mat4 projection; void main() { gl_Position = projection * view * model * vec4(aPos, 1.0f); }
0
repos/zig_learn_opengl/src/getting_started/basic_lighting
repos/zig_learn_opengl/src/getting_started/basic_lighting/content/light_shader.fs
#version 330 core out vec4 FragColor; void main() { FragColor = vec4(1.0f); };
0
repos/zig_learn_opengl/src/getting_started/basic_lighting
repos/zig_learn_opengl/src/getting_started/basic_lighting/content/shader.fs
#version 330 core out vec4 FragColor; in vec3 FragPos; in vec3 Normal; uniform vec3 lightPos; uniform vec3 objectColor; uniform vec3 lightColor; uniform vec3 viewPos; void main() { float ambientStrength = 0.1; vec3 ambient = ambientStrength * lightColor; float specularStrength = 0.75; vec3 norm = normalize(Normal); vec3 lightDir = normalize(lightPos - FragPos); float diff = max(dot(norm, lightDir), 0.0); vec3 diffuse = diff * lightColor; vec3 viewDir = normalize(viewPos - FragPos); vec3 reflectDir = reflect(-lightDir, norm); float spec = pow(max(dot(viewDir, reflectDir), 0.0), 256); vec3 specular = specularStrength * spec * lightColor; vec3 result = (ambient + diffuse + specular) * objectColor; FragColor = vec4(result, 1.0f); };
0
repos/zig_learn_opengl/src/getting_started/basic_lighting
repos/zig_learn_opengl/src/getting_started/basic_lighting/content/shader.vs
#version 330 core layout (location = 0) in vec3 aPos; layout (location = 1) in vec3 aNormal; uniform mat4 model; uniform mat4 view; uniform mat4 projection; out vec3 FragPos; out vec3 Normal; void main() { gl_Position = projection * view * vec4(aPos, 1.0f); FragPos = vec3(vec4(aPos, 1.0)); Normal = aNormal; }