@lampdotdev/lamp 0.0.0-stage → 0.36.2-nightly.16

package/Resources/GameKit/apple/LampPlayer.swift

@@ -0,0 +1,46 @@
+// Lamp's player: the one Mac app around a page (a game drawn with three.js, a screen, a web app), compiled once when
+// Lamp is built and copied for every game and screen made on this Mac, so none of them waits on a build or needs
+// Apple's tools. Nothing of any one game is in it: each copy reads what it is from its own bundle, which Lamp writes
+// as it makes the copy: its name and id, what kind of page it is and where that's served (LampPlayer in Info.plist),
+// what it's told about itself and Lamp (LampInstall, read by LampSupport.swift), its permission reasons and icon, and
+// the page itself in Resources/Web.
+//
+// The same Swift as an app Lamp compiles around a page (LampWebGame.swift, LampWebApp.swift, LampPage.swift and
+// LampSupport.swift), with what those have filled in by Lamp read here instead.
+import SwiftUI
+
+enum LampPlayer {
+    private static let info = Bundle.main.object(forInfoDictionaryKey: "LampPlayer") as? [String: Any] ?? [:]
+
+    /// The game's or screen's name, as Lamp wrote it.
+    static var name: String {
+        Bundle.main.object(forInfoDictionaryKey: "CFBundleDisplayName") as? String ?? ProcessInfo.processInfo.processName
+    }
+
+    /// A game's window, or any other page's. A copy that says neither was made wrong: it stops, saying so, rather than
+    /// open as something it isn't.
+    static let isGame: Bool = {
+        switch info["kind"] as? String {
+        case "game": return true
+        case "page": return false
+        default: fatalError("This app's Info.plist doesn't say what kind of page it is (LampPlayer.kind).")
+        }
+    }()
+
+    /// Where a page is served, which is where what it saves is kept: its kind's own address, for good. A game's is its
+    /// own (`LampGamePage`); any other page has to name one of the addresses Lamp gives.
+    static let scheme: String = {
+        guard let scheme = info["scheme"] as? String, ["lamp-screen", "lamp-web-app"].contains(scheme) else {
+            fatalError("This app's Info.plist doesn't name the address its page is served at (LampPlayer.scheme).")
+        }
+        return scheme
+    }()
+
+    /// The size a page made at a fixed size is laid out at ("1920x1080"), or nil for the window's.
+    static var canvas: CGSize? {
+        let sides = (info["canvas"] as? String)?.split(separator: "x").compactMap { Double($0) } ?? []
+        return sides.count == 2 ? CGSize(width: sides[0], height: sides[1]) : nil
+    }
+}
+
+if LampPlayer.isGame { LampGameApp.main() } else { LampWebApp.main() }

package/Resources/GameKit/apple/LampWebApp.swift

@@ -0,0 +1,63 @@
+// Lamp's common app around a page, on the Mac, the iPhone and the iPad: a window (or the whole screen) that is the
+// page in Web/, shown in a web view of its own by LampPage.swift. Lamp writes this file before every build.
+//
+// The page is served at {{PAGE_SCHEME}}://app/, the app's own address for good. A page laid out at a fixed size of its own
+// is zoomed to fill the window or screen; one that isn't is laid out at the window's size, as a browser would. A change
+// of the page goes in while the app is open (`LampPageLive`): the page opens again with what it saved.
+import SwiftUI
+import WebKit
+#if os(macOS)
+import AppKit
+#else
+import UIKit
+#endif
+
+@main
+struct LampWebApp: SwiftUI.App {
+    var body: some SwiftUI.Scene {
+        WindowGroup("{{NAME}}") {
+            LampWebAppView()
+                .ignoresSafeArea()
+                #if os(macOS)
+                .frame(minWidth: 480, minHeight: 270)
+                #else
+                .statusBarHidden()
+                .persistentSystemOverlays(.hidden)
+                #endif
+        }
+        #if os(macOS)
+        .defaultSize(width: 1280, height: 720)
+        .commands { LampCommands() }
+        #endif
+    }
+}
+
+@MainActor enum LampWebAppPage {
+    static let files = LampPageFiles(scheme: "{{PAGE_SCHEME}}")
+    static func make() -> WKWebView { LampPageView.make(files, live: true) }
+    /// The size the page is laid out at, or nil for the window's.
+    static let canvas: CGSize? = {{PAGE_CANVAS}}
+}
+
+struct LampWebAppView: View {
+    var body: some View {
+        ZStack {
+            Color.black
+            LampWebAppSurface()
+        }
+    }
+}
+
+#if os(macOS)
+struct LampWebAppSurface: NSViewRepresentable {
+    func makeNSView(context: Context) -> LampPageHolder { LampPageHolder(holding: LampWebAppPage.make(), canvas: LampWebAppPage.canvas) }
+    func updateNSView(_ holder: LampPageHolder, context: Context) {
+        DispatchQueue.main.async { if holder.window?.firstResponder !== holder.page { holder.window?.makeFirstResponder(holder.page) } }
+    }
+}
+#else
+struct LampWebAppSurface: UIViewRepresentable {
+    func makeUIView(context: Context) -> LampPageHolder { LampPageHolder(holding: LampWebAppPage.make(), canvas: LampWebAppPage.canvas) }
+    func updateUIView(_ holder: LampPageHolder, context: Context) {}
+}
+#endif

