web-a2e 1.0.0

package/public/shaders/edge.glsl

@@ -0,0 +1,109 @@
+// Edge overlay fragment shader
+// Renders the screen edge highlight as a separate pass so it is
+// completely unaffected by CRT effects (scanlines, shadow mask, etc.).
+// Uses stable coordinates (no jitter / horizontal sync distortion).
+
+precision highp float;
+
+uniform float u_curvature;
+uniform float u_cornerRadius;
+uniform float u_edgeHighlight;
+uniform vec2 u_textureSize;
+uniform vec2 u_resolution;
+
+varying vec2 v_texCoord;
+
+// Screen curvature (must match crt.glsl)
+vec2 curveUV(vec2 uv) {
+    if (u_curvature < 0.001) return uv;
+
+    vec2 cc = uv - 0.5;
+    float dist = dot(cc, cc);
+    float distortion = dist * u_curvature * 0.5;
+    return uv + cc * distortion;
+}
+
+// Rounded rectangle alpha (must match crt.glsl)
+float roundedRectAlpha(vec2 uv, float radius) {
+    if (radius < 0.001) return 1.0;
+
+    vec2 centered = abs(uv - 0.5);
+    vec2 cornerDist = centered - (0.5 - radius);
+
+    if (cornerDist.x < 0.0 || cornerDist.y < 0.0) {
+        return 1.0;
+    }
+
+    float dist = length(cornerDist);
+    return 1.0 - smoothstep(radius - 0.005, radius + 0.005, dist);
+}
+
+// Edge highlight with uniform screen-pixel width and anti-aliasing.
+// Computes the gradient direction of the distance field so that line
+// width and AA are expressed in output pixels regardless of whether
+// the fragment sits on a straight edge or a corner arc.
+float edgeHighlightIntensity(vec2 uv, float radius) {
+    if (u_edgeHighlight < 0.001) return 0.0;
+
+    vec2 centered = abs(uv - 0.5);
+    vec2 cornerDist = centered - (0.5 - radius);
+
+    float distFromEdge;
+    vec2 gradDir; // unit-length gradient direction in UV space
+
+    if (cornerDist.x > 0.0 && cornerDist.y > 0.0) {
+        // Corner arc
+        float d = length(cornerDist);
+        distFromEdge = radius - d;
+        gradDir = cornerDist / d;
+    } else if (0.5 - centered.x < 0.5 - centered.y) {
+        // Nearest to a vertical edge (left / right)
+        distFromEdge = 0.5 - centered.x;
+        gradDir = vec2(1.0, 0.0);
+    } else {
+        // Nearest to a horizontal edge (top / bottom)
+        distFromEdge = 0.5 - centered.y;
+        gradDir = vec2(0.0, 1.0);
+    }
+
+    // Convert pixel counts to UV-space distances along the gradient.
+    // length(gradDir / u_resolution) gives UV units per output pixel
+    // in the direction perpendicular to the edge.
+    float uvPerPixel = length(gradDir / u_resolution);
+    float lineWidth = 2.5 * uvPerPixel;
+    float aa = 0.75 * uvPerPixel;
+
+    // Anti-aliased line: smoothstep at both inner and outer boundaries
+    float outer = smoothstep(-aa, aa, distFromEdge);
+    float inner = smoothstep(lineWidth + aa, lineWidth - aa, distFromEdge);
+
+    return outer * inner * u_edgeHighlight;
+}
+
+void main() {
+    // Use raw texture coordinates with only curvature applied.
+    // No jitter or horizontal sync — the edge stays perfectly stable.
+    vec2 curvedUV = curveUV(v_texCoord);
+
+    // Outside the rounded rectangle — fully transparent
+    float cornerAlpha = roundedRectAlpha(curvedUV, u_cornerRadius);
+    if (cornerAlpha < 0.001) {
+        gl_FragColor = vec4(0.0, 0.0, 0.0, 0.0);
+        return;
+    }
+
+    // Edge highlight
+    float edgeGlow = edgeHighlightIntensity(curvedUV, u_cornerRadius);
+    if (edgeGlow < 0.001) {
+        gl_FragColor = vec4(0.0, 0.0, 0.0, 0.0);
+        return;
+    }
+
+    // Separate the line shape (0–1) from the brightness.
+    // Use the shape as alpha so the line is fully opaque where it exists
+    // and fades only at its own anti-aliased boundaries — not at the
+    // rounded-rect corner alpha which would dim the corner arcs.
+    float lineAlpha = edgeGlow / u_edgeHighlight;
+    vec3 highlightColor = vec3(0.55, 0.55, 0.5) * u_edgeHighlight;
+    gl_FragColor = vec4(highlightColor, lineAlpha);
+}

