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>
This commit is contained in:
Dion Moult
2026-06-04 11:11:14 +10:00
parent 7f87408b78
commit 8ab5c31e75
48 changed files with 705 additions and 815 deletions
+5
View File
@@ -52,6 +52,11 @@ add_ifcviewer_unit_test(test_sidecar_cache
add_ifcviewer_unit_test(test_instanced_geometry)
# Header-only state-machine tests for the renderer subsystems (selection,
# visibility). Subjects are inline in their .h files, so no SOURCES needed.
add_ifcviewer_unit_test(test_selection)
add_ifcviewer_unit_test(test_visibility)
# Federation is Qt-derived (QObject + signals). It has to pull Qt6 in
# directly and enable AUTOMOC for the Q_OBJECT moc-generation.
find_package(Qt${QT_VERSION} COMPONENTS Core Gui Test REQUIRED PATHS ${QT_DIR})
+256
View File
@@ -0,0 +1,256 @@
/********************************************************************************
* *
* This file is part of IfcOpenShell. *
* *
* IfcOpenShell is free software: you can redistribute it and/or modify *
* it under the terms of the Lesser GNU General Public License as published by *
* the Free Software Foundation, either version 3.0 of the License, or *
* (at your option) any later version. *
* *
* IfcOpenShell is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* Lesser GNU General Public License for more details. *
* *
* You should have received a copy of the Lesser GNU General Public License *
* along with this program. If not, see <http://www.gnu.org/licenses/>. *
* *
********************************************************************************/
// Tier-1 coverage of SelectionState — the CPU-side selection set + active
// id used by the wgpu viewport. The class is pure stdlib (no Qt, no QObject),
// so the test exercises the state machine directly. The GPU-side flags SSBO
// is filled via fillFlagsArray; that pure-function path is also covered.
#include "SelectionState.h"
#include <catch2/catch_test_macros.hpp>
#include <vector>
TEST_CASE("SelectionState starts empty with no active id", "[wgpu-selection]") {
SelectionState sel;
REQUIRE(sel.count() == 0);
REQUIRE(sel.activeId() == 0);
REQUIRE_FALSE(sel.contains(1));
REQUIRE_FALSE(sel.dirty());
}
TEST_CASE("replace(id) selects a single id and makes it active",
"[wgpu-selection]") {
SelectionState sel;
sel.replace(5);
REQUIRE(sel.count() == 1);
REQUIRE(sel.contains(5));
REQUIRE(sel.activeId() == 5);
REQUIRE(sel.dirty());
}
TEST_CASE("replace(0) clears the selection", "[wgpu-selection]") {
SelectionState sel;
sel.replace(5);
sel.markClean();
sel.replace(0);
REQUIRE(sel.count() == 0);
REQUIRE(sel.activeId() == 0);
REQUIRE(sel.dirty());
}
TEST_CASE("add(id) appends to the set and steals active", "[wgpu-selection]") {
SelectionState sel;
sel.replace(1);
sel.markClean();
sel.add(2);
REQUIRE(sel.count() == 2);
REQUIRE(sel.contains(1));
REQUIRE(sel.contains(2));
// Each click should drive the properties panel to the most recently
// touched object, so active follows the last add — distinct from GL's
// addToSelection (which kept the prior active).
REQUIRE(sel.activeId() == 2);
REQUIRE(sel.dirty());
}
TEST_CASE("add(0) is ignored", "[wgpu-selection]") {
SelectionState sel;
sel.replace(1);
sel.markClean();
sel.add(0);
REQUIRE(sel.count() == 1);
REQUIRE(sel.activeId() == 1);
REQUIRE_FALSE(sel.dirty()); // no-op didn't flip the flag
}
TEST_CASE("remove(non-active) keeps active", "[wgpu-selection]") {
SelectionState sel;
sel.replace(1);
sel.add(2);
sel.add(3);
REQUIRE(sel.activeId() == 3);
sel.markClean();
sel.remove(1);
REQUIRE(sel.count() == 2);
REQUIRE_FALSE(sel.contains(1));
REQUIRE(sel.activeId() == 3); // still the most recently touched
REQUIRE(sel.dirty());
}
TEST_CASE("remove(active) falls back to some remaining id", "[wgpu-selection]") {
SelectionState sel;
sel.replace(1);
sel.add(2);
sel.add(3);
REQUIRE(sel.activeId() == 3);
sel.remove(3);
REQUIRE(sel.count() == 2);
REQUIRE_FALSE(sel.contains(3));
// Active falls back to *some* remaining id (implementation picks the
// unordered_set's first element; documenting non-determinism rather
// than the specific choice).
const uint32_t a = sel.activeId();
REQUIRE((a == 1 || a == 2));
REQUIRE(sel.contains(a));
}
TEST_CASE("remove(last id) clears active", "[wgpu-selection]") {
SelectionState sel;
sel.replace(7);
REQUIRE(sel.activeId() == 7);
sel.remove(7);
REQUIRE(sel.count() == 0);
REQUIRE(sel.activeId() == 0);
}
TEST_CASE("remove(non-existent) is a no-op for state, no dirty flag",
"[wgpu-selection]") {
SelectionState sel;
sel.replace(1);
sel.markClean();
sel.remove(99);
REQUIRE(sel.count() == 1);
REQUIRE(sel.activeId() == 1);
REQUIRE_FALSE(sel.dirty());
}
TEST_CASE("remove(0) is ignored", "[wgpu-selection]") {
SelectionState sel;
sel.replace(1);
sel.markClean();
sel.remove(0);
REQUIRE(sel.count() == 1);
REQUIRE_FALSE(sel.dirty());
}
TEST_CASE("toggle adds when absent, removes when present", "[wgpu-selection]") {
SelectionState sel;
sel.toggle(5);
REQUIRE(sel.contains(5));
REQUIRE(sel.activeId() == 5);
sel.toggle(6);
REQUIRE(sel.contains(6));
REQUIRE(sel.activeId() == 6); // last add steals active
sel.toggle(5); // remove non-active — active unchanged
REQUIRE_FALSE(sel.contains(5));
REQUIRE(sel.activeId() == 6);
sel.toggle(6); // remove active — fallback (set empty → 0)
REQUIRE(sel.count() == 0);
REQUIRE(sel.activeId() == 0);
}
TEST_CASE("toggle(0) is ignored", "[wgpu-selection]") {
SelectionState sel;
sel.markClean();
sel.toggle(0);
REQUIRE(sel.count() == 0);
REQUIRE_FALSE(sel.dirty());
}
TEST_CASE("clear empties; no-op when already empty", "[wgpu-selection]") {
SelectionState sel;
sel.clear(); // already empty
REQUIRE_FALSE(sel.dirty());
sel.replace(1);
sel.markClean();
sel.clear();
REQUIRE(sel.count() == 0);
REQUIRE(sel.activeId() == 0);
REQUIRE(sel.dirty());
}
TEST_CASE("markClean clears the dirty flag", "[wgpu-selection]") {
SelectionState sel;
sel.replace(5);
REQUIRE(sel.dirty());
sel.markClean();
REQUIRE_FALSE(sel.dirty());
// Subsequent mutation re-arms the flag.
sel.add(6);
REQUIRE(sel.dirty());
}
TEST_CASE("selectionIds returns the live set", "[wgpu-selection]") {
SelectionState sel;
sel.add(1);
sel.add(2);
sel.add(3);
const auto& ids = sel.selectionIds();
REQUIRE(ids.size() == 3);
REQUIRE(ids.count(1) == 1);
REQUIRE(ids.count(2) == 1);
REQUIRE(ids.count(3) == 1);
}
TEST_CASE("fillFlagsArray packs selected/active bits per object_id",
"[wgpu-selection]") {
SelectionState sel;
sel.add(1);
sel.add(3); // active is now 3
std::vector<uint32_t> flags;
sel.fillFlagsArray(flags, 8);
REQUIRE(flags.size() == 8);
REQUIRE(flags[0] == 0u); // sentinel
REQUIRE(flags[1] == 1u); // selected, not active
REQUIRE(flags[2] == 0u);
REQUIRE(flags[3] == (1u | 2u)); // selected + active
REQUIRE(flags[4] == 0u);
REQUIRE(flags[5] == 0u);
REQUIRE(flags[6] == 0u);
REQUIRE(flags[7] == 0u);
}
TEST_CASE("fillFlagsArray drops ids past the entries cap",
"[wgpu-selection]") {
SelectionState sel;
sel.add(1);
sel.add(100); // active is 100
std::vector<uint32_t> flags;
sel.fillFlagsArray(flags, 4);
REQUIRE(flags.size() == 4);
REQUIRE(flags[1] == 1u);
// id 100 is out of range — should not write to flags[2]/[3]/etc.
REQUIRE(flags[2] == 0u);
REQUIRE(flags[3] == 0u);
}
+118
View File
@@ -0,0 +1,118 @@
/********************************************************************************
* *
* This file is part of IfcOpenShell. *
* *
* IfcOpenShell is free software: you can redistribute it and/or modify *
* it under the terms of the Lesser GNU General Public License as published by *
* the Free Software Foundation, either version 3.0 of the License, or *
* (at your option) any later version. *
* *
* IfcOpenShell is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* Lesser GNU General Public License for more details. *
* *
* You should have received a copy of the Lesser GNU General Public License *
* along with this program. If not, see <http://www.gnu.org/licenses/>. *
* *
********************************************************************************/
// Tier-1 coverage of VisibilityState — the per-element hidden-id set
// consulted in cull. The class is pure stdlib; this test exercises its
// primitives directly. Bulk hide/isolate/show-all semantics live in
// ViewportWindow (which composes VisibilityState + the model
// instance lists) and would need an integration test, not a Tier-1 unit.
#include "VisibilityState.h"
#include <catch2/catch_test_macros.hpp>
TEST_CASE("VisibilityState starts empty", "[wgpu-visibility]") {
VisibilityState vis;
REQUIRE(vis.hiddenCount() == 0);
REQUIRE_FALSE(vis.isHidden(0)); // 0 is the "no object" sentinel
REQUIRE_FALSE(vis.isHidden(1));
REQUIRE_FALSE(vis.isHidden(1u << 20));
}
TEST_CASE("hide(id) records the id; isHidden reflects it",
"[wgpu-visibility]") {
VisibilityState vis;
vis.hide(1);
vis.hide(2);
vis.hide(3);
REQUIRE(vis.hiddenCount() == 3);
REQUIRE(vis.isHidden(1));
REQUIRE(vis.isHidden(2));
REQUIRE(vis.isHidden(3));
REQUIRE_FALSE(vis.isHidden(4));
}
TEST_CASE("hide is idempotent", "[wgpu-visibility]") {
VisibilityState vis;
vis.hide(5);
vis.hide(5);
vis.hide(5);
REQUIRE(vis.hiddenCount() == 1);
REQUIRE(vis.isHidden(5));
}
TEST_CASE("hide(0) is ignored", "[wgpu-visibility]") {
VisibilityState vis;
vis.hide(0);
REQUIRE(vis.hiddenCount() == 0);
REQUIRE_FALSE(vis.isHidden(0));
}
TEST_CASE("show(id) removes a previously hidden id",
"[wgpu-visibility]") {
VisibilityState vis;
vis.hide(1);
vis.hide(2);
vis.show(1);
REQUIRE(vis.hiddenCount() == 1);
REQUIRE_FALSE(vis.isHidden(1));
REQUIRE(vis.isHidden(2));
}
TEST_CASE("show(non-hidden) is a no-op", "[wgpu-visibility]") {
VisibilityState vis;
vis.hide(1);
vis.show(99); // never hidden
REQUIRE(vis.hiddenCount() == 1);
REQUIRE(vis.isHidden(1));
}
TEST_CASE("clear() drops every hidden id", "[wgpu-visibility]") {
VisibilityState vis;
vis.hide(1);
vis.hide(2);
vis.hide(3);
vis.clear();
REQUIRE(vis.hiddenCount() == 0);
REQUIRE_FALSE(vis.isHidden(1));
REQUIRE_FALSE(vis.isHidden(2));
REQUIRE_FALSE(vis.isHidden(3));
}
TEST_CASE("hiddenIds returns the live set", "[wgpu-visibility]") {
VisibilityState vis;
vis.hide(10);
vis.hide(20);
vis.hide(30);
const auto& ids = vis.hiddenIds();
REQUIRE(ids.size() == 3);
REQUIRE(ids.count(10) == 1);
REQUIRE(ids.count(20) == 1);
REQUIRE(ids.count(30) == 1);
REQUIRE(ids.count(40) == 0);
}