rooty/rpi-vk-driver
1
0
Fork 0
mirror of https://github.com/Yours3lf/rpi-vk-driver.git synced 2025-02-19 16:54:18 +01:00
Code Issues Releases Wiki Activity

backup

Browse Source
This commit is contained in:
Unknown 2019-07-08 21:10:22 +01:00
parent dda5b3d62b
commit 7f4551f320
5 changed files with 131 additions and 7 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

13
driver/common.h
View File

@ -214,9 +214,18 @@ typedef struct VkShaderModule_T
uint32_t numDescriptorBindings[VK_RPI_ASSEMBLY_TYPE_MAX];
} _shaderModule;
typedef struct VkPipelineLayout_T
{
map descriptorSetBindingMap;
uint32_t setLayoutCount;
const _descriptorSetLayout* setLayouts;
uint32_t pushConstantRangeCount;
const VkPushConstantRange* pushConstantRanges;
} _pipelineLayout;
typedef struct VkPipeline_T
{
VkShaderModule modules[6];
_shaderModule* modules[6];
char* names[6];
uint32_t vertexBindingDescriptionCount;
VkVertexInputBindingDescription* vertexBindingDescriptions;
@ -260,7 +269,7 @@ typedef struct VkPipeline_T
float blendConstants[4];
uint32_t dynamicStateCount;
VkDynamicState* dynamicStates;
VkPipelineLayout layout;
_pipelineLayout* layout;
_renderpass* renderPass;
uint32_t subpass;
} _pipeline;

16
driver/descriptorSet.c
View File