package/Resources/GameKit/apple/LampWebGame.swift

@@ -0,0 +1,87 @@
+// Lamp's game kit: the app around a game drawn with three.js, on the Mac, the iPhone and the iPad. Lamp writes this
+// file before every build; the game itself is the page in Web/, which this shows in a web view of its own.
+//
+// On the Mac it's one window with the game filling it, under a title bar with nothing in it, so Lamp's wand floats at
+// its top right and the chat opens beside it like any app's. On an iPhone or iPad it's the whole screen, on its side.
+// The page is served and shown by Lamp's common host for a page (LampPage.swift), at the game's own address
+// (lamp-game://app/); what it logs goes to the app's log, and its sound plays without a tap first.
+import SwiftUI
+import WebKit
+#if os(macOS)
+import AppKit
+#else
+import UIKit
+#endif
+
+@main
+struct LampGameApp: SwiftUI.App {
+    var body: some SwiftUI.Scene {
+        WindowGroup("{{NAME}}") {
+            LampGameScreen()
+        }
+        #if os(macOS)
+        .windowStyle(.hiddenTitleBar)
+        .defaultSize(width: 1280, height: 720)
+        .commands { LampCommands() }
+        #endif
+    }
+}
+
+struct LampGameScreen: View {
+    // How to play is the game's own to show, named for what the player holds (label() and glyph() in lamp-game.js), so
+    // nothing here lists keys that may not be the game's or the player's.
+    var body: some View {
+        ZStack {
+            Color.black
+            LampGameSurface()
+        }
+        .ignoresSafeArea()
+        #if os(macOS)
+        .frame(minWidth: 480, minHeight: 270)
+        #else
+        .statusBarHidden()
+        .persistentSystemOverlays(.hidden)
+        #endif
+    }
+}
+
+/// The page that is the game, served by Lamp's common host (LampPage.swift): it logs its own errors, and takes Lamp's
+/// changes while it's open (`LampPageLive`).
+@MainActor enum LampGamePage {
+    static let files = LampPageFiles(scheme: "lamp-game")
+
+    static func make() -> WKWebView { LampPageView.make(files, catchErrors: false, live: true, gameChanges: true) }
+}
+
+#if os(macOS)
+struct LampGameSurface: NSViewRepresentable {
+    func makeNSView(context: Context) -> LampKeyCatcher { LampKeyCatcher(holding: LampGamePage.make()) }
+    func updateNSView(_ view: LampKeyCatcher, context: Context) {
+        DispatchQueue.main.async { view.window?.makeFirstResponder(view.page) }
+    }
+}
+
+/// Holds the page and takes the keys it hands back. WebKit gives back every key the page doesn't cancel, and a game
+/// reads its keys without cancelling most of them, so each would reach the window, which beeps for a key nothing took.
+/// A shortcut with ⌘ goes to the menus first: the web view says it took every one, before the page has even seen it,
+/// so macOS looks no further and ⌘Q, ⌘W and ⌘H would do nothing while the game has the keyboard.
+final class LampKeyCatcher: LampPageHolder {
+    init(holding page: WKWebView) { super.init(holding: page) }
+
+    required init?(coder: NSCoder) { nil }
+
+    override func performKeyEquivalent(with event: NSEvent) -> Bool {
+        if event.modifierFlags.contains(.command), NSApp.mainMenu?.performKeyEquivalent(with: event) == true { return true }
+        return super.performKeyEquivalent(with: event)
+    }
+
+    override func keyDown(with event: NSEvent) {}
+    override func keyUp(with event: NSEvent) {}
+    override func doCommand(by selector: Selector) {}
+}
+#else
+struct LampGameSurface: UIViewRepresentable {
+    func makeUIView(context: Context) -> LampPageHolder { LampPageHolder(holding: LampGamePage.make()) }
+    func updateUIView(_ holder: LampPageHolder, context: Context) {}
+}
+#endif

