How can I change an existing viewport?

[gwaldron]

I would like to alter a camera's viewport at runtime. Before compile I set:

view->viewDependentState->viewportData->properties.dataVariance = vsg::DYNAMIC_DATA;

And some of the thing I've tried are:

view->camera->viewportState->viewports[0].x = value;
...
view->camera->viewportState = vsg::ViewportState::create(...);
...
view->viewDependentState->viewportData->at(0).x = value;
view->viewDependentState->viewportData->dirty();

[robertosfield]

So far I have only done Viewport resizes in the context of window resizing. I have not yet written a testbed/example that does independent resizing of ViewportState.

The Camera's ViewportState is what controls what is rendered, but in Vulkan one also has to update the GraphicsPipeline objects in the scene to reflect this value. The WindowResizeHandler passes on updates to viewport dimensions. It might be this this is usable as is, or it might be that we need to expose the viewport size capability in a more friendly way.

The viewDependentState tracks the viewport state in a way that can be accessed from sharers rather than defines it you should be able to safely ignore settings this.

[gwaldron]

Thanks. I forgot about the viewport state in the pipeline. I will see if using or adapting WindowResizeHandler makes sense.

[robertosfield]

Today I did some work for a client that wanted to swap two Views, to test this out I modified the vsgmultiviews example so that the insert view would be swapped with the main view when you press 's', then set about getting it to work.

I found I could easily just reuse the WindowResizeHandler so I created a new UpdateGraphicsPiplines utility class that works on similar lines, but is a bit more general, this is now checked in VSG master:

4ed91af

The key part of the update vsgmultiviews example is in the ViewHandler:

https://github.com/vsg-dev/vsgExamples/blob/master/examples/app/vsgmultiviews/vsgmultiviews.cpp#L39

The code has to fine the vsg::Views assigned to the vsg::RenderGraph then swap the first two of them so that the insert view now becomes the first rendered, then the original first map view becomes the second one rendered. The next change to them is to swap the two View's Camera's ViewportState objects so they then have the others viewport/scissor settings, then finally we run the vsg::UpdateGraphicsPipeline.

The code looks like:

           std::vector<std::pair<size_t, vsg::ref_ptr<vsg::View>>> views;
            for(size_t i  = 0; i < renderGraph->children.size(); ++i)
            {
                if (auto view = renderGraph->children[i].cast<vsg::View>()) views.emplace_back(i, view);
            }

            if (views.size()<2) return;

            auto renderPass = renderGraph->getRenderPass();
            if (!renderPass) return;

            auto view0 = views[0].second;
            auto viewport0 = view0->camera->getViewport();
            VkExtent2D extent0{ static_cast<uint32_t>(viewport0.width), static_cast<uint32_t>(viewport0.height)};

            auto view1 = views[1].second;
            auto viewport1 = view1->camera->getViewport();
            VkExtent2D extent1{ static_cast<uint32_t>(viewport1.width), static_cast<uint32_t>(viewport1.height)};

            // swap rendering order by swap the view entries in the renderGraph->children
            std::swap(renderGraph->children[views[0].first], renderGraph->children[views[1].first]);
            std::swap(views[0].second->camera->viewportState, views[1].second->camera->viewportState);

            // change the aspect ratios of the projection matrices to fit the new diemensions.
            view0->camera->projectionMatrix->changeExtent(extent0, extent1);
            view1->camera->projectionMatrix->changeExtent(extent1, extent0);

            // wait until the device is idle to avoid changing state while it's being used.
            vkDeviceWaitIdle(*(renderPass->device));

            vsg::UpdateGraphicsPipelines updateGraphicsPipelines;

            updateGraphicsPipelines.context = vsg::Context::create(renderPass->device);
            updateGraphicsPipelines.context->renderPass = renderPass;

            renderGraph->accept(updateGraphicsPipelines);

For the case of just changing the ViewportState of a single View it should be possible to just update the View's ViewportState then run the UpdateGraphicsPipeline to rebuild the graphics pipelines in the scene graph.

I hope this helps.

[gwaldron]

Thanks Robert. This does help :)
I do have a couple follow-up questions.

1. When changing the viewport, will you also need to update the ClearAttachments to reflect the camera's new render area? I think so. I did a test where it updates the viewport's x,y,width,height, and the clear color area always stays in the original place.

2. You have both views under the same RenderGraph separated by those ClearAttachments. Is this the best practice, versus putting each View under its own RenderGraph? Are there any advantages to one over the other?

[robertosfield]

Whether you need to update the ClearAttachments will depend upon what it's doing. If you are just clearing the area associated with a specific View then you'll need to update the dimensions, but if you're just clearing the whole window then there's no need to update if the viewport is within the window extents.

As for best practice, multiple RenderGraph vs single one, I don't know if I can give a definitive answer. as I'm still learning what works best in different situations.