agents-orchestrator/agent-orchestrator
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

feat: Electrobun Svelte+WGPU prototype (Dawn GPU confirmed on Linux)

Browse source 
- Svelte 5 frontend with Catppuccin Mocha theme, 2 project cards
- Electrobun v1.16.0 with bundleWGPU: true (Dawn on Linux x64)
- WebKitGTK webview + WGPU surface coexistence confirmed
- CPU: 6.5% idle (CSS animation + WebKitGTK overhead)
- Port 9760 for dev server (project convention)
This commit is contained in:
Hibryda 2026-03-20 01:25:41 +01:00
parent 1f20fc460e
commit cfc135ffaf
29 changed files with 1106 additions and 1020 deletions
Download patch file Download diff file Expand all files Collapse all files

4
ui-electrobun/build/dev-linux-x64/wgpu-dev/Info.plist → ui-electrobun/build/dev-linux-x64/AgentOrchestrator-dev/Info.plist
View file

@ -5,9 +5,9 @@
<key>CFBundleExecutable</key>
<string>launcher</string>
<key>CFBundleIdentifier</key>
<string>wgpu.electrobun.dev</string>
<string>dev.agor.orchestrator</string>
<key>CFBundleName</key>
<string>wgpu-dev</string>
<string>AgentOrchestrator-dev</string>
<key>CFBundleVersion</key>
<string>0.0.1</string>
<key>CFBundlePackageType</key>

510
ui-electrobun/build/dev-linux-x64/wgpu-dev/Resources/app/bun/index.js → ui-electrobun/build/dev-linux-x64/AgentOrchestrator-dev/Resources/app/bun/index.js
View file