package/Resources/GameKit/apple/Native.swift

@@ -0,0 +1,12 @@
+import Foundation
+
+/// What the page asks of this Mac, iPhone or iPad with `LampNative.call(name, args)` in Web/: the person's own things
+/// the page can't reach itself (mail, calendar, reminders, contacts, photos, location…), read with Lamp's building
+/// blocks in LampSupport.swift. Each call is registered here once, as the app opens.
+enum Native {
+    @MainActor static func register() {
+        // LampNative.on("events") { args in
+        //     try await LampCalendar.events(days: args["days"] as? Int ?? 7).map { ["title": $0.title, "start": $0.start] }
+        // }
+    }
+}

package/Resources/GameKit/build.sh

@@ -0,0 +1,55 @@
+#!/bin/sh
+# Lamp's game kit: builds the game. Lamp writes this file before every build and runs it in the app's sandbox; don't
+# edit it.
+#
+#   sh Lamp/build.sh xbox      the console's app: build/xbox/App.exe, and build/xbox.zip with it and Assets/
+#
+# The game is every .cpp and .c in Game/, and every .glsl there is a shader, compiled by sokol-shdc into
+# build/shaders/<name>.glsl.h for the game to include. $LAMP_WINDOWS is
+# where Lamp keeps the tools for the console: LLVM's clang-cl and lld-link, Microsoft's SDK and sokol-shdc.
+set -e
+cd "$(dirname "$0")/.."
+target="${1:-xbox}"
+tools="${LAMP_WINDOWS:?Lamp gives the build the folder with the tools for the console}"
+mkdir -p build/shaders
+
+# Shaders first: the build includes what they make.
+for shader in Game/*.glsl; do
+  [ -e "$shader" ] || continue
+  name=$(basename "$shader")
+  out="build/shaders/$name.h"
+  if [ ! -f "$out" ] || [ "$shader" -nt "$out" ] || [ "$tools/bin/sokol-shdc" -nt "$out" ]; then
+    "$tools/bin/sokol-shdc" --input "$shader" --output "$out" --slang hlsl5:metal_macos >&2 || { rm -f "$out"; exit 1; }
+  fi
+done
+
+# Lamp's own code, compiled again only when it changed (Lamp touches kit.stamp when any of its files does): it's
+# the slow part. The game's, every time.
+fresh() { [ -f "$1" ] && [ "$1" -nt "$2" ] && [ "$1" -nt Lamp/kit.stamp ]; }
+
+sdk="$tools/sdk"
+out=build/xbox
+mkdir -p "$out"
+cl="$tools/llvm/bin/clang-cl"
+# The flags as the shell's own argument list, so a folder name with a space in it (the home folder's) stays one argument.
+set -- --target=x86_64-pc-windows-msvc /std:c++20 /EHsc /O2 /MT /DWINAPI_FAMILY=WINAPI_FAMILY_APP /D_CRT_USE_WINAPI_FAMILY_DESKTOP_APP \
+  /DUNICODE /D_UNICODE /DNOMINMAX /DLAMP_XBOX=1 -imsvc "$sdk/crt/include" -imsvc "$sdk/sdk/include/ucrt" -imsvc "$sdk/sdk/include/um" \
+  -imsvc "$sdk/sdk/include/shared" -imsvc "$sdk/sdk/include/winrt" -imsvc "$sdk/sdk/include/cppwinrt" -ILamp -Ibuild/shaders -IGame
+fresh "$out/lamp_kit.obj" Lamp/lamp_kit.cpp || "$cl" "$@" /DSOKOL_D3D11 -w /c Lamp/lamp_kit.cpp /Fo"$out/lamp_kit.obj"
+fresh "$out/lamp_xbox.obj" Lamp/lamp_xbox.cpp || "$cl" "$@" -w /c Lamp/lamp_xbox.cpp /Fo"$out/lamp_xbox.obj"
+fresh "$out/lamp_sound.obj" Lamp/lamp_sound.cpp || "$cl" "$@" -w /c Lamp/lamp_sound.cpp /Fo"$out/lamp_sound.obj"
+objects="$out/lamp_kit.obj $out/lamp_xbox.obj $out/lamp_sound.obj"
+for source in Game/*.cpp Game/*.c; do
+  [ -e "$source" ] || continue
+  object="$out/$(basename "$source").obj"
+  case "$source" in *.c) "$cl" "$@" /TC /c "$source" /Fo"$object" ;;
+                    *) "$cl" "$@" /c "$source" /Fo"$object" ;; esac
+  objects="$objects $object"
+done
+# A static C++ runtime, so the console needs no package of Microsoft's beside the game's.
+"$tools/llvm/bin/lld-link" /OUT:"$out/App.exe" /APPCONTAINER /SUBSYSTEM:WINDOWS /MACHINE:X64 /ENTRY:wWinMainCRTStartup /NODEFAULTLIB \
+  /LIBPATH:"$sdk/crt/lib/onecore/x86_64" /LIBPATH:"$sdk/sdk/lib/ucrt/x86_64" /LIBPATH:"$sdk/sdk/lib/um/x86_64" \
+  $objects libcmt.lib libvcruntime.lib libcpmt.lib ucrt.lib WindowsApp.lib d3d11.lib dxgi.lib xaudio2.lib
+rm -f build/xbox.zip
+( cd "$out" && zip -qX ../xbox.zip App.exe )
+if [ -d Assets ]; then zip -qrXy build/xbox.zip Assets -x '*/.*' -x '.*'; fi