package/public/shaders/vertex.glsl

@@ -0,0 +1,8 @@
+attribute vec2 a_position;
+attribute vec2 a_texCoord;
+varying vec2 v_texCoord;
+
+void main() {
+    gl_Position = vec4(a_position, 0.0, 1.0);
+    v_texCoord = a_texCoord;
+}

package/public/sw.js

@@ -0,0 +1,186 @@
+// Service Worker for Apple //e Emulator
+// Enables offline functionality by caching app assets
+
+// IMPORTANT: Bump this version when WASM or core JS files change
+const CACHE_VERSION = 3.3;
+const CACHE_NAME = `a2e-cache-v${CACHE_VERSION}`;
+
+// Files that should always be fetched fresh (network-first)
+const NETWORK_FIRST_FILES = ["/a2e.js", "/a2e.wasm"];
+
+// Assets to cache on install
+const PRECACHE_ASSETS = [
+  "/",
+  "/index.html",
+  "/manifest.json",
+  "/a2e.js",
+  "/a2e.wasm",
+  "/audio-worklet.js",
+  "/css/base.css",
+  "/css/layout.css",
+  "/css/monitor.css",
+  "/css/disk-drives.css",
+  "/css/controls.css",
+  "/css/modals.css",
+  "/css/debug-windows.css",
+  "/css/file-explorer.css",
+  "/css/documentation.css",
+  "/css/responsive.css",
+  "/images/drive-open.png",
+];
+
+// Install event - cache core assets
+self.addEventListener("install", (event) => {
+  event.waitUntil(
+    caches
+      .open(CACHE_NAME)
+      .then((cache) => {
+        console.log("[SW] Precaching app assets");
+        return cache.addAll(PRECACHE_ASSETS);
+      })
+      .then(() => {
+        // Activate immediately without waiting
+        return self.skipWaiting();
+      })
+      .catch((error) => {
+        console.error("[SW] Precache failed:", error);
+      }),
+  );
+});
+
+// Activate event - clean up old caches
+self.addEventListener("activate", (event) => {
+  event.waitUntil(
+    caches
+      .keys()
+      .then((cacheNames) => {
+        return Promise.all(
+          cacheNames
+            .filter((name) => name !== CACHE_NAME)
+            .map((name) => {
+              console.log("[SW] Deleting old cache:", name);
+              return caches.delete(name);
+            }),
+        );
+      })
+      .then(() => {
+        // Take control of all pages immediately
+        return self.clients.claim();
+      }),
+  );
+});
+
+// Check if URL should use network-first strategy
+function isNetworkFirst(url) {
+  // Explicit network-first files
+  if (
+    NETWORK_FIRST_FILES.some(
+      (file) => url.pathname === file || url.pathname.endsWith(file),
+    )
+  ) {
+    return true;
+  }
+  // Also use network-first for Vite JS bundles (they have hashed names)
+  if (url.pathname.includes("/assets/") && url.pathname.endsWith(".js")) {
+    return true;
+  }
+  return false;
+}
+
+// Fetch event - serve from cache, fall back to network
+self.addEventListener("fetch", (event) => {
+  const url = new URL(event.request.url);
+
+  // Skip non-GET requests
+  if (event.request.method !== "GET") {
+    return;
+  }
+
+  // Skip cross-origin requests (fonts, etc.)
+  if (url.origin !== self.location.origin) {
+    return;
+  }
+
+  // Use network-first for critical files (WASM, core JS)
+  if (isNetworkFirst(url)) {
+    event.respondWith(
+      fetch(event.request)
+        .then((networkResponse) => {
+          if (networkResponse && networkResponse.status === 200) {
+            // Update cache with fresh response
+            const responseToCache = networkResponse.clone();
+            caches.open(CACHE_NAME).then((cache) => {
+              cache.put(event.request, responseToCache);
+            });
+          }
+          return networkResponse;
+        })
+        .catch(() => {
+          // Network failed, try cache as fallback
+          return caches.match(event.request);
+        }),
+    );
+    return;
+  }
+
+  // Cache-first for other assets
+  event.respondWith(
+    caches.match(event.request).then((cachedResponse) => {
+      if (cachedResponse) {
+        // Return cached response
+        return cachedResponse;
+      }
+
+      // Not in cache - fetch from network
+      return fetch(event.request)
+        .then((networkResponse) => {
+          // Don't cache non-successful responses
+          if (!networkResponse || networkResponse.status !== 200) {
+            return networkResponse;
+          }
+
+          // Cache the new response for future use
+          // Clone because response can only be consumed once
+          const responseToCache = networkResponse.clone();
+
+          caches.open(CACHE_NAME).then((cache) => {
+            // Cache JS bundles and other assets dynamically
+            if (shouldCache(event.request.url)) {
+              cache.put(event.request, responseToCache);
+            }
+          });
+
+          return networkResponse;
+        })
+        .catch((error) => {
+          console.error("[SW] Fetch failed:", error);
+          // Could return an offline fallback page here
+          throw error;
+        });
+    }),
+  );
+});
+
+// Determine if a URL should be cached dynamically
+function shouldCache(url) {
+  // Cache JS bundles (Vite generates hashed names)
+  if (url.includes("/assets/") && url.endsWith(".js")) {
+    return true;
+  }
+  // Cache images
+  if (url.match(/\.(png|jpg|jpeg|gif|svg|webp)$/)) {
+    return true;
+  }
+  // Cache WASM
+  if (url.endsWith(".wasm")) {
+    return true;
+  }
+  return false;
+}
+
+// Listen for messages from the main app
+self.addEventListener("message", (event) => {
+  if (event.data === "skipWaiting") {
+    self.skipWaiting();
+  }
+});

