VkBool32 VKTS_APIENTRY fileSaveBinary(const char* filename, const IBinaryBufferSP& buffer)
{
if (!buffer.get())
{
return VK_FALSE;
}
return fileSave(filename, buffer->getData(), buffer->getSize());
}
IImageDataSP VKTS_APIENTRY imageDataLoadGli(const std::string& name, const IBinaryBufferSP& buffer)
{
if (!buffer.get())
{
return IImageDataSP();
}
auto texture = gli::load(name.c_str());
if (texture.empty())
{
return IImageDataSP();
}
if (texture.layers() > 1 && texture.faces() > 1)
{
return IImageDataSP();
}
VkFormat format = imageDataTranslateFormat(texture.format());
if (format == VK_FORMAT_UNDEFINED)
{
return IImageDataSP();
}
uint32_t arrayLayers = (uint32_t)(texture.layers() * texture.faces());
uint32_t mipLevels = (uint32_t)texture.levels();
VkImageType imageType = VK_IMAGE_TYPE_2D;
if (texture.extent().z > 1)
{
imageType = VK_IMAGE_TYPE_3D;
}
//
std::vector<size_t> allOffsets;
size_t offset = 0;
for (size_t arrayLayer = texture.base_layer(); arrayLayer <= texture.max_layer(); arrayLayer++)
{
for (size_t face = texture.base_face(); face <= texture.max_face(); face++)
{
for (size_t mipLevel = texture.base_level(); mipLevel <= texture.max_level(); mipLevel++)
{
allOffsets.push_back(offset);
offset += texture.size(mipLevel);
}
}
}
size_t totalSize = offset;
std::vector<uint8_t> data(totalSize);
offset = 0;
for (size_t arrayLayer = texture.base_layer(); arrayLayer <= texture.max_layer(); arrayLayer++)
{
for (size_t face = texture.base_face(); face <= texture.max_face(); face++)
{
for (size_t mipLevel = texture.base_level(); mipLevel <= texture.max_level(); mipLevel++)
{
memcpy(&data[offset], texture.data(arrayLayer, face, mipLevel), texture.size(mipLevel));
offset += texture.size(mipLevel);
}
}
}
return IImageDataSP(new ImageData(name, imageType, format, { (uint32_t)texture.extent().x, (uint32_t)texture.extent().y, (uint32_t)texture.extent().z }, mipLevels, arrayLayers, allOffsets, &data[0], totalSize));
}
IBufferObjectSP VKTS_APIENTRY bufferObjectCreate(IBufferSP& stageBuffer, IDeviceMemorySP& stageDeviceMemory, const IInitialResourcesSP& initialResources, const ICommandBuffersSP& cmdBuffer, const IBinaryBufferSP& binaryBuffer, const VkBufferCreateInfo& bufferCreateInfo, const VkMemoryPropertyFlags memoryPropertyFlag)
{
if (!initialResources.get() || !cmdBuffer.get() || !binaryBuffer.get())
{
return IBufferObjectSP();
}
//
VkResult result;
//
IBufferSP buffer;
IDeviceMemorySP deviceMemory;
if (!bufferObjectPrepare(buffer, deviceMemory, initialResources, bufferCreateInfo, memoryPropertyFlag))
{
return IBufferObjectSP();
}
//
if (memoryPropertyFlag & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT)
{
result = deviceMemory->upload(0, deviceMemory->getAllocationSize(), 0, binaryBuffer->getData(), binaryBuffer->getSize());
if (result != VK_SUCCESS)
{
logPrint(VKTS_LOG_ERROR, "BufferObject: Could not upload vertex data.");
return IBufferObjectSP();
}
}
else
{
if (!bufferObjectPrepare(stageBuffer, stageDeviceMemory, initialResources, bufferCreateInfo, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT))
{
logPrint(VKTS_LOG_ERROR, "BufferObject: Could not create vertex buffer.");
return IBufferObjectSP();
}
result = stageDeviceMemory->upload(0, stageDeviceMemory->getAllocationSize(), 0, binaryBuffer->getData(), binaryBuffer->getSize());
if (result != VK_SUCCESS)
{
logPrint(VKTS_LOG_ERROR, "BufferObject: Could not upload vertex data.");
return IBufferObjectSP();
}
VkBufferCopy bufferCopy;
bufferCopy.srcOffset = 0;
bufferCopy.dstOffset = 0;
bufferCopy.size = binaryBuffer->getSize();
stageBuffer->copyBuffer(cmdBuffer->getCommandBuffer(), buffer->getBuffer(), buffer->getSize(), 1, &bufferCopy);
}
//
IBufferViewSP noBufferView;
auto newInstance = new BufferObject(initialResources, buffer, noBufferView, deviceMemory);
if (!newInstance)
{
buffer->destroy();
return IBufferObjectSP();
}
return IBufferObjectSP(newInstance);
}
GraphicsPipeline::GraphicsPipeline(const VkDevice device, const VkPipelineCache pipelineCache, const VkGraphicsPipelineCreateInfo& graphicsPipelineCreateInfo, const VkPipeline pipeline, const VkTsVertexBufferType vertexBufferType) :
IGraphicsPipeline(), device(device), pipelineCache(pipelineCache), graphicsPipelineCreateInfo(graphicsPipelineCreateInfo), allStagesSerialized(), vertexInputStateSerialized(), inputAssemblyStateSerialized(), tessellationStateSerialized(), viewportStateSerialized(), rasterizationStateSerialized(), multisampleStateSerialized(), depthStencilStateSerialized(), colorBlendStateSerialized(), dynamicStateSerialized(), pipeline(pipeline), vertexBufferType(vertexBufferType)
{
this->graphicsPipelineCreateInfo.pStages = nullptr;
this->graphicsPipelineCreateInfo.pVertexInputState = nullptr;
this->graphicsPipelineCreateInfo.pInputAssemblyState = nullptr;
this->graphicsPipelineCreateInfo.pTessellationState = nullptr;
this->graphicsPipelineCreateInfo.pViewportState = nullptr;
this->graphicsPipelineCreateInfo.pRasterizationState = nullptr;
this->graphicsPipelineCreateInfo.pMultisampleState = nullptr;
this->graphicsPipelineCreateInfo.pDepthStencilState = nullptr;
this->graphicsPipelineCreateInfo.pColorBlendState = nullptr;
this->graphicsPipelineCreateInfo.pDynamicState = nullptr;
if (graphicsPipelineCreateInfo.stageCount > 0 && graphicsPipelineCreateInfo.pStages)
{
for (uint32_t i = 0; i < graphicsPipelineCreateInfo.stageCount; i++)
{
IBinaryBufferSP currentStageSerialized = commonSerializeStructureType(&graphicsPipelineCreateInfo.pStages[i]);
allStagesSerialized.append(currentStageSerialized);
if (i == 0)
{
this->graphicsPipelineCreateInfo.pStages = (const VkPipelineShaderStageCreateInfo*) currentStageSerialized->getData();
}
}
}
if (graphicsPipelineCreateInfo.pVertexInputState)
{
vertexInputStateSerialized = commonSerializeStructureType(graphicsPipelineCreateInfo.pVertexInputState);
this->graphicsPipelineCreateInfo.pVertexInputState = (const VkPipelineVertexInputStateCreateInfo*) vertexInputStateSerialized->getData();
}
if (graphicsPipelineCreateInfo.pInputAssemblyState)
{
inputAssemblyStateSerialized = commonSerializeStructureType(graphicsPipelineCreateInfo.pInputAssemblyState);
this->graphicsPipelineCreateInfo.pInputAssemblyState = (const VkPipelineInputAssemblyStateCreateInfo*) inputAssemblyStateSerialized->getData();
}
if (graphicsPipelineCreateInfo.pTessellationState)
{
tessellationStateSerialized = commonSerializeStructureType(graphicsPipelineCreateInfo.pTessellationState);
this->graphicsPipelineCreateInfo.pTessellationState = (const VkPipelineTessellationStateCreateInfo*) tessellationStateSerialized->getData();
}
if (graphicsPipelineCreateInfo.pViewportState)
{
viewportStateSerialized = commonSerializeStructureType(graphicsPipelineCreateInfo.pViewportState);
this->graphicsPipelineCreateInfo.pViewportState = (const VkPipelineViewportStateCreateInfo*) viewportStateSerialized->getData();
}
if (graphicsPipelineCreateInfo.pRasterizationState)
{
rasterizationStateSerialized = commonSerializeStructureType(graphicsPipelineCreateInfo.pRasterizationState);
this->graphicsPipelineCreateInfo.pRasterizationState = (const VkPipelineRasterizationStateCreateInfo*) rasterizationStateSerialized->getData();
}
if (graphicsPipelineCreateInfo.pMultisampleState)
{
multisampleStateSerialized = commonSerializeStructureType(graphicsPipelineCreateInfo.pMultisampleState);
this->graphicsPipelineCreateInfo.pMultisampleState = (const VkPipelineMultisampleStateCreateInfo*) multisampleStateSerialized->getData();
}
if (graphicsPipelineCreateInfo.pDepthStencilState)
{
depthStencilStateSerialized = commonSerializeStructureType(graphicsPipelineCreateInfo.pDepthStencilState);
this->graphicsPipelineCreateInfo.pDepthStencilState = (const VkPipelineDepthStencilStateCreateInfo*) depthStencilStateSerialized->getData();
}
if (graphicsPipelineCreateInfo.pColorBlendState)
{
colorBlendStateSerialized = commonSerializeStructureType(graphicsPipelineCreateInfo.pColorBlendState);
this->graphicsPipelineCreateInfo.pColorBlendState = (const VkPipelineColorBlendStateCreateInfo*) colorBlendStateSerialized->getData();
}
if (graphicsPipelineCreateInfo.pDynamicState)
{
dynamicStateSerialized = commonSerializeStructureType(graphicsPipelineCreateInfo.pDynamicState);
this->graphicsPipelineCreateInfo.pDynamicState = (const VkPipelineDynamicStateCreateInfo*) dynamicStateSerialized->getData();
}
}