package/Resources/GameKit/lamp_game.h

@@ -0,0 +1,116 @@
+// Lamp's game kit: what a game is written against. Lamp writes this file before every build; don't edit it.
+//
+// The game is two functions, game_init and game_frame, drawn with sokol_gfx (sokol_gfx.h), with sokol_shape.h for
+// boxes, spheres and the like, sokol_debugtext.h and sokol_gl.h for text and lines, HandmadeMath.h for vectors and
+// matrices, cgltf.h for glTF models and stb_image.h for pictures, and sound through the functions below. On the Xbox
+// the host is a full-screen app drawing with Direct3D 11 at 1920x1080, 60 frames a second, and playing the sound
+// through XAudio2. Nothing here or in the game may call Windows or Apple APIs: everything the game needs from the
+// machine goes through the functions below.
+#pragma once
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+#include "sokol_gfx.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// The controller's buttons, as bits of LampPad.down, .pressed and .released.
+enum {
+    LAMP_A = 1 << 0, LAMP_B = 1 << 1, LAMP_X = 1 << 2, LAMP_Y = 1 << 3,
+    LAMP_LB = 1 << 4, LAMP_RB = 1 << 5,          // the bumpers
+    LAMP_MENU = 1 << 6, LAMP_VIEW = 1 << 7,      // ≡ (start) and ⧉ (back)
+    LAMP_UP = 1 << 8, LAMP_DOWN = 1 << 9, LAMP_LEFT = 1 << 10, LAMP_RIGHT = 1 << 11,   // the d-pad
+    LAMP_LSTICK = 1 << 12, LAMP_RSTICK = 1 << 13 // a stick pressed in
+};
+
+typedef struct LampPad {
+    bool connected;
+    float lx, ly, rx, ry;  // the sticks, -1 to 1, up and right positive, with a small dead zone already taken out
+    float lt, rt;          // the triggers, 0 to 1
+    uint32_t down;         // buttons held now
+    uint32_t pressed;      // buttons that went down since the last frame
+    uint32_t released;     // buttons that came up since the last frame
+} LampPad;
+
+typedef struct LampSetup {
+    int width, height;                 // 1920x1080
+    sg_pixel_format color_format;      // what the screen is drawn in: pass to sdtx/sgl/pipelines
+    sg_pixel_format depth_format;
+    int sample_count;                  // 1
+} LampSetup;
+
+typedef struct LampFrame {
+    double dt;          // seconds since the last frame: 1/60 at the console's pace
+    double time;        // seconds since the game started
+    uint64_t number;    // frames since the game started
+    int width, height;
+    LampPad pads[4];    // pads[0] is the first controller
+    sg_swapchain swapchain;   // give it to sg_begin_pass for the pass that draws the screen
+} LampFrame;
+
+// Written by the game.
+void game_init(const LampSetup* setup);
+void game_frame(const LampFrame* frame);   // draw one frame: sg_begin_pass(swapchain) … sg_end_pass(); sg_commit();
+
+// What the game reads and keeps.
+typedef struct LampFile { void* data; size_t size; } LampFile;   // data is NULL when there's nothing
+LampFile lamp_asset(const char* path);   // a file from the app's Assets/ folder ("models/ship.glb")
+LampFile lamp_load(const char* name);    // what the game saved under this name, or nothing
+bool lamp_save(const char* name, const void* data, size_t size);   // kept on the console between plays
+void lamp_free(LampFile file);
+
+// A line in the game's log, which Lamp reads (printf's format). Keep it to what helps: a few lines, not one a frame.
+void lamp_log(const char* format, ...);
+
+// Random numbers: use these, never rand() or the time, for anything random.
+uint32_t lamp_random(void);
+float lamp_random_float(void);   // 0 up to 1
+
+// The controller's rumble, 0 to 1 for its two motors, until called again with zeros.
+void lamp_rumble(int pad, float low, float high);
+
+// Sound: effects and music, mixed by the kit in stereo at 48 kHz on the console's speakers. Up to 32 effects play at
+// once (a 33rd takes the place of the oldest) and one piece of music beside them. Nothing here waits or takes time
+// from the frame: call these from game_init and game_frame as things happen.
+typedef struct LampSound { uint32_t id; } LampSound;   // id 0 is no sound (a file that didn't load): playing it does nothing
+
+// An effect from Assets/ (.wav, .ogg or .mp3), decoded whole once: load each in game_init, never per frame.
+LampSound lamp_sound_load(const char* path);
+
+// An effect made in code, for a game with no sound files: a wave from one pitch to another under a simple envelope.
+typedef enum LampWave { LAMP_SINE, LAMP_SQUARE, LAMP_TRIANGLE, LAMP_SAW, LAMP_NOISE } LampWave;
+typedef struct LampTone {
+    LampWave wave;
+    float from_hz, to_hz;              // the pitch at the start and at the end (the same for a steady note)
+    float attack, hold, release;       // seconds: rising, at full volume, fading out
+    float volume;                      // 0 to 1
+} LampTone;
+LampSound lamp_sound_tone(LampTone tone);
+// An effect from samples the game worked out itself: mono, -1 to 1, at `rate` a second (48000 is the mix's own).
+LampSound lamp_sound_samples(const float* samples, int count, int rate);
+
+// Plays an effect and gives the voice playing it (0 when it didn't play). volume 0 to 1, pan -1 (left) to 1 (right),
+// pitch 1 as recorded (2 an octave up). lamp_play_loop plays it over and over until stopped: an engine, a hum.
+int lamp_play(LampSound sound, float volume, float pan, float pitch);
+int lamp_play_loop(LampSound sound, float volume, float pan, float pitch);
+void lamp_voice_set(int voice, float volume, float pan, float pitch);   // change a voice as it plays
+void lamp_stop(int voice);                                              // a voice that ended already: nothing
+void lamp_stop_all(void);
+
+// Music from Assets/ (.ogg, .mp3 or .wav), read a little at a time as it plays and played over and over; a new
+// piece fades in over the one playing, and NULL fades it out. Keep music quiet under the effects (0.3 to 0.5).
+void lamp_music(const char* path, float volume);
+// Music the game made itself (lamp_sound_samples, lamp_sound_tone), played over and over as music: under the music
+// volume, fading in over what plays. A sound of id 0 fades the music out.
+void lamp_music_sound(LampSound sound, float volume);
+void lamp_music_volume(float volume);
+
+// The person's own volumes for effects and for music, 0 to 1 (0 is off): what the game's settings change, kept with
+// lamp_save. Both start at 1.
+void lamp_volume(float effects, float music);
+
+#ifdef __cplusplus
+}
+#endif

