3 Commits

Author	SHA1	Message	Date
Dion Moult	584504dcdc	ifcviewer-web: stream user sidecars via Blob.slice byte ranges (#88) ... Picked files are no longer copied whole into the wasm heap. The browser File object stays in JS (Module.__ifcvFile) and is read lazily through Blob.slice byte ranges, so a 200-500 MB sidecar never enters wasm linear memory — only chunk-sized slices do. Mechanism (web-only, #if __EMSCRIPTEN__): - JS glue (EM_JS): ifcvFileSize + ifcvReadRangeInto — slice [off,off+n) of the File and copy it into a caller-provided heap pointer, then call back _ifcv_on_range_done. No malloc across the boundary; C pre-sizes the destination from the read plan. - webReadRangesAsync: reuses planSidecarReadRanges to coalesce a range set into Blob.slice reads (1 MB gap — each slice is an async hop), scatters them into a destination laid out in input order, and fires a continuation when the whole set lands. An in-flight map keyed by id survives unordered_map rehash (scratch buffers are heap-owned). - loadSidecarFromBlobWeb: async metadata load — head (16 B) -> index count -> tail-to-EOF -> parseSidecarHead/Tail -> applyCachedModel, then tags the model streaming_from_blob and frames it. - driveStreamingLoads: blob-sourced models route to beginWebChunkLoad (async vertex+index range reads -> applyStreamedChunk in the callback), holding is_loading until the bytes arrive. The embedded MEMFS sample keeps the synchronous fopen path. shell.html stashes the File and calls _load_sidecar_from_blob_c instead of FS.writeFile'ing the whole thing; EXPORTED_RUNTIME_METHODS=['FS'] dropped. Desktop is untouched (the new members + driveStreamingLoads branch are all emscripten-guarded). Web links clean; desktop rebuilds; 107/107 unit tests pass. Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>	2026-06-29 17:43:53 +10:00
Dion Moult	b123ee69d6	viewer: two-pass alpha transparency + Alt+X global x-ray cap ... ## The bug FZK-Haus windows rendered fully opaque despite every piece of the data path carrying alpha correctly: vertex format is RGBA u8x4, InstanceCpu/InstanceGpu carry color_override_rgba8 with its alpha byte, fs_main returns vec4(rgb, in.color.a). Cause: the main render pipeline's color target had `blend = nullptr`, which in wgpu disables the blend stage entirely — fragment RGBA overwrites the back buffer unmodified, alpha discarded. ## Why "just enable blend" isn't enough Two failure modes that don't go away with a one-liner: 1. `depthWriteEnabled = True` on the main pipeline would make a transparent window-frame pane occlude geometry behind it in depth, so the wall behind the window then fails the depth test and never draws — you'd see the silhouette of the window with whatever colour was in the back buffer before, not the wall. 2. Order-dependent blending across transparent surfaces in arbitrary cull order — overlapping transparent surfaces would shift colours as the camera moves. Standard fix for a BIM viewer is two-pass opaque-then-transparent. ## What this commit adds ### Per-mesh "has any alpha < 255" classifier * `ModelGpuData::mesh_has_alpha` (uint8_t vector, parallel to meshes). * Sized in `applyCachedModel`. * Populated in `applyStreamedChunk` by scanning each in-chunk mesh's vertex bytes for a vertex's alpha byte < 255 (offset 11 within the 12-byte vertex record — the 4th byte of the third u32, which the shader reads as `w2 >> 24`). Single chunk-arrival site covers both sidecar streaming and the worker-result drain. First-load IFC-without-sidecar geometry still routes opaque until the sidecar bake completes; A-path scan is deferred. ### Per-chunk opaque/transparent partition during cull * `Chunk::opaque_visible_vertices` / `opaque_visible_draws` (per-frame counts). * Transient `visible_draws_scratch_transparent` + `transparent_per_draw_vertex_counts` filled alongside the existing opaque half during the cull walk. Post-walk concat appends transparent entries onto the opaque half and continues the cumulative prefix-sum sequence — single buffer, single bind group, no doubling. * Classifier inside the cull lambda: `xray_active ? always_transparent : override_active ? (override.alpha < 255) : mesh_has_alpha[mesh_id]` ### Per-chunk uniform layout extension From `[total_draws, total_verts, 0, 0]` to `[total_draws, total_verts, opaque_verts, opaque_draws]`. The third slot is what `render()` passes as `firstVertex` to the transparent- pass draw call so the shader's vid lands in the transparent range of the same visible_draws_scratch buffer. ### `main_pipeline_transparent_` Copy of `main_pipeline_` with `color_target.blend = SrcAlpha / OneMinusSrcAlpha`. depthWriteEnabled stays True (see below). ### Two-pass `render()` Opaque pass (`main_pipeline_`, firstVertex=0, vertexCount=opaque_visible_vertices) then transparent pass (`main_pipeline_transparent_`, firstVertex=opaque_visible_vertices, vertexCount=total - opaque). Each loop skips empty halves so an opaque-only chunk costs one draw call, transparent-only one draw, mixed chunks two. ### depth_transparent.depthWriteEnabled = True (NOT off) Initially set False (standard "let further-back geometry paint through transparent front faces" trick) but that broke the edge- detect pass: edge detection reads the depth buffer to find silhouette discontinuities, and windows-without-depth meant the glass had no silhouette at all (panes looked like framed holes) and the edges of opaque geometry behind the glass painted through at full intensity. Keeping the write avoids that — trade-off is depth- test occlusion between transparent surfaces (closer occludes farther), which for BIM panes that don't overlap in screen space is invisible. Real fix for the overlap case is OIT or sort-back- to-front, not depth-write toggling. ## Alt+X global X-ray (drops in basically free) * `xray_alpha_cap` field on FrameUniforms + WGSL counterpart, default 1.0 (no effect). fs_main clamps `out.a = min(in.color.a, cap)`. * `ViewportWindow::xray_alpha_cap_` member, default 1.0. Alt+X toggles between 1.0 and 0.3. * Cull classifier sees `xray_alpha_cap_ < 1.0` and forces every instance into the transparent pass so the blend stage actually fires (an opaque-pass fragment with capped alpha would still overwrite the back buffer). * No per-instance state mutation needed — toggle is a single float in a uniform plus a re-cull. Excluding objects from x-ray later would mean tagging them so the classifier skips the force- transparent branch for them, also small. Stress-tested on FZK-Haus: window glass visibly translucent with correct silhouette edges; Alt+X turns the whole scene to a tinted ghost of itself and back without artefact. Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>	2026-06-04 12:58:50 +10:00
Dion Moult	8ab5c31e75	refactor: merge ifcviewer-wgpu into ifcviewer, drop Wgpu prefix ... The GL backend is gone (task #53). The wgpu/non-wgpu folder split and the Wgpu* class prefix were both disambiguation artefacts from the overlap period — now pure dead weight. ## Folder + library merge * `src/ifcviewer-wgpu/` → folded into `src/ifcviewer/` (git mv tracks every file as a rename so blame/log history survives). * `src/ifcviewer-wgpu-minimal/` → `src/ifcviewer-minimal/` (the exe was already named `IfcViewerMinimal`; this just brings the folder + CMake target name into line). * `src/ifcviewer-wgpu/tests/test_wgpu_{selection,visibility}.cpp` → `src/ifcviewer/tests/test_{selection,visibility}.cpp`, folded into the existing `add_ifcviewer_unit_test(...)` helper. * The `IfcViewerWgpu` static library is dissolved — its sources become part of the unified `IfcViewer` static library, which now bundles scene/loader + renderer in one target. The pre-merge circular dependency (IfcViewer linking IfcViewerWgpu just to get the ViewportWindow.h include path that SceneLoader.h needs) goes away. * The wgpu-native FetchContent block, the Cocoa/QuartzCore link on Apple, the OBJCXX-enabled `.mm` source, and the wgpu-native runtime install all move into `src/ifcviewer/CMakeLists.txt` unchanged. ## Type renames (Wgpu prefix dropped from every Wgpu* identifier) WgpuAreaMeasurement → AreaMeasurement WgpuBufferPool → BufferPool WgpuLengthMeasurement → LengthMeasurement WgpuMetalSurface → MetalSurface WgpuModelGpuData → ModelGpuData WgpuOverlayFrame → OverlayFrame WgpuOverlayRenderer → OverlayRenderer WgpuSectionPlane → SectionPlane WgpuSelectionState → SelectionState WgpuStreamingLoader → StreamingLoader WgpuStreamingThread → StreamingThread WgpuViewportWindow → ViewportWindow WgpuVisibilityState → VisibilityState CMake target IfcViewerWgpuMinimal → IfcViewerMinimal (exe name was already this since wgpu shipped as default). Deliberately kept: `onWgpuLog` (wgpu-native log callback — names a binding to an external API, not one of *our* types), and the WGPU* enum/struct prefixes from wgpu-native's own headers. `WgpuMemProbe` lives in the separate `src/wgpu-mem-probe/` standalone diagnostic project and isn't touched. ## Include-path updates Every `#include "../ifcviewer-wgpu/Wgpu<X>.h"` → `"../ifcviewer/<X>.h"`, every in-directory `#include "Wgpu<X>.h"` → `"<X>.h"`. Includes from sibling subdirectories (modules/, etc.) are updated to point at `../../../ifcviewer/` instead of `../../../ifcviewer-wgpu/`. ## cmake/CMakeLists.txt simplification The redundant `add_subdirectory(ifcviewer-wgpu)` blocks (one inside the BUILD_BONSAIVIEWER fan-in, one in the BONSAIVIEWER-less standalone block) collapse into a single unconditional `add_subdirectory(../src/ifcviewer ifcviewer)`. The standalone block keeps only `wgpu-mem-probe` (the diagnostic tool, unrelated to the viewer lib). ## Verification * Full build green: `IfcViewer` static lib, `IfcViewerMinimal` exe, `BonsaiViewer` exe, all four pre-existing ifcviewer unit tests, and the two new-location tests (`test_selection`, `test_visibility`). * No stray `Wgpu<X>` identifier remains across `src/ifcviewer/`, `src/bonsaiviewer/`, `src/ifcviewer-minimal/` (verified by grep). * Renames tracked by git as `R` entries — `git log --follow` on ViewportWindow.cpp etc. continues to show history through the move. Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>	2026-06-04 11:11:14 +10:00