@ -381,7 +381,23 @@ VKAPI_ATTR void VKAPI_CALL vkCmdBindDescriptorSets(
uint32_t dynamicOffsetCount,
const uint32_t* pDynamicOffsets)
{
//TODO dynamic offsets
assert(commandBuffer);
assert(layout);
assert(pDescriptorSets);
_commandBuffer* cb = commandBuffer;
//use pipeline layout's memory to store what is bound...
_pipelineLayout* pl = pipelineBindPoint == VK_PIPELINE_BIND_POINT_GRAPHICS ? cb->graphicsPipeline->layout : cb->computePipeline->layout;
assert(firstSet + descriptorSetCount <= pl->setLayoutCount);
for(uint32_t c = firstSet; c < firstSet + descriptorSetCount; ++c)
{
setMapElement(&pl->descriptorSetBindingMap, c, pDescriptorSets[c]);
}
}
VKAPI_ATTR void VKAPI_CALL vkDestroyDescriptorSetLayout(

53
driver/draw.c
View File

@ -246,6 +246,7 @@ void vkCmdDraw(VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t ins
uniform viewport zoffset : 0.500000
/**/
/**
//TODO: if fragment shader doesn't use any uniforms, then VS will expect to read the first uniform in the stream
//clFit(commandBuffer, &commandBuffer->uniformsCl, 4*(1+4+4));
clFit(commandBuffer, &commandBuffer->uniformsCl, 4*(4+4));
@ -261,6 +262,58 @@ void vkCmdDraw(VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t ins
clInsertUniformConstant(&commandBuffer->uniformsCl, 1065353216);
clInsertUniformXYScale(&commandBuffer->uniformsCl, (float)(i->width) * 0.5f * 16.0f);
clInsertUniformZOffset(&commandBuffer->uniformsCl, 0.5f);
/**/
_shaderModule* csModule = cb->graphicsPipeline->modules[ulog2(VK_SHADER_STAGE_VERTEX_BIT)];
_pipelineLayout* pl = cb->graphicsPipeline->layout;
for(uint32_t c = 0; c < csModule->numDescriptorBindings[VK_RPI_ASSEMBLY_TYPE_COORDINATE]; ++c)
{
uint32_t offset = 0;
for(uint32_t d = 0; d < c; ++d)
{
offset += csModule->numDescriptorBindings[d];
}
_descriptorSet* ds = getMapElement(pl->descriptorSetBindingMap, csModule->descriptorSets[offset + c]);
clFit(commandBuffer, &commandBuffer->uniformsCl, 4*csModule->descriptorCounts[offset + c]);
switch(csModule->descriptorTypes[offset + c])
{
case VK_DESCRIPTOR_TYPE_SAMPLER:
case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:
case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE:
case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE:
case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT:
_descriptorImage* dib = getMapElement(ds->imageBindingMap, csModule->descriptorBindings[offset + c]);
for(uint32_t d = 0; d < csModule->descriptorCounts[offset + c]; ++d)
{
//TODO
//clInsertUniformConstant(&commandBuffer->uniformsCl, );
}
break;
case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER:
case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC:
_descriptorBuffer* dbb = getMapElement(ds->bufferBindingMap, csModule->descriptorBindings[offset + c]);
for(uint32_t d = 0; d < csModule->descriptorCounts[offset + c]; ++d)
{
//TODO
//csModule->descriptorArrayElems[offset + c]
//clInsertUniformConstant(&commandBuffer->uniformsCl, );
}
break;
case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER:
case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER:
_descriptorTexelBuffer* dtb = getMapElement(ds->texelBufferBindingMap, csModule->descriptorBindings[offset + c]);
for(uint32_t d = 0; d < csModule->descriptorCounts[offset + c]; ++d)
{
//TODO
//clInsertUniformConstant(&commandBuffer->uniformsCl, );
}
}
}
}
VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexedIndirect(

40
driver/pipeline.c
View File

@ -229,6 +229,46 @@ VKAPI_ATTR VkResult VKAPI_CALL vkCreatePipelineLayout(
const VkAllocationCallbacks* pAllocator,
VkPipelineLayout* pPipelineLayout)
{
assert(device);
assert(pCreateInfo);
assert(pPipelineLayout);
_pipelineLayout* pl = ALLOCATE(sizeof(_pipelineLayout), 1, VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
if(!pl)
{
return VK_ERROR_OUT_OF_HOST_MEMORY;
}
pl->setLayoutCount = pCreateInfo->setLayoutCount;
pl->pushConstantRangeCount = pCreateInfo->pushConstantRangeCount;
if(pCreateInfo->setLayoutCount > 0 && pCreateInfo->pSetLayouts)
{
pl->setLayouts = ALLOCATE(sizeof(VkDescriptorSetLayout)*pCreateInfo->setLayoutCount, 1, VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
if(!pl->setLayouts)
{
return VK_ERROR_OUT_OF_HOST_MEMORY;
}
memcpy(pl->setLayouts, pCreateInfo->pSetLayouts, sizeof(VkDescriptorSetLayout)*pCreateInfo->setLayoutCount);
}
if(pCreateInfo->pushConstantRangeCount > 0 && pCreateInfo->pPushConstantRanges)
{
pl->pushConstantRanges = ALLOCATE(sizeof(VkPushConstantRange)*pCreateInfo->pushConstantRangeCount, 1, VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
if(!pl->pushConstantRanges)
{
return VK_ERROR_OUT_OF_HOST_MEMORY;
}
memcpy(pl->pushConstantRanges, pCreateInfo->pPushConstantRanges, sizeof(VkPushConstantRange)*pCreateInfo->pushConstantRangeCount);
}
pl->descriptorSetBindingMap = createMap(ALLOCATE(sizeof(_descriptorSet*)*pCreateInfo->setLayoutCount, 1, VK_SYSTEM_ALLOCATION_SCOPE_OBJECT), pCreateInfo->setLayoutCount);
*pPipelineLayout = pl;
return VK_SUCCESS;
}

16
driver/shader.c
View File

@ -51,40 +51,46 @@ VkResult vkCreateShaderModuleFromRpiAssemblyEXT(VkDevice device, VkRpiShaderModu
if(pCreateInfo->numDescriptorBindings[c] > 0)
{
uint32_t offset = 0;
for(uint32_t d = 0; d < c; ++d)
{
offset += pCreateInfo->numDescriptorBindings[d];
}
shader->descriptorBindings[c] = ALLOCATE(sizeof(uint32_t)*pCreateInfo->numDescriptorBindings[c], 1, VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
if(!shader->descriptorBindings[c])
{
return VK_ERROR_OUT_OF_HOST_MEMORY;
}
memcpy(shader->descriptorBindings[c], pCreateInfo->descriptorBindings + (c*pCreateInfo->numDescriptorBindings[c]), sizeof(uint32_t)*pCreateInfo->numDescriptorBindings[c]);
memcpy(shader->descriptorBindings[c], pCreateInfo->descriptorBindings + offset, sizeof(uint32_t)*pCreateInfo->numDescriptorBindings[c]);
shader->descriptorSets[c] = ALLOCATE(sizeof(uint32_t)*pCreateInfo->numDescriptorBindings[c], 1, VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
if(!shader->descriptorSets[c])
{
return VK_ERROR_OUT_OF_HOST_MEMORY;
}
memcpy(shader->descriptorSets[c], pCreateInfo->descriptorSets + (c*pCreateInfo->numDescriptorBindings[c]), sizeof(uint32_t)*pCreateInfo->numDescriptorBindings[c]);
memcpy(shader->descriptorSets[c], pCreateInfo->descriptorSets + offset, sizeof(uint32_t)*pCreateInfo->numDescriptorBindings[c]);
shader->descriptorTypes[c] = ALLOCATE(sizeof(VkDescriptorType)*pCreateInfo->numDescriptorBindings[c], 1, VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
if(!shader->descriptorTypes[c])
{
return VK_ERROR_OUT_OF_HOST_MEMORY;
}
memcpy(shader->descriptorTypes[c], pCreateInfo->descriptorTypes + (c*pCreateInfo->numDescriptorBindings[c]), sizeof(VkDescriptorType)*pCreateInfo->numDescriptorBindings[c]);
memcpy(shader->descriptorTypes[c], pCreateInfo->descriptorTypes + offset, sizeof(VkDescriptorType)*pCreateInfo->numDescriptorBindings[c]);
shader->descriptorCounts[c] = ALLOCATE(sizeof(uint32_t)*pCreateInfo->numDescriptorBindings[c], 1, VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
if(!shader->descriptorCounts[c])
{
return VK_ERROR_OUT_OF_HOST_MEMORY;
}
memcpy(shader->descriptorCounts[c], pCreateInfo->descriptorCounts + (c*pCreateInfo->numDescriptorBindings[c]), sizeof(uint32_t)*pCreateInfo->numDescriptorBindings[c]);
memcpy(shader->descriptorCounts[c], pCreateInfo->descriptorCounts + offset, sizeof(uint32_t)*pCreateInfo->numDescriptorBindings[c]);
shader->descriptorArrayElems[c] = ALLOCATE(sizeof(uint32_t)*pCreateInfo->numDescriptorBindings[c], 1, VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
if(!shader->descriptorArrayElems[c])
{
return VK_ERROR_OUT_OF_HOST_MEMORY;
}
memcpy(shader->descriptorArrayElems[c], pCreateInfo->descriptorArrayElems + (c*pCreateInfo->numDescriptorBindings[c]), sizeof(uint32_t)*pCreateInfo->numDescriptorBindings[c]);
memcpy(shader->descriptorArrayElems[c], pCreateInfo->descriptorArrayElems + offset, sizeof(uint32_t)*pCreateInfo->numDescriptorBindings[c]);
}
}
else