remove gitignore from pkg see drager/wasm-pack#1408

Author: 0dpe

pkg/README.md

@@ -0,0 +1,88 @@
+# path_tracer
+
+A cross-platform **demo** GPU ray tracer built with Rust and WebGPU, demonstrating modern GPU programming techniques. Runs natively on Windows, macOS, and Linux, as well as in web browsers from the same codebase.
+
+## Why WebGPU?
+
+GPU programming offers massive parallelism for graphics and compute workloads, but has historically been fragmented across incompatible APIs:
+
+* **OpenGL**: Aging API with inconsistent driver support
+* **DirectX**: Windows-only
+* **Metal**: Apple platforms only
+* **Vulkan**: Verbose, complex to learn
+* **CUDA & OpenCL**: Compute-focused, vendor-specific or limited adoption
+
+Unlike CPU code that runs anywhere with minimal changes, GPU developers traditionally had to choose between portability and access to modern features.
+
+WebGPU solves this. It's a modern, cross-platform GPU API that provides a single interface across all major platforms and browsers. WebGPU maps efficiently to DirectX 12, Metal, and Vulkan under the hood without sacrificing performance. The W3C WebGPU spec reached a Candidate Recommendation Draft in 2025.
+
+This project demonstrates WebGPU capabilities using **wgpu** (the Rust implementation) and serves as a practical learning resource for modern GPU programming.
+
+## What It Does
+
+This is a real-time GPU ray tracer that:
+
+* Renders 3D scenes loaded from glTF (.glb) files (tested with Blender exported files)
+* Runs the same Rust codebase natively (desktop) and on the web (via WebAssembly)
+* Uses compute shaders for ray-triangle intersection (Möller-Trumbore algorithm)
+* Handles first-person camera controls with keyboard and mouse input
+* Demonstrates core WebGPU (wgpu v27) concepts: bind groups, compute/vertex/fragment pipelines, WGSL compute/vertex/fragment shaders, storage textures, etc.
+
+**Current Status**: This is a basic ray tracer skeleton (~1300 lines of code in total). It traces primary rays only and lacks features like recursive path tracing or acceleration structures (BVH).
+
+## Build & Run
+
+### Prerequisites
+
+1. Install [Rust](https://rustup.rs/)
+2. For web builds, install wasm-pack:
+
+   ```bash
+   cargo install wasm-pack
+   ```
+
+3. For web hosting on localhost, use Python's built-in server or install simple-http-server:
+
+   ```bash
+   cargo install simple-http-server
+   ```
+
+### Native (Desktop)
+
+```bash
+git clone https://github.com/0dpe/path_tracer.git
+cd path_tracer
+cargo run --release
+```
+
+**Controls**: Left click the window, then use <kbd>W</kbd><kbd>A</kbd><kbd>S</kbd><kbd>D</kbd> + <kbd>Left Shift</kbd>/<kbd>Space</kbd> to move, mouse to look around. Press <kbd>Esc</kbd> or click again to release cursor.
+
+### Web (Browser)
+
+```bash
+git clone https://github.com/0dpe/path_tracer.git
+cd path_tracer
+wasm-pack build --target web
+
+# serve the folder
+simple-http-server
+# Or: python -m http.server 8000
+```
+
+Open Chrome at `http://localhost:8000` and click on `index.html`. Same controls as native.
+
+> [!NOTE]
+> Requires a browser with WebGPU support (Chrome stable, Safari/Firefox with flags enabled as of 2025).
+
+## General Crate Structure
+
+```text
+path_tracer/
+├── assets/              # .glb scene files
+├── src/
+│   ├── render/          # WebGPU setup, shaders, scene loading
+│   ├── lib.rs           # Window management and event loop
+│   └── main.rs          # Native entry point
+├── Cargo.toml           # Dependencies and wgpu version
+└── index.html           # Webpage
+```

pkg/package.json

@@ -0,0 +1,15 @@
+{
+  "name": "path_tracer",
+  "type": "module",
+  "version": "0.1.0",
+  "files": [
+    "path_tracer_bg.wasm",
+    "path_tracer.js",
+    "path_tracer.d.ts"
+  ],
+  "main": "path_tracer.js",
+  "types": "path_tracer.d.ts",
+  "sideEffects": [
+    "./snippets/*"
+  ]
+}

pkg/path_tracer.d.ts

@@ -0,0 +1,43 @@
+/* tslint:disable */
+/* eslint-disable */
+export function run(): void;
+
+export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
+
+export interface InitOutput {
+  readonly memory: WebAssembly.Memory;
+  readonly run: () => void;
+  readonly __externref_table_alloc: () => number;
+  readonly __wbindgen_export_1: WebAssembly.Table;
+  readonly __wbindgen_exn_store: (a: number) => void;
+  readonly __wbindgen_malloc: (a: number, b: number) => number;
+  readonly __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
+  readonly __wbindgen_free: (a: number, b: number, c: number) => void;
+  readonly __wbindgen_export_6: WebAssembly.Table;
+  readonly closure704_externref_shim: (a: number, b: number, c: any) => void;
+  readonly closure708_externref_shim: (a: number, b: number, c: any, d: any) => void;
+  readonly wasm_bindgen__convert__closures_____invoke__h958c97b594d4e963: (a: number, b: number) => void;
+  readonly closure805_externref_shim: (a: number, b: number, c: any) => void;
+  readonly __wbindgen_start: () => void;
+}
+
+export type SyncInitInput = BufferSource | WebAssembly.Module;
+/**
+* Instantiates the given `module`, which can either be bytes or
+* a precompiled `WebAssembly.Module`.
+*
+* @param {{ module: SyncInitInput }} module - Passing `SyncInitInput` directly is deprecated.
+*
+* @returns {InitOutput}
+*/
+export function initSync(module: { module: SyncInitInput } | SyncInitInput): InitOutput;
+
+/**
+* If `module_or_path` is {RequestInfo} or {URL}, makes a request and
+* for everything else, calls `WebAssembly.instantiate` directly.
+*
+* @param {{ module_or_path: InitInput | Promise<InitInput> }} module_or_path - Passing `InitInput` directly is deprecated.
+*
+* @returns {Promise<InitOutput>}
+*/
+export default function __wbg_init (module_or_path?: { module_or_path: InitInput | Promise<InitInput> } | InitInput | Promise<InitInput>): Promise<InitOutput>;