KonstantinSeurer
/
mesa
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

vk/0.210.0: More structure field renaming

This commit is contained in:
Jason Ekstrand 2015-12-01 12:52:56 -08:00
parent 407b8cc5e0
commit 299f8f1511
12 changed files with 62 additions and 63 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

23
include/vulkan/vulkan.h
View File

@ -1172,7 +1172,7 @@ typedef struct VkExtent3D {
typedef struct VkImageFormatProperties { typedef struct VkImageFormatProperties {
VkExtent3D maxExtent; VkExtent3D maxExtent;
uint32_t maxMipLevels; uint32_t maxMipLevels;
uint32_t maxArraySize; uint32_t maxArrayLayers;
VkSampleCountFlags sampleCounts; VkSampleCountFlags sampleCounts;
VkDeviceSize maxResourceSize; VkDeviceSize maxResourceSize;
} VkImageFormatProperties; } VkImageFormatProperties;
@ -1363,7 +1363,7 @@ typedef struct {
typedef struct VkMappedMemoryRange { typedef struct VkMappedMemoryRange {
VkStructureType sType; VkStructureType sType;
const void* pNext; const void* pNext;
VkDeviceMemory mem; VkDeviceMemory memory;
VkDeviceSize offset; VkDeviceSize offset;
VkDeviceSize size; VkDeviceSize size;
} VkMappedMemoryRange; } VkMappedMemoryRange;
@ -1473,7 +1473,7 @@ typedef struct VkQueryPoolCreateInfo {
const void* pNext; const void* pNext;
VkQueryPoolCreateFlags flags; VkQueryPoolCreateFlags flags;
VkQueryType queryType; VkQueryType queryType;
uint32_t slots; uint32_t entryCount;
VkQueryPipelineStatisticFlags pipelineStatistics; VkQueryPipelineStatisticFlags pipelineStatistics;
} VkQueryPoolCreateInfo; } VkQueryPoolCreateInfo;
@ -1484,7 +1484,7 @@ typedef struct VkBufferCreateInfo {
VkDeviceSize size; VkDeviceSize size;
VkBufferUsageFlags usage; VkBufferUsageFlags usage;
VkSharingMode sharingMode; VkSharingMode sharingMode;
uint32_t queueFamilyCount; uint32_t queueFamilyIndexCount;
const uint32_t* pQueueFamilyIndices; const uint32_t* pQueueFamilyIndices;
} VkBufferCreateInfo; } VkBufferCreateInfo;
@ -1506,12 +1506,12 @@ typedef struct VkImageCreateInfo {
VkFormat format; VkFormat format;
VkExtent3D extent; VkExtent3D extent;
uint32_t mipLevels; uint32_t mipLevels;
uint32_t arraySize; uint32_t arrayLayers;
uint32_t samples; uint32_t samples;
VkImageTiling tiling; VkImageTiling tiling;
VkImageUsageFlags usage; VkImageUsageFlags usage;
VkSharingMode sharingMode; VkSharingMode sharingMode;
uint32_t queueFamilyCount; uint32_t queueFamilyIndexCount;
const uint32_t* pQueueFamilyIndices; const uint32_t* pQueueFamilyIndices;
VkImageLayout initialLayout; VkImageLayout initialLayout;
} VkImageCreateInfo; } VkImageCreateInfo;
@ -1533,9 +1533,9 @@ typedef struct VkComponentMapping {
typedef struct VkImageSubresourceRange { typedef struct VkImageSubresourceRange {
VkImageAspectFlags aspectMask; VkImageAspectFlags aspectMask;
uint32_t baseMipLevel; uint32_t baseMipLevel;
uint32_t mipLevels; uint32_t levelCount;
uint32_t baseArrayLayer; uint32_t baseArrayLayer;
uint32_t arraySize; uint32_t layerCount;
} VkImageSubresourceRange; } VkImageSubresourceRange;
typedef struct VkImageViewCreateInfo { typedef struct VkImageViewCreateInfo {
@ -1570,9 +1570,8 @@ typedef struct VkPipelineCacheCreateInfo {
VkStructureType sType; VkStructureType sType;
const void* pNext; const void* pNext;
VkPipelineCacheCreateFlags flags; VkPipelineCacheCreateFlags flags;
size_t initialSize; size_t initialDataSize;
const void* initialData; const void* pInitialData;
size_t maxSize;
} VkPipelineCacheCreateInfo; } VkPipelineCacheCreateInfo;
typedef struct VkSpecializationMapEntry { typedef struct VkSpecializationMapEntry {
@ -1962,8 +1961,8 @@ typedef struct VkRenderPassCreateInfo {
typedef struct VkCommandPoolCreateInfo { typedef struct VkCommandPoolCreateInfo {
VkStructureType sType; VkStructureType sType;
const void* pNext; const void* pNext;
uint32_t queueFamilyIndex;
VkCommandPoolCreateFlags flags; VkCommandPoolCreateFlags flags;
uint32_t queueFamilyIndex;
} VkCommandPoolCreateInfo; } VkCommandPoolCreateInfo;
typedef struct { typedef struct {

6
src/vulkan/anv_dump.c
View File

@ -49,7 +49,7 @@ anv_dump_image_to_ppm(struct anv_device *device,
.format = VK_FORMAT_R8G8B8A8_UNORM, .format = VK_FORMAT_R8G8B8A8_UNORM,
.extent = (VkExtent3D) { extent.width, extent.height, 1 }, .extent = (VkExtent3D) { extent.width, extent.height, 1 },
.mipLevels = 1, .mipLevels = 1,
.arraySize = 1, .arrayLayers = 1,
.samples = 1, .samples = 1,
.tiling = VK_IMAGE_TILING_LINEAR, .tiling = VK_IMAGE_TILING_LINEAR,
.usage = VK_IMAGE_USAGE_TRANSFER_DST_BIT, .usage = VK_IMAGE_USAGE_TRANSFER_DST_BIT,
@ -144,9 +144,9 @@ anv_dump_image_to_ppm(struct anv_device *device,
.subresourceRange = (VkImageSubresourceRange) { .subresourceRange = (VkImageSubresourceRange) {
.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT, .aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,
.baseMipLevel = 0, .baseMipLevel = 0,
.mipLevels = 1, .levelCount = 1,
.baseArrayLayer = 0, .baseArrayLayer = 0,
.arraySize = 1, .layerCount = 1,
}, },
}}); }});

4
src/vulkan/anv_formats.c
View File

@ -432,7 +432,7 @@ VkResult anv_GetPhysicalDeviceImageFormatProperties(
*pImageFormatProperties = (VkImageFormatProperties) { *pImageFormatProperties = (VkImageFormatProperties) {
.maxExtent = maxExtent, .maxExtent = maxExtent,
.maxMipLevels = maxMipLevels, .maxMipLevels = maxMipLevels,
.maxArraySize = maxArraySize, .maxArrayLayers = maxArraySize,
/* FINISHME: Support multisampling */ /* FINISHME: Support multisampling */
.sampleCounts = VK_SAMPLE_COUNT_1_BIT, .sampleCounts = VK_SAMPLE_COUNT_1_BIT,
@ -449,7 +449,7 @@ unsupported:
*pImageFormatProperties = (VkImageFormatProperties) { *pImageFormatProperties = (VkImageFormatProperties) {
.maxExtent = { 0, 0, 0 }, .maxExtent = { 0, 0, 0 },
.maxMipLevels = 0, .maxMipLevels = 0,
.maxArraySize = 0, .maxArrayLayers = 0,
.sampleCounts = 0, .sampleCounts = 0,
.maxResourceSize = 0, .maxResourceSize = 0,
}; };

22
src/vulkan/anv_image.c
View File

@ -151,7 +151,7 @@ anv_image_make_surface(const struct anv_device *dev,
const VkExtent3D *restrict extent = &create_info->vk_info->extent; const VkExtent3D *restrict extent = &create_info->vk_info->extent;
const uint32_t levels = create_info->vk_info->mipLevels; const uint32_t levels = create_info->vk_info->mipLevels;
const uint32_t array_size = create_info->vk_info->arraySize; const uint32_t array_size = create_info->vk_info->arrayLayers;
const enum isl_tiling tiling = anv_image_choose_tiling(create_info); const enum isl_tiling tiling = anv_image_choose_tiling(create_info);
const struct anv_tile_info *tile_info = const struct anv_tile_info *tile_info =
@ -303,7 +303,7 @@ anv_image_create(VkDevice _device,
assert(pCreateInfo->sType == VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO); assert(pCreateInfo->sType == VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO);
anv_assert(pCreateInfo->mipLevels > 0); anv_assert(pCreateInfo->mipLevels > 0);
anv_assert(pCreateInfo->arraySize > 0); anv_assert(pCreateInfo->arrayLayers > 0);
anv_assert(pCreateInfo->samples == 1); anv_assert(pCreateInfo->samples == 1);
anv_assert(pCreateInfo->extent.width > 0); anv_assert(pCreateInfo->extent.width > 0);
anv_assert(pCreateInfo->extent.height > 0); anv_assert(pCreateInfo->extent.height > 0);
@ -331,7 +331,7 @@ anv_image_create(VkDevice _device,
image->extent = pCreateInfo->extent; image->extent = pCreateInfo->extent;
image->format = anv_format_for_vk_format(pCreateInfo->format); image->format = anv_format_for_vk_format(pCreateInfo->format);
image->levels = pCreateInfo->mipLevels; image->levels = pCreateInfo->mipLevels;
image->array_size = pCreateInfo->arraySize; image->array_size = pCreateInfo->arrayLayers;
image->usage = anv_image_get_full_usage(pCreateInfo); image->usage = anv_image_get_full_usage(pCreateInfo);
image->surface_type = surf_type; image->surface_type = surf_type;
@ -487,17 +487,17 @@ anv_validate_CreateImageView(VkDevice _device,
/* Validate subresource. */ /* Validate subresource. */
assert(subresource->aspectMask != 0); assert(subresource->aspectMask != 0);
assert(subresource->mipLevels > 0); assert(subresource->levelCount > 0);
assert(subresource->arraySize > 0); assert(subresource->layerCount > 0);
assert(subresource->baseMipLevel < image->levels); assert(subresource->baseMipLevel < image->levels);
assert(subresource->baseMipLevel + subresource->mipLevels <= image->levels); assert(subresource->baseMipLevel + subresource->levelCount <= image->levels);
assert(subresource->baseArrayLayer < image->array_size); assert(subresource->baseArrayLayer < image->array_size);
assert(subresource->baseArrayLayer + subresource->arraySize <= image->array_size); assert(subresource->baseArrayLayer + subresource->layerCount <= image->array_size);
assert(pView); assert(pView);
if (view_info->is_cube) { if (view_info->is_cube) {
assert(subresource->baseArrayLayer % 6 == 0); assert(subresource->baseArrayLayer % 6 == 0);
assert(subresource->arraySize % 6 == 0); assert(subresource->layerCount % 6 == 0);
} }
const VkImageAspectFlags ds_flags = VK_IMAGE_ASPECT_DEPTH_BIT const VkImageAspectFlags ds_flags = VK_IMAGE_ASPECT_DEPTH_BIT
@ -543,7 +543,7 @@ anv_image_view_init(struct anv_image_view *iview,
ANV_FROM_HANDLE(anv_image, image, pCreateInfo->image); ANV_FROM_HANDLE(anv_image, image, pCreateInfo->image);
const VkImageSubresourceRange *range = &pCreateInfo->subresourceRange; const VkImageSubresourceRange *range = &pCreateInfo->subresourceRange;
assert(range->arraySize > 0); assert(range->layerCount > 0);
assert(range->baseMipLevel < image->levels); assert(range->baseMipLevel < image->levels);
assert(image->usage & (VK_IMAGE_USAGE_SAMPLED_BIT | assert(image->usage & (VK_IMAGE_USAGE_SAMPLED_BIT |
VK_IMAGE_USAGE_STORAGE_BIT | VK_IMAGE_USAGE_STORAGE_BIT |
@ -555,10 +555,10 @@ anv_image_view_init(struct anv_image_view *iview,
unreachable("bad VkImageType"); unreachable("bad VkImageType");
case VK_IMAGE_TYPE_1D: case VK_IMAGE_TYPE_1D:
case VK_IMAGE_TYPE_2D: case VK_IMAGE_TYPE_2D:
assert(range->baseArrayLayer + range->arraySize - 1 <= image->array_size); assert(range->baseArrayLayer + range->layerCount - 1 <= image->array_size);
break; break;
case VK_IMAGE_TYPE_3D: case VK_IMAGE_TYPE_3D:
assert(range->baseArrayLayer + range->arraySize - 1 assert(range->baseArrayLayer + range->layerCount - 1
<= anv_minify(image->extent.depth, range->baseMipLevel)); <= anv_minify(image->extent.depth, range->baseMipLevel));
break; break;
} }

2
src/vulkan/anv_intel.c
View File

@ -78,7 +78,7 @@ VkResult anv_CreateDmaBufImageINTEL(
.format = pCreateInfo->format, .format = pCreateInfo->format,
.extent = pCreateInfo->extent, .extent = pCreateInfo->extent,
.mipLevels = 1, .mipLevels = 1,
.arraySize = 1, .arrayLayers = 1,
.samples = 1, .samples = 1,
/* FIXME: Need a way to use X tiling to allow scanout */ /* FIXME: Need a way to use X tiling to allow scanout */
.tiling = VK_IMAGE_TILING_OPTIMAL, .tiling = VK_IMAGE_TILING_OPTIMAL,

44
src/vulkan/anv_meta.c
View File

@ -674,7 +674,7 @@ do_buffer_copy(struct anv_cmd_buffer *cmd_buffer,
.depth = 1, .depth = 1,
}, },
.mipLevels = 1, .mipLevels = 1,
.arraySize = 1, .arrayLayers = 1,
.samples = 1, .samples = 1,
.tiling = VK_IMAGE_TILING_LINEAR, .tiling = VK_IMAGE_TILING_LINEAR,
.usage = 0, .usage = 0,
@ -707,9 +707,9 @@ do_buffer_copy(struct anv_cmd_buffer *cmd_buffer,
.subresourceRange = { .subresourceRange = {
.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT, .aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,
.baseMipLevel = 0, .baseMipLevel = 0,
.mipLevels = 1, .levelCount = 1,
.baseArrayLayer = 0, .baseArrayLayer = 0,
.arraySize = 1 .layerCount = 1
}, },
}, },
cmd_buffer); cmd_buffer);
@ -724,9 +724,9 @@ do_buffer_copy(struct anv_cmd_buffer *cmd_buffer,
.subresourceRange = { .subresourceRange = {
.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT, .aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,
.baseMipLevel = 0, .baseMipLevel = 0,
.mipLevels = 1, .levelCount = 1,
.baseArrayLayer = 0, .baseArrayLayer = 0,
.arraySize = 1, .layerCount = 1,
}, },
}, },
cmd_buffer); cmd_buffer);
@ -855,9 +855,9 @@ void anv_CmdCopyImage(
.subresourceRange = { .subresourceRange = {
.aspectMask = pRegions[r].srcSubresource.aspectMask, .aspectMask = pRegions[r].srcSubresource.aspectMask,
.baseMipLevel = pRegions[r].srcSubresource.mipLevel, .baseMipLevel = pRegions[r].srcSubresource.mipLevel,
.mipLevels = 1, .levelCount = 1,
.baseArrayLayer = pRegions[r].srcSubresource.baseArrayLayer, .baseArrayLayer = pRegions[r].srcSubresource.baseArrayLayer,
.arraySize = pRegions[r].dstSubresource.layerCount, .layerCount = pRegions[r].dstSubresource.layerCount,
}, },
}, },
cmd_buffer); cmd_buffer);
@ -899,9 +899,9 @@ void anv_CmdCopyImage(
.subresourceRange = { .subresourceRange = {
.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT, .aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,
.baseMipLevel = pRegions[r].dstSubresource.mipLevel, .baseMipLevel = pRegions[r].dstSubresource.mipLevel,
.mipLevels = 1, .levelCount = 1,
.baseArrayLayer = dest_base_array_slice + slice, .baseArrayLayer = dest_base_array_slice + slice,
.arraySize = 1 .layerCount = 1
}, },
}, },
cmd_buffer); cmd_buffer);
@ -955,9 +955,9 @@ void anv_CmdBlitImage(
.subresourceRange = { .subresourceRange = {
.aspectMask = pRegions[r].srcSubresource.aspectMask, .aspectMask = pRegions[r].srcSubresource.aspectMask,
.baseMipLevel = pRegions[r].srcSubresource.mipLevel, .baseMipLevel = pRegions[r].srcSubresource.mipLevel,
.mipLevels = 1, .levelCount = 1,
.baseArrayLayer = pRegions[r].srcSubresource.baseArrayLayer, .baseArrayLayer = pRegions[r].srcSubresource.baseArrayLayer,
.arraySize = 1 .layerCount = 1
}, },
}, },
cmd_buffer); cmd_buffer);
@ -989,9 +989,9 @@ void anv_CmdBlitImage(
.subresourceRange = { .subresourceRange = {
.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT, .aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,
.baseMipLevel = pRegions[r].dstSubresource.mipLevel, .baseMipLevel = pRegions[r].dstSubresource.mipLevel,
.mipLevels = 1, .levelCount = 1,
.baseArrayLayer = dest_array_slice, .baseArrayLayer = dest_array_slice,
.arraySize = 1 .layerCount = 1
}, },
}, },
cmd_buffer); cmd_buffer);
@ -1032,7 +1032,7 @@ make_image_for_buffer(VkDevice vk_device, VkBuffer vk_buffer, VkFormat format,
.format = format, .format = format,
.extent = extent, .extent = extent,
.mipLevels = 1, .mipLevels = 1,
.arraySize = 1, .arrayLayers = 1,
.samples = 1, .samples = 1,
.tiling = VK_IMAGE_TILING_LINEAR, .tiling = VK_IMAGE_TILING_LINEAR,
.usage = usage, .usage = usage,
@ -1106,9 +1106,9 @@ void anv_CmdCopyBufferToImage(
.subresourceRange = { .subresourceRange = {
.aspectMask = proxy_aspect, .aspectMask = proxy_aspect,
.baseMipLevel = 0, .baseMipLevel = 0,
.mipLevels = 1, .levelCount = 1,
.baseArrayLayer = 0, .baseArrayLayer = 0,
.arraySize = 1, .layerCount = 1,
}, },
}, },
cmd_buffer); cmd_buffer);
@ -1123,9 +1123,9 @@ void anv_CmdCopyBufferToImage(
.subresourceRange = { .subresourceRange = {
.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT, .aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,
.baseMipLevel = pRegions[r].imageSubresource.mipLevel, .baseMipLevel = pRegions[r].imageSubresource.mipLevel,
.mipLevels = 1, .levelCount = 1,
.baseArrayLayer = dest_base_array_slice + slice, .baseArrayLayer = dest_base_array_slice + slice,
.arraySize = 1 .layerCount = 1
}, },
}, },
cmd_buffer); cmd_buffer);
@ -1194,9 +1194,9 @@ void anv_CmdCopyImageToBuffer(
.subresourceRange = { .subresourceRange = {
.aspectMask = pRegions[r].imageSubresource.aspectMask, .aspectMask = pRegions[r].imageSubresource.aspectMask,
.baseMipLevel = pRegions[r].imageSubresource.mipLevel, .baseMipLevel = pRegions[r].imageSubresource.mipLevel,
.mipLevels = 1, .levelCount = 1,
.baseArrayLayer = pRegions[r].imageSubresource.baseArrayLayer, .baseArrayLayer = pRegions[r].imageSubresource.baseArrayLayer,
.arraySize = pRegions[r].imageSubresource.layerCount, .layerCount = pRegions[r].imageSubresource.layerCount,
}, },
}, },
cmd_buffer); cmd_buffer);
@ -1234,9 +1234,9 @@ void anv_CmdCopyImageToBuffer(
.subresourceRange = { .subresourceRange = {
.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT, .aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,
.baseMipLevel = 0, .baseMipLevel = 0,
.mipLevels = 1, .levelCount = 1,
.baseArrayLayer = 0, .baseArrayLayer = 0,
.arraySize = 1 .layerCount = 1
}, },
}, },
cmd_buffer); cmd_buffer);

