Draw the whole 3D view in place of the client's renderer

The full view is now the default. While the renderer process covers the whole
view (Channel::covering, set after each frame it presents), the adapter skips
the client's renderer's clears and draws, decided per frame; the client's
renderer still gets state and resources, and draws again as soon as the
renderer process stops covering the view.

The client's window no longer gets WS_CLIPCHILDREN: the client draws when its
window gets WM_PAINT, which a window entirely covered by clipped children never
gets (it fell to about one frame a second). The flip model swap chain shows
above the client's drawing anyway.

Co-Authored-By: Claude Opus 5.5 <[email protected]>

adapter/engine.cpp

@@ -47,7 +47,9 @@ void Engine::enable2dFrameBuffer() { inner_->enable2dFrameBuffer(); }
 
 void Engine::clear(std::uint32_t flags, imvu::Color color)
 {
-    inner_->clear(flags, color);
+    if (innerDraws()) {
+        inner_->clear(flags, color);
+    }
     recorder_->add(Op::Clear, protocol::Clear{flags, color});
 }
 
@@ -242,6 +244,13 @@ imvu::SharedPtr<imvu::PiTextureRenderTarget> Engine::newTextureRenderTarget(imvu
 void Engine::beginRendering(imvu::PiRenderTarget* target)
 {
     inner_->beginRendering(target);
+    // Decided per frame: frames into render targets, and frames while the renderer process doesn't cover the view, are
+    // drawn by the client's renderer.
+    const bool takenOver = target == nullptr && recorder_->covering();
+    if (takenOver != takenOver_ && target == nullptr) {
+        log::info("engine: frame {}: {}", frames_, takenOver ? "drawn by the renderer process" : "drawn by the client's renderer");
+    }
+    takenOver_ = takenOver;
     if (target != nullptr && foreignLogged_ < 20) {
         ++foreignLogged_;
         log::info("engine: frame {}: drawing into a render target ({})", frames_, static_cast<void*>(target));
@@ -271,7 +280,9 @@ void Engine::drawTriangles(imvu::PiInternalIndexBuffer* indices, imvu::PiInterna
                            imvu::PiInternalVertexBuffer* normals, imvu::PiInternalVertexBuffer* texCoords,
                            imvu::PiInternalVertexBuffer* colors)
 {
-    inner_->drawTriangles(inner(indices), inner(positions), inner(normals), inner(texCoords), inner(colors));
+    if (innerDraws()) {
+        inner_->drawTriangles(inner(indices), inner(positions), inner(normals), inner(texCoords), inner(colors));
+    }
     ++(id(indices) != 0 && id(positions) != 0 ? stats_.triangles : stats_.foreignTriangles);
     recorder_->add(Op::DrawTriangles,
                    protocol::DrawTriangles{id(indices), id(positions), id(normals), id(texCoords), id(colors)});
@@ -279,13 +290,17 @@ void Engine::drawTriangles(imvu::PiInternalIndexBuffer* indices, imvu::PiInterna
 
 void Engine::drawLine(imvu::Vec3f from, imvu::Vec3f to, imvu::Color color)
 {
-    inner_->drawLine(from, to, color);
+    if (innerDraws()) {
+        inner_->drawLine(from, to, color);
+    }
     ++stats_.lines;
 }
 
 void Engine::drawPointSprites(const imvu::PointSpriteVector& sprites)
 {
-    inner_->drawPointSprites(sprites);
+    if (innerDraws()) {
+        inner_->drawPointSprites(sprites);
+    }
     ++stats_.sprites;
     if (sprites.first == nullptr || sprites.last <= sprites.first) {
         return;
@@ -304,7 +319,9 @@ void Engine::drawTrianglesFromMemory(std::uint32_t vertexCount, std::uint32_t in
                                      const imvu::VertexAttributeArray<imvu::Vec2f>& texCoords,
                                      const imvu::VertexAttributeArray<imvu::Color>& colors)
 {
-    inner_->drawTrianglesFromMemory(vertexCount, indexCount, indices, positions, normals, texCoords, colors);
+    if (innerDraws()) {
+        inner_->drawTrianglesFromMemory(vertexCount, indexCount, indices, positions, normals, texCoords, colors);
+    }
     ++(indices != nullptr ? stats_.indexed : stats_.unindexed);
     if (positions.data == nullptr || vertexCount == 0) {
         return;