package/scripts/generate_roms.sh

@@ -0,0 +1,69 @@
+#!/bin/bash
+
+# Generate C++ source file containing ROM data as byte arrays
+# Usage: generate_roms.sh <rom_directory> <output_file>
+
+ROM_DIR="$1"
+OUTPUT_FILE="$2"
+
+if [ -z "$ROM_DIR" ] || [ -z "$OUTPUT_FILE" ]; then
+    echo "Usage: $0 <rom_directory> <output_file>"
+    exit 1
+fi
+
+# Start the output file
+cat > "$OUTPUT_FILE" << 'EOF'
+// Auto-generated ROM data - DO NOT EDIT
+// Generated by generate_roms.sh
+
+#include <cstdint>
+#include <cstddef>
+
+namespace roms {
+
+EOF
+
+# Function to convert a binary file to a C array
+generate_array() {
+    local file="$1"
+    local name="$2"
+
+    if [ ! -f "$file" ]; then
+        echo "// ROM file not found: $file" >> "$OUTPUT_FILE"
+        echo "const uint8_t ${name}[] = {};" >> "$OUTPUT_FILE"
+        echo "const size_t ${name}_SIZE = 0;" >> "$OUTPUT_FILE"
+        echo "" >> "$OUTPUT_FILE"
+        return
+    fi
+
+    local size=$(wc -c < "$file" | tr -d ' ')
+
+    echo "// $(basename "$file")" >> "$OUTPUT_FILE"
+    echo "const uint8_t ${name}[] = {" >> "$OUTPUT_FILE"
+
+    xxd -i < "$file" | sed 's/^/    /' >> "$OUTPUT_FILE"
+
+    echo "};" >> "$OUTPUT_FILE"
+    echo "const size_t ${name}_SIZE = $size;" >> "$OUTPUT_FILE"
+    echo "" >> "$OUTPUT_FILE"
+}
+
+# Generate arrays for each ROM
+# Prefer combined ROM if available
+if [ -f "$ROM_DIR/342-0349-B-C0-FF.bin" ]; then
+    generate_array "$ROM_DIR/342-0349-B-C0-FF.bin" "ROM_SYSTEM"
+elif [ -f "$ROM_DIR/342-0135-A-CD.bin" ] && [ -f "$ROM_DIR/342-0134-A-EF.bin" ]; then
+    # Fallback to separate CD/EF ROMs - combine them
+    generate_array "$ROM_DIR/342-0135-A-CD.bin" "ROM_CD"
+    generate_array "$ROM_DIR/342-0134-A-EF.bin" "ROM_EF"
+fi
+
+generate_array "$ROM_DIR/342-0273-A-US-UK.bin" "ROM_CHAR"
+generate_array "$ROM_DIR/341-0027.bin" "ROM_DISK2"
+generate_array "$ROM_DIR/Thunderclock Plus ROM.bin" "ROM_THUNDERCLOCK"
+generate_array "$ROM_DIR/Apple Mouse Interface Card ROM - 342-0270-C.bin" "ROM_MOUSE"
+
+# Close namespace
+echo "} // namespace roms" >> "$OUTPUT_FILE"
+
+echo "Generated $OUTPUT_FILE"