package/Resources/GameKit/lamp_host.h

@@ -0,0 +1,19 @@
+// Lamp's game kit: what the two hosts share, not for the game. Lamp writes this file before every build.
+#pragma once
+#include <stdint.h>
+#include "lamp_game.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+void lamp_host_seed(uint64_t seed);
+// Sets a pad's pressed and released from what was down the frame before.
+void lamp_host_edges(LampPad* pad, uint32_t before);
+float lamp_host_dead_zone(float value);
+// The mix: `frames` stereo frames at 48 kHz, interleaved, into `out`. Called by the host's sound thread on the
+// console; it takes a lock the game's sound calls take too.
+void lamp_host_mix(float* out, int frames);
+void lamp_host_sokol_log(const char* tag, uint32_t level, uint32_t item, const char* message, uint32_t line, const char* file, void* user);
+#ifdef __cplusplus
+}
+#endif

package/Resources/GameKit/lamp_kit.cpp

@@ -0,0 +1,61 @@
+// Lamp's game kit: the sokol libraries' code and what both hosts share. Lamp writes this file before every build.
+// Compiled for the Xbox's host, with SOKOL_D3D11.
+#if defined(SOKOL_D3D11)
+#define WIN32_LEAN_AND_MEAN
+#include <windows.h>
+// LoadLibraryA isn't in an app's part of the Windows API; LoadLibraryExA is, and loads the same system library
+// (sokol_gfx loads d3dcompiler_47.dll with it to compile the shaders on the console).
+#define LoadLibraryA(name) LoadLibraryExA(name, NULL, 0)
+#endif
+// The declarations first, then each library's code (sokol's headers allow being included again with SOKOL_IMPL).
+#include "lamp_game.h"
+#include "lamp_host.h"
+#define SOKOL_IMPL
+#include "sokol_gfx.h"
+#include "sokol_log.h"
+#include "sokol_gl.h"
+#include "sokol_debugtext.h"
+#include "sokol_shape.h"
+#define HANDMADE_MATH_IMPLEMENTATION
+#include "HandmadeMath.h"
+#define CGLTF_IMPLEMENTATION
+#include "cgltf.h"
+#define STB_IMAGE_IMPLEMENTATION
+#define STBI_NO_STDIO
+#include "stb_image.h"
+#include <stdlib.h>
+
+static uint64_t lamp_seed = 0x9E3779B97F4A7C15ull;
+
+void lamp_host_seed(uint64_t seed) { lamp_seed = seed ? seed : 0x9E3779B97F4A7C15ull; }
+
+// xorshift64*: small, fast and the same on both hosts.
+uint32_t lamp_random(void) {
+    lamp_seed ^= lamp_seed >> 12;
+    lamp_seed ^= lamp_seed << 25;
+    lamp_seed ^= lamp_seed >> 27;
+    return (uint32_t)((lamp_seed * 0x2545F4914F6CDD1Dull) >> 32);
+}
+
+float lamp_random_float(void) { return (float)(lamp_random() >> 8) / 16777216.0f; }
+
+void lamp_free(LampFile file) { free(file.data); }
+
+void lamp_host_edges(LampPad* pad, uint32_t before) {
+    pad->pressed = pad->down & ~before;
+    pad->released = before & ~pad->down;
+}
+
+float lamp_host_dead_zone(float value) {
+    const float zone = 0.12f;
+    if (value > zone) return (value - zone) / (1 - zone);
+    if (value < -zone) return (value + zone) / (1 - zone);
+    return 0;
+}
+
+void lamp_host_sokol_log(const char* tag, uint32_t level, uint32_t item, const char* message, uint32_t line, const char* file, void*) {
+    // Errors and warnings only: sokol's info lines would fill the log.
+    if (level > 1) return;
+    lamp_log("[%s] %s: %s (%s:%u)", tag ? tag : "sokol", level == 0 ? "panic" : "error", message ? message : "", file ? file : "", line);
+    (void)item;
+}