@ -3206,7 +3206,7 @@ function toCString(jsString, addNullTerminator = true) {
const buff = Buffer.from(jsString + appendWith, "utf8");
return ptr(buff);
}
var menuDataRegistry, menuDataCounter = 0, ELECTROBUN_DELIMITER = "|EB|", native, ffi, WGPUBridge, windowCloseCallback, windowMoveCallback, windowResizeCallback, windowFocusCallback, windowBlurCallback, windowKeyCallback, getMimeType, getHTMLForWebviewSync, urlOpenCallback, appReopenCallback, quitRequestedCallback, globalShortcutHandlers, globalShortcutCallback, Screen, sessionCache, webviewDecideNavigation, webviewEventHandler = (id, eventName, detail) => {
var menuDataRegistry, menuDataCounter = 0, ELECTROBUN_DELIMITER = "|EB|", native, ffi, WGPUBridge, windowCloseCallback, windowMoveCallback, windowResizeCallback, windowFocusCallback, windowBlurCallback, windowKeyCallback, getMimeType, getHTMLForWebviewSync, urlOpenCallback, appReopenCallback, quitRequestedCallback, globalShortcutHandlers, globalShortcutCallback, sessionCache, webviewDecideNavigation, webviewEventHandler = (id, eventName, detail) => {
const webview = BrowserView.getById(id);
if (!webview) {
console.error("[webviewEventHandler] No webview found for id:", id);
@ -4563,60 +4563,6 @@ window.__electrobunBunBridge = window.__electrobunBunBridge || window.webkit?.me
threadsafe: true
});
native.symbols.setGlobalShortcutCallback(globalShortcutCallback);
Screen = {
getPrimaryDisplay: () => {
const jsonStr = native.symbols.getPrimaryDisplay();
if (!jsonStr) {
return {
id: 0,
bounds: { x: 0, y: 0, width: 0, height: 0 },
workArea: { x: 0, y: 0, width: 0, height: 0 },
scaleFactor: 1,
isPrimary: true
};
}
try {
return JSON.parse(jsonStr.toString());
} catch {
return {
id: 0,
bounds: { x: 0, y: 0, width: 0, height: 0 },
workArea: { x: 0, y: 0, width: 0, height: 0 },
scaleFactor: 1,
isPrimary: true
};
}
},
getAllDisplays: () => {
const jsonStr = native.symbols.getAllDisplays();
if (!jsonStr) {
return [];
}
try {
return JSON.parse(jsonStr.toString());
} catch {
return [];
}
},
getCursorScreenPoint: () => {
const jsonStr = native.symbols.getCursorScreenPoint();
if (!jsonStr) {
return { x: 0, y: 0 };
}
try {
return JSON.parse(jsonStr.toString());
} catch {
return { x: 0, y: 0 };
}
},
getMouseButtons: () => {
try {
return native.symbols.getMouseButtons();
} catch {
return 0n;
}
}
};
sessionCache = new Map;
webviewDecideNavigation = new JSCallback((_webviewId, _url) => {
return true;
@ -231800,438 +231746,30 @@ init_BuildConfig();
await init_native();
// src/bun/index.ts
import { CString as CString3, ptr as ptr3, toArrayBuffer as toArrayBuffer3 } from "bun:ffi";
var WGPUNative2 = webGPU_default.native;
var WGPU_STRLEN2 = 0xffffffffffffffffn;
var WGPU_DEPTH_SLICE_UNDEFINED2 = 4294967295;
var WGPUTextureUsage_RenderAttachment2 = 0x0000000000000010n;
var WGPUBufferUsage_Vertex = 0x0000000000000020n;
var WGPUBufferUsage_CopyDst = 0x0000000000000008n;
var WGPUVertexFormat_Float322 = 28;
var WGPUVertexFormat_Float32x22 = 29;
var WGPUVertexFormat_Float32x42 = 31;
var WGPUVertexStepMode_Vertex2 = 1;
var WGPUPrimitiveTopology_TriangleList2 = 4;
var WGPUFrontFace_CCW2 = 1;
var WGPUCullMode_None2 = 1;
var WGPUPresentMode_Fifo2 = 1;
var KEEPALIVE = [];
function writePtr2(view, offset, value) {
view.setBigUint64(offset, BigInt(value ?? 0), true);
}
function writeU322(view, offset, value) {
view.setUint32(offset, value >>> 0, true);
}
function writeU642(view, offset, value) {
view.setBigUint64(offset, value, true);
}
function makeSurfaceConfiguration2(devicePtr, width, height, format) {
const buffer2 = new ArrayBuffer(64);
const view = new DataView(buffer2);
writePtr2(view, 0, 0);
writePtr2(view, 8, devicePtr);
writeU322(view, 16, format);
writeU322(view, 20, 0);
writeU642(view, 24, WGPUTextureUsage_RenderAttachment2);
writeU322(view, 32, width);
writeU322(view, 36, height);
writeU642(view, 40, 0n);
writePtr2(view, 48, 0);
writeU322(view, 56, 1);
writeU322(view, 60, WGPUPresentMode_Fifo2);
return { buffer: buffer2, ptr: ptr3(buffer2) };
}
function makeShaderSourceWGSL2(codePtr) {
const buffer2 = new ArrayBuffer(32);
const view = new DataView(buffer2);
writePtr2(view, 0, 0);
writeU322(view, 8, 2);
writeU322(view, 12, 0);
writePtr2(view, 16, codePtr);
writeU642(view, 24, WGPU_STRLEN2);
return { buffer: buffer2, ptr: ptr3(buffer2) };
}
function makeShaderModuleDescriptor2(nextInChainPtr) {
const buffer2 = new ArrayBuffer(24);
const view = new DataView(buffer2);
writePtr2(view, 0, nextInChainPtr);
writePtr2(view, 8, 0);
writeU642(view, 16, 0n);
return { buffer: buffer2, ptr: ptr3(buffer2) };
}
function makeVertexAttribute2(offset, shaderLocation, format) {
const buffer2 = new ArrayBuffer(32);
const view = new DataView(buffer2);
writePtr2(view, 0, 0);
writeU322(view, 8, format);
writeU322(view, 12, 0);
writeU642(view, 16, BigInt(offset));
writeU322(view, 24, shaderLocation);
writeU322(view, 28, 0);
return { buffer: buffer2, ptr: ptr3(buffer2) };
}
function makeVertexBufferLayout2(attributePtr, attributeCount, stride) {
const buffer2 = new ArrayBuffer(40);
const view = new DataView(buffer2);
writePtr2(view, 0, 0);
writeU322(view, 8, WGPUVertexStepMode_Vertex2);
writeU322(view, 12, 0);
writeU642(view, 16, BigInt(stride));
writeU642(view, 24, BigInt(attributeCount));
writePtr2(view, 32, attributePtr);
return { buffer: buffer2, ptr: ptr3(buffer2) };
}
function makeColorTargetState2(format) {
const buffer2 = new ArrayBuffer(32);
const view = new DataView(buffer2);
writePtr2(view, 0, 0);
writeU322(view, 8, format);
writeU322(view, 12, 0);
writePtr2(view, 16, 0);
writeU642(view, 24, 0x0fn);
return { buffer: buffer2, ptr: ptr3(buffer2) };
}
function makeVertexState2(modulePtr, entryPointPtr, bufferLayoutPtr) {
const buffer2 = new ArrayBuffer(64);
const view = new DataView(buffer2);
writePtr2(view, 0, 0);
writePtr2(view, 8, modulePtr);
writePtr2(view, 16, entryPointPtr);
writeU642(view, 24, WGPU_STRLEN2);
writeU642(view, 32, 0n);
writePtr2(view, 40, 0);
writeU642(view, 48, 1n);
writePtr2(view, 56, bufferLayoutPtr);
return { buffer: buffer2, ptr: ptr3(buffer2) };
}
function makeFragmentState2(modulePtr, entryPointPtr, targetPtr) {
const buffer2 = new ArrayBuffer(64);
const view = new DataView(buffer2);
writePtr2(view, 0, 0);
writePtr2(view, 8, modulePtr);
writePtr2(view, 16, entryPointPtr);
writeU642(view, 24, WGPU_STRLEN2);
writeU642(view, 32, 0n);
writePtr2(view, 40, 0);
writeU642(view, 48, 1n);
writePtr2(view, 56, targetPtr);
return { buffer: buffer2, ptr: ptr3(buffer2) };
}
function makePrimitiveState2() {
const buffer2 = new ArrayBuffer(32);
const view = new DataView(buffer2);
writePtr2(view, 0, 0);
writeU322(view, 8, WGPUPrimitiveTopology_TriangleList2);
writeU322(view, 12, 0);
writeU322(view, 16, WGPUFrontFace_CCW2);
writeU322(view, 20, WGPUCullMode_None2);
writeU322(view, 24, 0);
writeU322(view, 28, 0);
return { buffer: buffer2, ptr: ptr3(buffer2) };
}
function makeMultisampleState2() {
const buffer2 = new ArrayBuffer(24);
const view = new DataView(buffer2);
writePtr2(view, 0, 0);
writeU322(view, 8, 1);
writeU322(view, 12, 4294967295);
writeU322(view, 16, 0);
writeU322(view, 20, 0);
return { buffer: buffer2, ptr: ptr3(buffer2) };
}
function makeRenderPipelineDescriptor2(vertexStatePtr, primitiveStatePtr, multisampleStatePtr, fragmentStatePtr) {
const buffer2 = new ArrayBuffer(168);
const view = new DataView(buffer2);
writePtr2(view, 0, 0);
writePtr2(view, 8, 0);
writeU642(view, 16, 0n);
writePtr2(view, 24, 0);
new Uint8Array(buffer2, 32, 64).set(new Uint8Array(vertexStatePtr.buffer));
new Uint8Array(buffer2, 96, 32).set(new Uint8Array(primitiveStatePtr.buffer));
writePtr2(view, 128, 0);
new Uint8Array(buffer2, 136, 24).set(new Uint8Array(multisampleStatePtr.buffer));
writePtr2(view, 160, fragmentStatePtr.ptr);
return { buffer: buffer2, ptr: ptr3(buffer2) };
}
function makeBufferDescriptor2(size) {
const buffer2 = new ArrayBuffer(48);
const view = new DataView(buffer2);
writePtr2(view, 0, 0);
writePtr2(view, 8, 0);
writeU642(view, 16, 0n);
writeU642(view, 24, WGPUBufferUsage_Vertex | WGPUBufferUsage_CopyDst);
writeU642(view, 32, BigInt(size));
writeU322(view, 40, 0);
writeU322(view, 44, 0);
return { buffer: buffer2, ptr: ptr3(buffer2) };
}
function makeCommandEncoderDescriptor2() {
const buffer2 = new ArrayBuffer(24);
const view = new DataView(buffer2);
writePtr2(view, 0, 0);
writePtr2(view, 8, 0);
writeU642(view, 16, 0n);
return { buffer: buffer2, ptr: ptr3(buffer2) };
}
function makeSurfaceTexture2() {
const buffer2 = new ArrayBuffer(24);
return { buffer: buffer2, view: new DataView(buffer2), ptr: ptr3(buffer2) };
}
function makeRenderPassColorAttachment2(viewPtr, clear) {
const buffer2 = new ArrayBuffer(72);
const view = new DataView(buffer2);
writePtr2(view, 0, 0);
writePtr2(view, 8, viewPtr);
writeU322(view, 16, WGPU_DEPTH_SLICE_UNDEFINED2);
writeU322(view, 20, 0);
writePtr2(view, 24, 0);
writeU322(view, 32, 2);
writeU322(view, 36, 1);
view.setFloat64(40, clear.r, true);
view.setFloat64(48, clear.g, true);
view.setFloat64(56, clear.b, true);
view.setFloat64(64, clear.a, true);
return { buffer: buffer2, ptr: ptr3(buffer2) };
}
function makeRenderPassDescriptor2(colorAttachmentPtr) {
const buffer2 = new ArrayBuffer(64);
const view = new DataView(buffer2);
writePtr2(view, 0, 0);
writePtr2(view, 8, 0);
writeU642(view, 16, 0n);
writeU642(view, 24, 1n);
writePtr2(view, 32, colorAttachmentPtr);
writePtr2(view, 40, 0);
writePtr2(view, 48, 0);
writePtr2(view, 56, 0);
return { buffer: buffer2, ptr: ptr3(buffer2) };
}
function makeCommandBufferArray(cmdPtr) {
const buffer2 = new BigUint64Array([BigInt(cmdPtr)]);
return { buffer: buffer2, ptr: ptr3(buffer2) };
}
var size = 640;
var display = Screen.getPrimaryDisplay();
var workArea = display.workArea;
var x = workArea.x + Math.floor((workArea.width - size) / 2);
var y = workArea.y + Math.floor((workArea.height - size) / 2);
var win = new GpuWindow({
title: "WGPU Shader",
frame: { width: size, height: size, x, y },
titleBarStyle: "default",
transparent: false
});
if (!WGPUNative2.available) {
throw new Error("WGPU not available for wgpu");
}
var instance = WGPUNative2.symbols.wgpuCreateInstance(0);
var surface = WGPUBridge.createSurfaceForView(instance, win.wgpuView.ptr);
var adapterDevice = new BigUint64Array(2);
WGPUBridge.createAdapterDeviceMainThread(instance, surface, ptr3(adapterDevice));
var adapter = Number(adapterDevice[0]);
var device = Number(adapterDevice[1]);
if (!adapter || !device) {
throw new Error("Failed to get WGPU adapter/device");
}
var queue = WGPUNative2.symbols.wgpuDeviceGetQueue(device);
var capsBuffer = new ArrayBuffer(64);
var capsView = new DataView(capsBuffer);
WGPUNative2.symbols.wgpuSurfaceGetCapabilities(surface, adapter, ptr3(capsBuffer));
var formatCount = Number(capsView.getBigUint64(16, true));
var formatPtr = Number(capsView.getBigUint64(24, true));
var surfaceFormat = 23;
if (formatCount && formatPtr) {
const formats = new Uint32Array(toArrayBuffer3(formatPtr, 0, formatCount * 4));
if (formats.length)
surfaceFormat = formats[0];
}
var surfaceConfig = makeSurfaceConfiguration2(device, size, size, surfaceFormat);
WGPUBridge.surfaceConfigure(surface, surfaceConfig.ptr);
var shaderText = `
struct VSOut {
@builtin(position) position : vec4<f32>,
@location(0) uv : vec2<f32>,
@location(1) time : f32,
@location(2) resolution : vec2<f32>,
@location(3) mouse : vec4<f32>,
};
@vertex
fn vs_main(
@location(0) position: vec2<f32>,
@location(1) time: f32,
@location(2) resolution: vec2<f32>,
@location(3) mouse: vec4<f32>
) -> VSOut {
var out: VSOut;
out.position = vec4<f32>(position, 0.0, 1.0);
out.uv = position;
out.time = time;
out.resolution = resolution;
out.mouse = mouse;
return out;
}
@fragment
fn fs_main(
@location(0) uv: vec2<f32>,
@location(1) time: f32,
@location(2) resolution: vec2<f32>,
@location(3) mouse: vec4<f32>
) -> @location(0) vec4<f32> {
let fragCoord = (uv * 0.5 + vec2<f32>(0.5)) * resolution;
let m = (mouse.xy / max(resolution, vec2<f32>(1.0))) * 2.0 - vec2<f32>(1.0);
let loopMax: i32 = select(32, 64, mouse.z > 0.5);
var o = vec4<f32>(0.0);
var i: f32 = 0.0;
var d: f32 = 0.0;
var c: f32 = 0.0;
var s: f32 = 0.0;
var q = vec3<f32>(0.0);
var p = vec3<f32>(0.0);
let r = vec3<f32>(resolution, 0.0);
var dir = normalize(vec3<f32>((fragCoord + fragCoord - r.xy) / r.y, 1.0));
dir.x = dir.x + m.x * 0.35;
dir.y = dir.y + -m.y * 0.35;
for (var iter: i32 = 0; iter < loopMax; iter = iter + 1) {
i = f32(iter + 1);
p = dir * d;
p.z = p.z + time * 4.0;
q = p;
s = 0.0;
c = 20.0;
loop {
if (c <= 0.2) { break; }
let m = mat2x2<f32>(
vec2<f32>(cos(c / 30.0 + 0.0), cos(c / 30.0 + 33.0)),
vec2<f32>(cos(c / 30.0 + 11.0), cos(c / 30.0 + 0.0))
);
let xz = m * vec2<f32>(p.x, p.z);
p.x = xz.x;
p.z = xz.y;
p = abs(fract(p / c) * c - vec3<f32>(c * 0.5)) - vec3<f32>(c * 0.2);
s = max(
9.0 + 3.0 * sin(q.z * 0.05) - abs(q.x),
max(s, min(p.x, min(p.y, p.z)))
);
p = q;
c = c * 0.5;
var DEV_SERVER_PORT = 9760;
var DEV_SERVER_URL = `http://localhost:${DEV_SERVER_PORT}`;
async function getMainViewUrl() {
const channel = await Updater.localInfo.channel();
if (channel === "dev") {
try {
await fetch(DEV_SERVER_URL, { method: "HEAD" });
console.log(`HMR enabled: Using Vite dev server at ${DEV_SERVER_URL}`);
return DEV_SERVER_URL;
} catch {
console.log("Vite dev server not running. Run 'bun run dev:hmr' for HMR support.");
}
let sinp = sin(p * 12.0);
let dotv = dot(sinp, vec3<f32>(0.1, 0.1, 0.1));
s = min(s, p.y + 8.0 + dotv);
d = d + s;
let add = i / max(s, 0.001);
o = o + vec4<f32>(add, add, add, add);
}
let denom = max(d, 0.000001);
o = tanh(o / denom / 30000.0);
return vec4<f32>(o.xyz, 1.0);
return "views://mainview/index.html";
}
`;
var shaderBytes = new TextEncoder().encode(shaderText + "\x00");
var shaderBuf = new Uint8Array(shaderBytes);
KEEPALIVE.push(shaderBuf);
var shaderPtr = ptr3(shaderBuf);
var shaderSource = makeShaderSourceWGSL2(shaderPtr);
var shaderDesc = makeShaderModuleDescriptor2(shaderSource.ptr);
var shaderModule = WGPUNative2.symbols.wgpuDeviceCreateShaderModule(device, shaderDesc.ptr);
var entryPoint = new CString3("vs_main");
var fragEntryPoint = new CString3("fs_main");
KEEPALIVE.push(entryPoint, fragEntryPoint);
var posAttr = makeVertexAttribute2(0, 0, WGPUVertexFormat_Float32x22);
var timeAttr = makeVertexAttribute2(8, 1, WGPUVertexFormat_Float322);
var resAttr = makeVertexAttribute2(12, 2, WGPUVertexFormat_Float32x22);
var mouseAttr = makeVertexAttribute2(20, 3, WGPUVertexFormat_Float32x42);
var attrBuf = new ArrayBuffer(32 * 4);
new Uint8Array(attrBuf, 0, 32).set(new Uint8Array(posAttr.buffer));
new Uint8Array(attrBuf, 32, 32).set(new Uint8Array(timeAttr.buffer));
new Uint8Array(attrBuf, 64, 32).set(new Uint8Array(resAttr.buffer));
new Uint8Array(attrBuf, 96, 32).set(new Uint8Array(mouseAttr.buffer));
var attrPtr = ptr3(attrBuf);
KEEPALIVE.push(attrBuf);
var vertexLayout = makeVertexBufferLayout2(attrPtr, 4, 36);
var vertexState = makeVertexState2(shaderModule, entryPoint.ptr, vertexLayout.ptr);
var colorTarget = makeColorTargetState2(surfaceFormat);
var fragmentState = makeFragmentState2(shaderModule, fragEntryPoint.ptr, colorTarget.ptr);
var primitiveState = makePrimitiveState2();
var multisampleState = makeMultisampleState2();
var pipelineDesc = makeRenderPipelineDescriptor2(vertexState, primitiveState, multisampleState, fragmentState);
var pipeline = WGPUNative2.symbols.wgpuDeviceCreateRenderPipeline(device, pipelineDesc.ptr);
var vertexCount = 3;
var bufferDesc = makeBufferDescriptor2(vertexCount * 9 * 4);
var vertexBuffer = WGPUNative2.symbols.wgpuDeviceCreateBuffer(device, bufferDesc.ptr);
var encoderDesc = makeCommandEncoderDescriptor2();
var lastLeftDown = false;
var qualityBoost = false;
var clickX = 0;
var clickY = 0;
function renderFrame() {
const sizeNow = win.getSize();
const t = performance.now() * 0.001;
const positions = [-1, -1, 3, -1, -1, 3];
const frame2 = win.getFrame();
const cursor = Screen.getCursorScreenPoint();
const rawX = cursor.x - frame2.x;
const rawY = cursor.y - frame2.y;
const mx = Math.max(0, Math.min(frame2.width, rawX));
const my = Math.max(0, Math.min(frame2.height, rawY));
const buttons = Screen.getMouseButtons();
const leftDown = (buttons & 1n) === 1n;
if (leftDown && !lastLeftDown) {
qualityBoost = !qualityBoost;
clickX = mx;
clickY = my;
var url = await getMainViewUrl();
var mainWindow = new BrowserWindow({
title: "Agent Orchestrator \u2014 Electrobun",
url,
frame: {
width: 1400,
height: 900,
x: 100,
y: 100
}
lastLeftDown = leftDown;
const packed = new Float32Array(vertexCount * 9);
for (let i = 0;i < vertexCount; i += 1) {
const idx = i * 9;
packed[idx] = positions[i * 2];
packed[idx + 1] = positions[i * 2 + 1];
packed[idx + 2] = t;
packed[idx + 3] = sizeNow.width;
packed[idx + 4] = sizeNow.height;
packed[idx + 5] = mx;
packed[idx + 6] = my;
packed[idx + 7] = qualityBoost ? clickX : 0;
packed[idx + 8] = qualityBoost ? clickY : 0;
}
WGPUNative2.symbols.wgpuQueueWriteBuffer(queue, vertexBuffer, 0, ptr3(packed), packed.byteLength);
WGPUNative2.symbols.wgpuInstanceProcessEvents(instance);
const surfaceTexture = makeSurfaceTexture2();
WGPUBridge.surfaceGetCurrentTexture(surface, surfaceTexture.ptr);
const status = surfaceTexture.view.getUint32(16, true);
if (status !== 1 && status !== 2)
return;
const texPtr = Number(surfaceTexture.view.getBigUint64(8, true));
if (!texPtr)
return;
const textureView = WGPUNative2.symbols.wgpuTextureCreateView(texPtr, 0);
if (!textureView)
return;
const colorAttachment = makeRenderPassColorAttachment2(textureView, {
r: 0.05,
g: 0.05,
b: 0.1,
a: 1
});
const renderPassDesc = makeRenderPassDescriptor2(colorAttachment.ptr);
const encoder = WGPUNative2.symbols.wgpuDeviceCreateCommandEncoder(device, encoderDesc.ptr);
const pass2 = WGPUNative2.symbols.wgpuCommandEncoderBeginRenderPass(encoder, renderPassDesc.ptr);
WGPUNative2.symbols.wgpuRenderPassEncoderSetPipeline(pass2, pipeline);
WGPUNative2.symbols.wgpuRenderPassEncoderSetVertexBuffer(pass2, 0, vertexBuffer, 0, packed.byteLength);
WGPUNative2.symbols.wgpuRenderPassEncoderDraw(pass2, vertexCount, 1, 0, 0);
WGPUNative2.symbols.wgpuRenderPassEncoderEnd(pass2);
const commandBuffer = WGPUNative2.symbols.wgpuCommandEncoderFinish(encoder, 0);
const commandArray = makeCommandBufferArray(commandBuffer);
WGPUNative2.symbols.wgpuQueueSubmit(queue, 1, commandArray.ptr);
WGPUBridge.surfacePresent(surface);
WGPUNative2.symbols.wgpuTextureViewRelease(textureView);
WGPUNative2.symbols.wgpuTextureRelease(texPtr);
WGPUNative2.symbols.wgpuCommandBufferRelease(commandBuffer);
WGPUNative2.symbols.wgpuCommandEncoderRelease(encoder);
}
setInterval(renderFrame, 16);
});
console.log("Agent Orchestrator (Electrobun) started!");

10
ui-electrobun/build/dev-linux-x64/AgentOrchestrator-dev/Resources/app/views/mainview/assets/index-D-cE0ySN.js Normal file
View file

File diff suppressed because one or more lines are too long

1
ui-electrobun/build/dev-linux-x64/AgentOrchestrator-dev/Resources/app/views/mainview/assets/index-DpJ88YKe.css Normal file
View file

File diff suppressed because one or more lines are too long

13
ui-electrobun/build/dev-linux-x64/AgentOrchestrator-dev/Resources/app/views/mainview/index.html Normal file
View file

@ -0,0 +1,13 @@
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8" />
<meta name="viewport" content="width=device-width, initial-scale=1.0" />
<title>Svelte App</title>
<script type="module" crossorigin src="/assets/index-D-cE0ySN.js"></script>
<link rel="stylesheet" crossorigin href="/assets/index-DpJ88YKe.css">
</head>
<body>
<div id="app"></div>
</body>
</html>

0
ui-electrobun/build/dev-linux-x64/wgpu-dev/Resources/build.json → ui-electrobun/build/dev-linux-x64/AgentOrchestrator-dev/Resources/build.json
View file

0
ui-electrobun/build/dev-linux-x64/wgpu-dev/Resources/main.js → ui-electrobun/build/dev-linux-x64/AgentOrchestrator-dev/Resources/main.js
View file

1
ui-electrobun/build/dev-linux-x64/AgentOrchestrator-dev/Resources/version.json Normal file
View file

@ -0,0 +1 @@
{"version":"0.0.1","hash":"dev","channel":"dev","baseUrl":"","name":"AgentOrchestrator-dev","identifier":"dev.agor.orchestrator"}

0
ui-electrobun/build/dev-linux-x64/wgpu-dev/bin/bspatch → ui-electrobun/build/dev-linux-x64/AgentOrchestrator-dev/bin/bspatch
View file

0
ui-electrobun/build/dev-linux-x64/wgpu-dev/bin/bun → ui-electrobun/build/dev-linux-x64/AgentOrchestrator-dev/bin/bun
View file

0
ui-electrobun/build/dev-linux-x64/wgpu-dev/bin/launcher → ui-electrobun/build/dev-linux-x64/AgentOrchestrator-dev/bin/launcher
View file

0
ui-electrobun/build/dev-linux-x64/wgpu-dev/bin/libNativeWrapper.so → ui-electrobun/build/dev-linux-x64/AgentOrchestrator-dev/bin/libNativeWrapper.so
View file

0
ui-electrobun/build/dev-linux-x64/wgpu-dev/bin/libasar.so → ui-electrobun/build/dev-linux-x64/AgentOrchestrator-dev/bin/libasar.so
View file

0
ui-electrobun/build/dev-linux-x64/wgpu-dev/bin/libwebgpu_dawn.so → ui-electrobun/build/dev-linux-x64/AgentOrchestrator-dev/bin/libwebgpu_dawn.so
View file

0
ui-electrobun/build/dev-linux-x64/wgpu-dev/bin/zig-zstd → ui-electrobun/build/dev-linux-x64/AgentOrchestrator-dev/bin/zig-zstd
View file

1
ui-electrobun/build/dev-linux-x64/wgpu-dev/Resources/version.json
View file

@ -1 +0,0 @@
{"version":"0.0.1","hash":"dev","channel":"dev","baseUrl":"","name":"wgpu-dev","identifier":"wgpu.electrobun.dev"}