wgpu backend: vertex-pulling main render pass

Stage 3 of the wgpu port. Replaces the clear-only render loop with the
full main shading pass:

  - WGSL port of the GL main shader. Vertex-pulling: the vertex storage
    buffer is read as array<u32> in the shader, with pos/normal/color
    decoded manually per vertex. baseVertex (set per draw to mesh's
    vertex offset) folds into @builtin(vertex_index) automatically;
    firstInstance carries the instance slot for @builtin(instance_index).
    No vertex-input layout — vertex pulling means no IA bindings.

  - Render pipeline bound to depth-32-float (write-on, less compare),
    back-face cull, CCW front face. Pre-multiplies a [-1,1]→[0,1] z-remap
    matrix onto Qt's projection so WebGPU's clip-z convention is met.

  - Two bind groups: group=0 per-frame (uniform with view-proj + key/fill
    light + hemisphere ambient), group=1 per-model (three read-only
    storage buffers: vertices, mesh quant, instances).

  - Depth texture is created lazily and recreated on surface resize.

  - Orbit camera state on WgpuViewportWindow with viewAll() that frames
    the union of all loaded models' world AABBs after the first load.
    Mouse navigation lands later.

  - Draw loop: one drawIndexed per (mesh, instance) pair per model. This
    is correct but CPU-heavy on dense scenes; stage 6 introduces the cull
    + compacted visible list that lets multiple instances of one mesh
    collapse to a single call, and the eventual GPU-driven cull (post
    sunset of the GL backend) goes further.

Verified on /tmp/quad_v13.ifcview (1 mesh, 1 instance) and on a real v13
sidecar baked from basic.ifc via the GL minimal viewer (3 meshes,
3 instances, 864 B verts). No wgpu validation errors fire across pipeline
creation, depth attachment, bind groups, or the draw loop on either.
Visual confirmation deferred until --screenshot lands (task #10) which
is being pulled forward next so we don't keep flying blind.

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

src/ifcviewer-wgpu/WgpuViewportWindow.h

@@ -70,6 +70,11 @@ public:
 
     size_t modelCount() const { return models_gpu_.size(); }
 
+    // Frame the union of all loaded models' world AABBs. No-op on empty
+    // scenes. Called automatically after the first model loads; clients
+    // can re-invoke to re-frame.
+    void viewAll();
+
 protected:
     void exposeEvent(QExposeEvent* event) override;
     void resizeEvent(QResizeEvent* event) override;
@@ -82,7 +87,13 @@ private:
     void render();
     void shutdown();
 
-    void flushPendingSidecarQueue();
+    bool  buildPipelines();
+    void  buildModelBindGroup(WgpuModelGpuData& m);
+    void  ensureDepthTexture(int w, int h);
+    void  releaseDepthTexture();
+    void  updateFrameUniforms();
+    void  flushPendingSidecarQueue();
+    bool  computeSceneAabb(float mn[3], float mx[3]) const;
 
     bool wgpu_initialized_ = false;
     bool surface_configured_ = false;
@@ -96,14 +107,46 @@ private:
     WGPUSurface       surface_        = nullptr;
     WGPUTextureFormat surface_format_ = WGPUTextureFormat_Undefined;
 
+    // Render pipeline + bind group layouts (built once after init).
+    WGPUShaderModule       main_shader_module_ = nullptr;
+    WGPUBindGroupLayout    frame_bgl_          = nullptr;  // group 0
+    WGPUBindGroupLayout    model_bgl_          = nullptr;  // group 1
+    WGPUPipelineLayout     pipeline_layout_    = nullptr;
+    WGPURenderPipeline     main_pipeline_      = nullptr;
+
+    // Per-frame uniform (view-proj + lighting), bound at group 0.
+    WGPUBuffer    frame_uniform_buffer_ = nullptr;
+    WGPUBindGroup frame_bind_group_     = nullptr;
+
+    // Depth attachment, recreated on surface resize.
+    WGPUTexture     depth_texture_ = nullptr;
+    WGPUTextureView depth_view_    = nullptr;
+    int             depth_w_       = 0;
+    int             depth_h_       = 0;
+
     QColor background_color_ = QColor("#202329");
 
+    // Camera (orbit, right-handed Y-up world → wait, BIM is +Z up).
+    // Mirrors the GL viewport's defaults; mouse navigation lands later.
+    float camera_target_[3] = { 0.0f, 0.0f, 0.0f };
+    float camera_distance_  = 50.0f;
+    float camera_yaw_deg_   = 45.0f;
+    float camera_pitch_deg_ = 30.0f;
+    float camera_fov_y_deg_ = 45.0f;
+    float camera_near_      = 0.1f;
+    float camera_far_       = 10000.0f;
+
     // Per-model state, keyed by viewport-assigned model_id.
     std::unordered_map<uint32_t, WgpuModelGpuData> models_gpu_;
     uint32_t next_model_id_ = 1;
 
     // Sidecar paths queued before init completes.
     std::deque<QString> pending_sidecars_;
+
+    // Set after the first model load triggers a viewAll(); prevents
+    // subsequent loads from snapping the camera away from where the
+    // user pointed it.
+    bool initial_view_applied_ = false;
 };
 
 #endif // WGPUVIEWPORTWINDOW_H