ic
/
magnum
mirror of https://github.com/mosra/magnum.git
6
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

Vk: store the set of dynamic states in a Pipeline instance. 

Will be subsequently useful for command buffers.
pull/495/head
Vladimír Vondruš 5 years ago
parent
ac62a6c708
commit
9e71e5ab0e
4 changed files with 124 additions and 17 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 43
      src/Magnum/Vk/Pipeline.cpp
  2. 18
      src/Magnum/Vk/Pipeline.h
  3. 2
      src/Magnum/Vk/RasterizationPipelineCreateInfo.h
  4. 78
      src/Magnum/Vk/Test/PipelineVkTest.cpp

43
src/Magnum/Vk/Pipeline.cpp
Unescape View File

@ -43,7 +43,12 @@ namespace Magnum { namespace Vk {
struct RasterizationPipelineCreateInfo::State { struct RasterizationPipelineCreateInfo::State {
Containers::Array<VkPipelineColorBlendAttachmentState> colorBlendAttachments; Containers::Array<VkPipelineColorBlendAttachmentState> colorBlendAttachments;
Containers::Array<VkDynamicState> dynamicStates;
/* The enum is saved as well to be subsequently available through
Pipeline::dynamicRasterizationStates() */
DynamicRasterizationStates dynamicStates;
Containers::Array<VkDynamicState> dynamicStateList;
/** @todo make an array once we support multiview */ /** @todo make an array once we support multiview */
VkViewport viewport; VkViewport viewport;
VkRect2D scissor; VkRect2D scissor;
@ -242,21 +247,24 @@ constexpr VkDynamicState DynamicRasterizationStateMapping[]{
} }
RasterizationPipelineCreateInfo& RasterizationPipelineCreateInfo::setDynamicStates(const DynamicRasterizationStates& states) { RasterizationPipelineCreateInfo& RasterizationPipelineCreateInfo::setDynamicStates(const DynamicRasterizationStates& states) {
/* Save the enum so we can store it in the created Pipeline object later */
_state->dynamicStates = states;
/* Count the number of states set, allocate for that */ /* Count the number of states set, allocate for that */
std::size_t count = 0; std::size_t count = 0;
for(std::size_t i = 0; i != DynamicRasterizationStates::Size; ++i) for(std::size_t i = 0; i != DynamicRasterizationStates::Size; ++i)
count += Math::popcount(states.data()[i]); count += Math::popcount(states.data()[i]);
_state->dynamicStates = Containers::Array<VkDynamicState>{Containers::NoInit, count}; _state->dynamicStateList = Containers::Array<VkDynamicState>{Containers::NoInit, count};
std::size_t offset = 0; std::size_t offset = 0;
for(std::uint64_t i = 0; i != Containers::arraySize(DynamicRasterizationStateMapping); ++i) for(std::uint64_t i = 0; i != Containers::arraySize(DynamicRasterizationStateMapping); ++i)
if(states & DynamicRasterizationState(i)) if(states & DynamicRasterizationState(i))
_state->dynamicStates[offset++] = DynamicRasterizationStateMapping[i]; _state->dynamicStateList[offset++] = DynamicRasterizationStateMapping[i];
CORRADE_INTERNAL_ASSERT(offset == count); CORRADE_INTERNAL_ASSERT(offset == count);
_dynamicInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO; _dynamicInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO;
_dynamicInfo.dynamicStateCount = count; _dynamicInfo.dynamicStateCount = count;
_dynamicInfo.pDynamicStates = _state->dynamicStates; _dynamicInfo.pDynamicStates = _state->dynamicStateList;
_info.pDynamicState = &_dynamicInfo; _info.pDynamicState = &_dynamicInfo;
return *this; return *this;
} }
@ -278,15 +286,20 @@ ComputePipelineCreateInfo::ComputePipelineCreateInfo(const VkComputePipelineCrea
member instead of doing a copy */ member instead of doing a copy */
_info(info) {} _info(info) {}
Pipeline Pipeline::wrap(Device& device, const PipelineBindPoint bindPoint, const VkPipeline handle, const HandleFlags flags) { Pipeline Pipeline::wrap(Device& device, const PipelineBindPoint bindPoint, const VkPipeline handle, const DynamicRasterizationStates& dynamicStates, const HandleFlags flags) {
Pipeline out{NoCreate}; Pipeline out{NoCreate};
out._device = &device; out._device = &device;
out._handle = handle; out._handle = handle;
out._bindPoint = bindPoint; out._bindPoint = bindPoint;
out._flags = flags; out._flags = flags;
out._dynamicStates.rasterization = dynamicStates;
return out; return out;
} }
Pipeline Pipeline::wrap(Device& device, const PipelineBindPoint bindPoint, const VkPipeline handle, const HandleFlags flags) {
return wrap(device, bindPoint, handle, DynamicRasterizationStates{}, flags);
}
Pipeline::Pipeline(Device& device, const RasterizationPipelineCreateInfo& info): Pipeline::Pipeline(Device& device, const RasterizationPipelineCreateInfo& info):
_device{&device}, _device{&device},
#ifdef CORRADE_GRACEFUL_ASSERT #ifdef CORRADE_GRACEFUL_ASSERT
@ -294,7 +307,8 @@ Pipeline::Pipeline(Device& device, const RasterizationPipelineCreateInfo& info):
_handle{}, _handle{},
#endif #endif
_bindPoint{PipelineBindPoint::Rasterization}, _bindPoint{PipelineBindPoint::Rasterization},
_flags{HandleFlag::DestroyOnDestruction} _flags{HandleFlag::DestroyOnDestruction},
_dynamicStates{info._state->dynamicStates}
{ {
/* Doesn't check that the viewport is really a dynamic state, but should /* Doesn't check that the viewport is really a dynamic state, but should
catch most cases without false positives */ catch most cases without false positives */
@ -304,13 +318,17 @@ Pipeline::Pipeline(Device& device, const RasterizationPipelineCreateInfo& info):
MAGNUM_VK_INTERNAL_ASSERT_SUCCESS(device->CreateGraphicsPipelines(device, {}, 1, info, nullptr, &_handle)); MAGNUM_VK_INTERNAL_ASSERT_SUCCESS(device->CreateGraphicsPipelines(device, {}, 1, info, nullptr, &_handle));
} }
Pipeline::Pipeline(Device& device, const ComputePipelineCreateInfo& info): _device{&device}, _bindPoint{PipelineBindPoint::Compute}, _flags{HandleFlag::DestroyOnDestruction} { Pipeline::Pipeline(Device& device, const ComputePipelineCreateInfo& info): _device{&device}, _bindPoint{PipelineBindPoint::Compute}, _flags{HandleFlag::DestroyOnDestruction}, _dynamicStates{} {
MAGNUM_VK_INTERNAL_ASSERT_SUCCESS(device->CreateComputePipelines(device, {}, 1, info, nullptr, &_handle)); MAGNUM_VK_INTERNAL_ASSERT_SUCCESS(device->CreateComputePipelines(device, {}, 1, info, nullptr, &_handle));
} }
Pipeline::Pipeline(NoCreateT): _device{}, _handle{}, _bindPoint{} {} Pipeline::Pipeline(NoCreateT): _device{}, _handle{}, _bindPoint{}, _dynamicStates{} {}
Pipeline::Pipeline(Pipeline&& other) noexcept: _device{other._device}, _handle{other._handle}, _bindPoint{other._bindPoint}, _flags{other._flags} { Pipeline::Pipeline(Pipeline&& other) noexcept: _device{other._device}, _handle{other._handle}, _bindPoint{other._bindPoint}, _flags{other._flags},
/* Can't use {} with GCC 4.8 here because it tries to initialize the first
member instead of doing a copy */
_dynamicStates(other._dynamicStates)
{
other._handle = {}; other._handle = {};
} }
@ -325,9 +343,16 @@ Pipeline& Pipeline::operator=(Pipeline&& other) noexcept {
swap(other._handle, _handle); swap(other._handle, _handle);
swap(other._bindPoint, _bindPoint); swap(other._bindPoint, _bindPoint);
swap(other._flags, _flags); swap(other._flags, _flags);
swap(other._dynamicStates, _dynamicStates);
return *this; return *this;
} }
DynamicRasterizationStates Pipeline::dynamicRasterizationStates() const {
CORRADE_ASSERT(_bindPoint == PipelineBindPoint::Rasterization,
"Vk::Pipeline::dynamicRasterizationStates(): not a rasterization pipeline", {});
return _dynamicStates.rasterization;
}
VkPipeline Pipeline::release() { VkPipeline Pipeline::release() {
const VkPipeline handle = _handle; const VkPipeline handle = _handle;
_handle = {}; _handle = {};

18
src/Magnum/Vk/Pipeline.h
Unescape View File

@ -30,6 +30,7 @@
* @m_since_latest * @m_since_latest
*/ */
#include <Corrade/Containers/BigEnumSet.h>
#include <Corrade/Containers/EnumSet.h> #include <Corrade/Containers/EnumSet.h>
#include "Magnum/Magnum.h" #include "Magnum/Magnum.h"
@ -116,6 +117,9 @@ class MAGNUM_VK_EXPORT Pipeline {
* @param bindPoint Pipeline bind point. Available through * @param bindPoint Pipeline bind point. Available through
* @ref bindPoint() afterwards. * @ref bindPoint() afterwards.
* @param handle The @type_vk{Pipeline} handle * @param handle The @type_vk{Pipeline} handle
* @param dynamicStates Dynamic states enabled on the rasterization
* pipeline. Available through @ref dynamicRasterizationStates()
* afterwards.
* @param flags Handle flags * @param flags Handle flags
* *
* The @p handle is expected to be originating from @p device. Unlike * The @p handle is expected to be originating from @p device. Unlike
@ -124,6 +128,8 @@ class MAGNUM_VK_EXPORT Pipeline {
* different behavior. * different behavior.
* @see @ref release() * @see @ref release()
*/ */
static Pipeline wrap(Device& device, PipelineBindPoint bindPoint, VkPipeline handle, const DynamicRasterizationStates& dynamicStates, HandleFlags flags = {});
/** @overload */
static Pipeline wrap(Device& device, PipelineBindPoint bindPoint, VkPipeline handle, HandleFlags flags = {}); static Pipeline wrap(Device& device, PipelineBindPoint bindPoint, VkPipeline handle, HandleFlags flags = {});
/** /**
@ -193,6 +199,15 @@ class MAGNUM_VK_EXPORT Pipeline {
*/ */
PipelineBindPoint bindPoint() const { return _bindPoint; } PipelineBindPoint bindPoint() const { return _bindPoint; }
/**
* @brief Dynamic rasterization states enabled in this pipeline
*
* Contains the states passed to @ref RasterizationPipelineCreateInfo::setDynamicStates()
* or to the @ref wrap() call. Expects that @ref bindPoint() is
* @ref PipelineBindPoint::Rasterization.
*/
DynamicRasterizationStates dynamicRasterizationStates() const;
/** /**
* @brief Release the underlying Vulkan pipeline * @brief Release the underlying Vulkan pipeline
* *
@ -210,6 +225,9 @@ class MAGNUM_VK_EXPORT Pipeline {
VkPipeline _handle; VkPipeline _handle;
PipelineBindPoint _bindPoint; PipelineBindPoint _bindPoint;
HandleFlags _flags; HandleFlags _flags;
union {
DynamicRasterizationStates rasterization;
} _dynamicStates;
}; };
/** /**

2
src/Magnum/Vk/RasterizationPipelineCreateInfo.h
Unescape View File

@ -524,6 +524,8 @@ class MAGNUM_VK_EXPORT RasterizationPipelineCreateInfo {
operator const VkGraphicsPipelineCreateInfo*() const { return &_info; } operator const VkGraphicsPipelineCreateInfo*() const { return &_info; }
private: private:
friend Pipeline;
VkGraphicsPipelineCreateInfo _info; VkGraphicsPipelineCreateInfo _info;
VkPipelineViewportStateCreateInfo _viewportInfo; VkPipelineViewportStateCreateInfo _viewportInfo;
VkPipelineRasterizationStateCreateInfo _rasterizationInfo; VkPipelineRasterizationStateCreateInfo _rasterizationInfo;

78
src/Magnum/Vk/Test/PipelineVkTest.cpp
Unescape View File

@ -62,7 +62,10 @@ struct PipelineVkTest: VulkanTester {
void constructCompute(); void constructCompute();
void constructMove(); void constructMove();
void wrap(); void wrapRasterization();
void wrapCompute();
void dynamicRasterizationStatesNotRasterization();
void cmdBind(); void cmdBind();
@ -81,7 +84,10 @@ PipelineVkTest::PipelineVkTest() {
&PipelineVkTest::constructCompute, &PipelineVkTest::constructCompute,
&PipelineVkTest::constructMove, &PipelineVkTest::constructMove,
&PipelineVkTest::wrap, &PipelineVkTest::wrapRasterization,
&PipelineVkTest::wrapCompute,
&PipelineVkTest::dynamicRasterizationStatesNotRasterization,
&PipelineVkTest::cmdBind, &PipelineVkTest::cmdBind,
@ -134,10 +140,12 @@ void PipelineVkTest::constructRasterization() {
Pipeline pipeline{device(), RasterizationPipelineCreateInfo{ Pipeline pipeline{device(), RasterizationPipelineCreateInfo{
shaderSet, meshLayout, pipelineLayout, renderPass, 0, 1} shaderSet, meshLayout, pipelineLayout, renderPass, 0, 1}
.setViewport({{}, {200, 200}}) .setViewport({{}, {200, 200}})
.setDynamicStates(DynamicRasterizationState::LineWidth|DynamicRasterizationState::DepthBias)
}; };
CORRADE_VERIFY(pipeline.handle()); CORRADE_VERIFY(pipeline.handle());
CORRADE_COMPARE(pipeline.handleFlags(), HandleFlag::DestroyOnDestruction); CORRADE_COMPARE(pipeline.handleFlags(), HandleFlag::DestroyOnDestruction);
CORRADE_COMPARE(pipeline.bindPoint(), PipelineBindPoint::Rasterization); CORRADE_COMPARE(pipeline.bindPoint(), PipelineBindPoint::Rasterization);
CORRADE_COMPARE(pipeline.dynamicRasterizationStates(), DynamicRasterizationState::LineWidth|DynamicRasterizationState::DepthBias);
} }
/* Shouldn't crash or anything */ /* Shouldn't crash or anything */
@ -241,16 +249,16 @@ void PipelineVkTest::constructRasterizationViewportNotSetDynamic() {
RasterizationPipelineCreateInfo info{ RasterizationPipelineCreateInfo info{
shaderSet, meshLayout, pipelineLayout, renderPass, 0, 1}; shaderSet, meshLayout, pipelineLayout, renderPass, 0, 1};
info.setViewport(Range3D{}) /* Has to be set because the count is used */ info.setViewport(Range3D{}) /* Has to be set because the count is used */
.setDynamicStates(DynamicRasterizationState::Viewport| .setDynamicStates(DynamicRasterizationState::Viewport|DynamicRasterizationState::Scissor);
DynamicRasterizationState::Scissor);
/* But the data don't have to be there */ /* But the data don't have to be there */
const_cast<VkPipelineViewportStateCreateInfo*>(info->pViewportState)->pViewports = nullptr; const_cast<VkPipelineViewportStateCreateInfo*>(info->pViewportState)->pViewports = nullptr;
const_cast<VkPipelineViewportStateCreateInfo*>(info->pViewportState)->pScissors = nullptr; const_cast<VkPipelineViewportStateCreateInfo*>(info->pViewportState)->pScissors = nullptr;
Pipeline pipeline{device(), info}; Pipeline pipeline{device(), info};
/* The only thing I want to verify is that this doesn't crash or assert */ /* The main thing I want to verify is that this doesn't crash or assert */
CORRADE_VERIFY(pipeline.handle()); CORRADE_VERIFY(pipeline.handle());
CORRADE_COMPARE(pipeline.dynamicRasterizationStates(), DynamicRasterizationState::Viewport|DynamicRasterizationState::Scissor);
} }
void PipelineVkTest::constructCompute() { void PipelineVkTest::constructCompute() {
@ -311,6 +319,7 @@ void PipelineVkTest::constructMove() {
Pipeline a{device(), RasterizationPipelineCreateInfo{ Pipeline a{device(), RasterizationPipelineCreateInfo{
shaderSet, meshLayout, pipelineLayout, renderPass, 0, 1} shaderSet, meshLayout, pipelineLayout, renderPass, 0, 1}
.setViewport({{}, {200, 200}}) .setViewport({{}, {200, 200}})
.setDynamicStates(DynamicRasterizationState::LineWidth|DynamicRasterizationState::DepthBias)
}; };
VkPipeline handle = a.handle(); VkPipeline handle = a.handle();
@ -319,6 +328,7 @@ void PipelineVkTest::constructMove() {
CORRADE_COMPARE(b.handle(), handle); CORRADE_COMPARE(b.handle(), handle);
CORRADE_COMPARE(b.handleFlags(), HandleFlag::DestroyOnDestruction); CORRADE_COMPARE(b.handleFlags(), HandleFlag::DestroyOnDestruction);
CORRADE_COMPARE(b.bindPoint(), PipelineBindPoint::Rasterization); CORRADE_COMPARE(b.bindPoint(), PipelineBindPoint::Rasterization);
CORRADE_COMPARE(b.dynamicRasterizationStates(), DynamicRasterizationState::LineWidth|DynamicRasterizationState::DepthBias);
Pipeline c{NoCreate}; Pipeline c{NoCreate};
c = std::move(b); c = std::move(b);
@ -327,12 +337,13 @@ void PipelineVkTest::constructMove() {
CORRADE_COMPARE(c.handle(), handle); CORRADE_COMPARE(c.handle(), handle);
CORRADE_COMPARE(c.handleFlags(), HandleFlag::DestroyOnDestruction); CORRADE_COMPARE(c.handleFlags(), HandleFlag::DestroyOnDestruction);
CORRADE_COMPARE(c.bindPoint(), PipelineBindPoint::Rasterization); CORRADE_COMPARE(c.bindPoint(), PipelineBindPoint::Rasterization);
CORRADE_COMPARE(c.dynamicRasterizationStates(), DynamicRasterizationState::LineWidth|DynamicRasterizationState::DepthBias);
CORRADE_VERIFY(std::is_nothrow_move_constructible<Pipeline>::value); CORRADE_VERIFY(std::is_nothrow_move_constructible<Pipeline>::value);
CORRADE_VERIFY(std::is_nothrow_move_assignable<Pipeline>::value); CORRADE_VERIFY(std::is_nothrow_move_assignable<Pipeline>::value);
} }
void PipelineVkTest::wrap() { void PipelineVkTest::wrapRasterization() {
RenderPass renderPass{device(), RenderPassCreateInfo{} RenderPass renderPass{device(), RenderPassCreateInfo{}
.setAttachments({ .setAttachments({
AttachmentDescription{PixelFormat::RGBA8Unorm, AttachmentDescription{PixelFormat::RGBA8Unorm,
@ -368,12 +379,39 @@ void PipelineVkTest::wrap() {
VkPipeline pipeline{}; VkPipeline pipeline{};
CORRADE_COMPARE(Result(device()->CreateGraphicsPipelines(device(), {}, 1, CORRADE_COMPARE(Result(device()->CreateGraphicsPipelines(device(), {}, 1,
RasterizationPipelineCreateInfo{shaderSet, meshLayout, pipelineLayout, renderPass, 0, 1} RasterizationPipelineCreateInfo{shaderSet, meshLayout, pipelineLayout, renderPass, 0, 1}
.setViewport({{}, {200, 200}}), .setViewport({{}, {200, 200}})
.setDynamicStates(DynamicRasterizationState::LineWidth|DynamicRasterizationState::DepthBias),
nullptr, &pipeline)), Result::Success); nullptr, &pipeline)), Result::Success);
auto wrapped = Pipeline::wrap(device(), PipelineBindPoint::Rasterization, pipeline, HandleFlag::DestroyOnDestruction); auto wrapped = Pipeline::wrap(device(), PipelineBindPoint::Rasterization, pipeline, DynamicRasterizationState::LineWidth|DynamicRasterizationState::DepthBias, HandleFlag::DestroyOnDestruction);
CORRADE_COMPARE(wrapped.handle(), pipeline); CORRADE_COMPARE(wrapped.handle(), pipeline);
CORRADE_COMPARE(wrapped.bindPoint(), PipelineBindPoint::Rasterization); CORRADE_COMPARE(wrapped.bindPoint(), PipelineBindPoint::Rasterization);
CORRADE_COMPARE(wrapped.dynamicRasterizationStates(), DynamicRasterizationState::LineWidth|DynamicRasterizationState::DepthBias);
/* Release the handle again, destroy by hand */
CORRADE_COMPARE(wrapped.release(), pipeline);
CORRADE_VERIFY(!wrapped.handle());
device()->DestroyPipeline(device(), pipeline, nullptr);
}
void PipelineVkTest::wrapCompute() {
PipelineLayout pipelineLayout{device(), PipelineLayoutCreateInfo{}};
Shader shader{device(), ShaderCreateInfo{
Utility::Directory::read(Utility::Directory::join(VK_TEST_DIR, "compute-noop.spv"))
}};
ShaderSet shaderSet;
shaderSet.addShader(ShaderStage::Compute, shader, "main"_s);
VkPipeline pipeline{};
CORRADE_COMPARE(Result(device()->CreateComputePipelines(device(), {}, 1,
ComputePipelineCreateInfo{shaderSet, pipelineLayout},
nullptr, &pipeline)), Result::Success);
auto wrapped = Pipeline::wrap(device(), PipelineBindPoint::Compute, pipeline, HandleFlag::DestroyOnDestruction);
CORRADE_COMPARE(wrapped.handle(), pipeline);
CORRADE_COMPARE(wrapped.bindPoint(), PipelineBindPoint::Compute);
/* Release the handle again, destroy by hand */ /* Release the handle again, destroy by hand */
CORRADE_COMPARE(wrapped.release(), pipeline); CORRADE_COMPARE(wrapped.release(), pipeline);
@ -381,6 +419,30 @@ void PipelineVkTest::wrap() {
device()->DestroyPipeline(device(), pipeline, nullptr); device()->DestroyPipeline(device(), pipeline, nullptr);
} }
void PipelineVkTest::dynamicRasterizationStatesNotRasterization() {
#ifdef CORRADE_NO_ASSERT
CORRADE_SKIP("CORRADE_NO_ASSERT defined, can't test assertions");
#endif
PipelineLayout pipelineLayout{device(), PipelineLayoutCreateInfo{}};
Shader shader{device(), ShaderCreateInfo{
Utility::Directory::read(Utility::Directory::join(VK_TEST_DIR, "compute-noop.spv"))
}};
ShaderSet shaderSet;
shaderSet.addShader(ShaderStage::Compute, shader, "main"_s);
Pipeline pipeline{device(), ComputePipelineCreateInfo{
shaderSet, pipelineLayout
}};
std::ostringstream out;
Error redirectError{&out};
pipeline.dynamicRasterizationStates();
CORRADE_COMPARE(out.str(), "Vk::Pipeline::dynamicRasterizationStates(): not a rasterization pipeline\n");
}
void PipelineVkTest::cmdBind() { void PipelineVkTest::cmdBind() {
CommandPool pool{device(), CommandPoolCreateInfo{ CommandPool pool{device(), CommandPoolCreateInfo{
/* This might blow up if queue() isn't the one matching this family */ /* This might blow up if queue() isn't the one matching this family */

Write Preview
Loading…
Cancel
Save