8
src/vulkan/anv_meta_clear.c
View File

@ -690,8 +690,8 @@ void anv_CmdClearColorImage(
meta_clear_begin(&saved_state, cmd_buffer); meta_clear_begin(&saved_state, cmd_buffer);
for (uint32_t r = 0; r < rangeCount; r++) { for (uint32_t r = 0; r < rangeCount; r++) {
for (uint32_t l = 0; l < pRanges[r].mipLevels; l++) { for (uint32_t l = 0; l < pRanges[r].levelCount; l++) {
for (uint32_t s = 0; s < pRanges[r].arraySize; s++) { for (uint32_t s = 0; s < pRanges[r].layerCount; s++) {
struct anv_image_view iview; struct anv_image_view iview;
anv_image_view_init(&iview, cmd_buffer->device, anv_image_view_init(&iview, cmd_buffer->device,
&(VkImageViewCreateInfo) { &(VkImageViewCreateInfo) {
@ -702,9 +702,9 @@ void anv_CmdClearColorImage(
.subresourceRange = { .subresourceRange = {
.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT, .aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,
.baseMipLevel = pRanges[r].baseMipLevel + l, .baseMipLevel = pRanges[r].baseMipLevel + l,
.mipLevels = 1, .levelCount = 1,
.baseArrayLayer = pRanges[r].baseArrayLayer + s, .baseArrayLayer = pRanges[r].baseArrayLayer + s,
.arraySize = 1 .layerCount = 1
}, },
}, },
cmd_buffer); cmd_buffer);

2
src/vulkan/anv_query.c
View File

@ -55,7 +55,7 @@ VkResult anv_CreateQueryPool(
if (pool == NULL) if (pool == NULL)
return vk_error(VK_ERROR_OUT_OF_HOST_MEMORY); return vk_error(VK_ERROR_OUT_OF_HOST_MEMORY);
size = pCreateInfo->slots * sizeof(struct anv_query_pool_slot); size = pCreateInfo->entryCount * sizeof(struct anv_query_pool_slot);
result = anv_bo_init_new(&pool->bo, device, size); result = anv_bo_init_new(&pool->bo, device, size);
if (result != VK_SUCCESS) if (result != VK_SUCCESS)
goto fail; goto fail;

2
src/vulkan/anv_wsi_wayland.c
View File

@ -561,7 +561,7 @@ wsi_wl_image_init(struct wsi_wl_swapchain *chain, struct wsi_wl_image *image)
.depth = 1 .depth = 1
}, },
.mipLevels = 1, .mipLevels = 1,
.arraySize = 1, .arrayLayers = 1,
.samples = 1, .samples = 1,
/* FIXME: Need a way to use X tiling to allow scanout */ /* FIXME: Need a way to use X tiling to allow scanout */
.tiling = VK_IMAGE_TILING_OPTIMAL, .tiling = VK_IMAGE_TILING_OPTIMAL,

2
src/vulkan/anv_wsi_x11.c
View File

@ -313,7 +313,7 @@ x11_create_swapchain(struct anv_wsi_implementation *impl,
.depth = 1 .depth = 1
}, },
.mipLevels = 1, .mipLevels = 1,
.arraySize = 1, .arrayLayers = 1,
.samples = 1, .samples = 1,
/* FIXME: Need a way to use X tiling to allow scanout */ /* FIXME: Need a way to use X tiling to allow scanout */
.tiling = VK_IMAGE_TILING_OPTIMAL, .tiling = VK_IMAGE_TILING_OPTIMAL,

6
src/vulkan/gen7_state.c
View File

@ -231,8 +231,8 @@ genX(image_view_init)(struct anv_image_view *iview,
}; };
uint32_t depth = 1; uint32_t depth = 1;
if (range->arraySize > 1) { if (range->layerCount > 1) {
depth = range->arraySize; depth = range->layerCount;
} else if (image->extent.depth > 1) { } else if (image->extent.depth > 1) {
depth = image->extent.depth; depth = image->extent.depth;
} }
@ -300,7 +300,7 @@ genX(image_view_init)(struct anv_image_view *iview,
* sampler engine is [SurfaceMinLOD, SurfaceMinLOD + MIPCountLOD]. * sampler engine is [SurfaceMinLOD, SurfaceMinLOD + MIPCountLOD].
*/ */
surface_state.SurfaceMinLOD = range->baseMipLevel; surface_state.SurfaceMinLOD = range->baseMipLevel;
surface_state.MIPCountLOD = range->mipLevels - 1; surface_state.MIPCountLOD = range->levelCount - 1;
GENX(RENDER_SURFACE_STATE_pack)(NULL, iview->nonrt_surface_state.map, GENX(RENDER_SURFACE_STATE_pack)(NULL, iview->nonrt_surface_state.map,
&surface_state); &surface_state);

4
src/vulkan/gen8_state.c
View File

@ -145,7 +145,7 @@ genX(image_view_init)(struct anv_image_view *iview,
* example, if Minimum Array Element is set to 1024 on a 2D surface, * example, if Minimum Array Element is set to 1024 on a 2D surface,
* the range of this field is reduced to [0,1023]. * the range of this field is reduced to [0,1023].
*/ */
depth = range->arraySize; depth = range->layerCount;
/* From the Broadwell PRM >> RENDER_SURFACE_STATE::RenderTargetViewExtent: /* From the Broadwell PRM >> RENDER_SURFACE_STATE::RenderTargetViewExtent:
* *
@ -242,7 +242,7 @@ genX(image_view_init)(struct anv_image_view *iview,
* sampler engine is [SurfaceMinLOD, SurfaceMinLOD + MIPCountLOD]. * sampler engine is [SurfaceMinLOD, SurfaceMinLOD + MIPCountLOD].
*/ */
surface_state.SurfaceMinLOD = range->baseMipLevel; surface_state.SurfaceMinLOD = range->baseMipLevel;
surface_state.MIPCountLOD = range->mipLevels - 1; surface_state.MIPCountLOD = range->levelCount - 1;
GENX(RENDER_SURFACE_STATE_pack)(NULL, iview->nonrt_surface_state.map, GENX(RENDER_SURFACE_STATE_pack)(NULL, iview->nonrt_surface_state.map,
&surface_state); &surface_state);