1/*
2 * Copyright © 2020 Intel Corporation
3 *
4 * Permission is hereby granted, free of charge, to any person obtaining a
5 * copy of this software and associated documentation files (the "Software"),
6 * to deal in the Software without restriction, including without limitation
7 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
8 * and/or sell copies of the Software, and to permit persons to whom the
9 * Software is furnished to do so, subject to the following conditions:
10 *
11 * The above copyright notice and this permission notice (including the next
12 * paragraph) shall be included in all copies or substantial portions of the
13 * Software.
14 *
15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
18 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
20 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
21 * IN THE SOFTWARE.
22 */
23
24#include "anv_private.h"
25
26void
27anv_GetAccelerationStructureBuildSizesKHR(
28    VkDevice                                    device,
29    VkAccelerationStructureBuildTypeKHR         buildType,
30    const VkAccelerationStructureBuildGeometryInfoKHR* pBuildInfo,
31    const uint32_t*                             pMaxPrimitiveCounts,
32    VkAccelerationStructureBuildSizesInfoKHR*   pSizeInfo)
33{
34   assert(pSizeInfo->sType ==
35          VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_SIZES_INFO_KHR);
36
37   pSizeInfo->accelerationStructureSize = 0; /* TODO */
38
39   uint64_t cpu_build_scratch_size = 0; /* TODO */
40   uint64_t cpu_update_scratch_size = cpu_build_scratch_size;
41
42   uint64_t gpu_build_scratch_size = 0; /* TODO */
43   uint64_t gpu_update_scratch_size = gpu_build_scratch_size;
44
45   switch (buildType) {
46   case VK_ACCELERATION_STRUCTURE_BUILD_TYPE_HOST_KHR:
47      pSizeInfo->buildScratchSize = cpu_build_scratch_size;
48      pSizeInfo->updateScratchSize = cpu_update_scratch_size;
49      break;
50
51   case VK_ACCELERATION_STRUCTURE_BUILD_TYPE_DEVICE_KHR:
52      pSizeInfo->buildScratchSize = gpu_build_scratch_size;
53      pSizeInfo->updateScratchSize = gpu_update_scratch_size;
54      break;
55
56   case VK_ACCELERATION_STRUCTURE_BUILD_TYPE_HOST_OR_DEVICE_KHR:
57      pSizeInfo->buildScratchSize = MAX2(cpu_build_scratch_size,
58                                         gpu_build_scratch_size);
59      pSizeInfo->updateScratchSize = MAX2(cpu_update_scratch_size,
60                                          gpu_update_scratch_size);
61      break;
62
63   default:
64      unreachable("Invalid acceleration structure build type");
65   }
66}
67
68VkResult
69anv_CreateAccelerationStructureKHR(
70    VkDevice                                    _device,
71    const VkAccelerationStructureCreateInfoKHR* pCreateInfo,
72    const VkAllocationCallbacks*                pAllocator,
73    VkAccelerationStructureKHR*                 pAccelerationStructure)
74{
75   ANV_FROM_HANDLE(anv_device, device, _device);
76   ANV_FROM_HANDLE(anv_buffer, buffer, pCreateInfo->buffer);
77   struct anv_acceleration_structure *accel;
78
79   accel = vk_zalloc2(&device->vk.alloc, pAllocator, sizeof(*accel), 8,
80                      VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
81   if (accel == NULL)
82      return vk_error(device, VK_ERROR_OUT_OF_HOST_MEMORY);
83
84   vk_object_base_init(&device->vk, &accel->base,
85                       VK_OBJECT_TYPE_ACCELERATION_STRUCTURE_KHR);
86
87   accel->size = pCreateInfo->size;
88   accel->address = anv_address_add(buffer->address, pCreateInfo->offset);
89
90   *pAccelerationStructure = anv_acceleration_structure_to_handle(accel);
91
92   return VK_SUCCESS;
93}
94
95void
96anv_DestroyAccelerationStructureKHR(
97    VkDevice                                    _device,
98    VkAccelerationStructureKHR                  accelerationStructure,
99    const VkAllocationCallbacks*                pAllocator)
100{
101   ANV_FROM_HANDLE(anv_device, device, _device);
102   ANV_FROM_HANDLE(anv_acceleration_structure, accel, accelerationStructure);
103
104   if (!accel)
105      return;
106
107   vk_object_base_finish(&accel->base);
108   vk_free2(&device->vk.alloc, pAllocator, accel);
109}
110
111VkDeviceAddress
112anv_GetAccelerationStructureDeviceAddressKHR(
113    VkDevice                                    device,
114    const VkAccelerationStructureDeviceAddressInfoKHR* pInfo)
115{
116   ANV_FROM_HANDLE(anv_acceleration_structure, accel,
117                   pInfo->accelerationStructure);
118
119   assert(!anv_address_is_null(accel->address));
120   assert(anv_bo_is_pinned(accel->address.bo));
121
122   return anv_address_physical(accel->address);
123}
124
125void
126anv_GetDeviceAccelerationStructureCompatibilityKHR(
127    VkDevice                                    device,
128    const VkAccelerationStructureVersionInfoKHR* pVersionInfo,
129    VkAccelerationStructureCompatibilityKHR*    pCompatibility)
130{
131   unreachable("Unimplemented");
132}
133
134VkResult
135anv_BuildAccelerationStructuresKHR(
136    VkDevice                                    _device,
137    VkDeferredOperationKHR                      deferredOperation,
138    uint32_t                                    infoCount,
139    const VkAccelerationStructureBuildGeometryInfoKHR* pInfos,
140    const VkAccelerationStructureBuildRangeInfoKHR* const* ppBuildRangeInfos)
141{
142   ANV_FROM_HANDLE(anv_device, device, _device);
143   unreachable("Unimplemented");
144   return vk_error(device, VK_ERROR_FEATURE_NOT_PRESENT);
145}
146
147VkResult
148anv_CopyAccelerationStructureKHR(
149    VkDevice                                    _device,
150    VkDeferredOperationKHR                      deferredOperation,
151    const VkCopyAccelerationStructureInfoKHR*   pInfo)
152{
153   ANV_FROM_HANDLE(anv_device, device, _device);
154   unreachable("Unimplemented");
155   return vk_error(device, VK_ERROR_FEATURE_NOT_PRESENT);
156}
157
158VkResult
159anv_CopyAccelerationStructureToMemoryKHR(
160    VkDevice                                    _device,
161    VkDeferredOperationKHR                      deferredOperation,
162    const VkCopyAccelerationStructureToMemoryInfoKHR* pInfo)
163{
164   ANV_FROM_HANDLE(anv_device, device, _device);
165   unreachable("Unimplemented");
166   return vk_error(device, VK_ERROR_FEATURE_NOT_PRESENT);
167}
168
169VkResult
170anv_CopyMemoryToAccelerationStructureKHR(
171    VkDevice                                    _device,
172    VkDeferredOperationKHR                      deferredOperation,
173    const VkCopyMemoryToAccelerationStructureInfoKHR* pInfo)
174{
175   ANV_FROM_HANDLE(anv_device, device, _device);
176   unreachable("Unimplemented");
177   return vk_error(device, VK_ERROR_FEATURE_NOT_PRESENT);
178}
179
180VkResult
181anv_WriteAccelerationStructuresPropertiesKHR(
182    VkDevice                                    _device,
183    uint32_t                                    accelerationStructureCount,
184    const VkAccelerationStructureKHR*           pAccelerationStructures,
185    VkQueryType                                 queryType,
186    size_t                                      dataSize,
187    void*                                       pData,
188    size_t                                      stride)
189{
190   ANV_FROM_HANDLE(anv_device, device, _device);
191   unreachable("Unimplemented");
192   return vk_error(device, VK_ERROR_FEATURE_NOT_PRESENT);
193}
194
195void
196anv_CmdBuildAccelerationStructuresKHR(
197    VkCommandBuffer                             commandBuffer,
198    uint32_t                                    infoCount,
199    const VkAccelerationStructureBuildGeometryInfoKHR* pInfos,
200    const VkAccelerationStructureBuildRangeInfoKHR* const* ppBuildRangeInfos)
201{
202   unreachable("Unimplemented");
203}
204
205void
206anv_CmdBuildAccelerationStructuresIndirectKHR(
207    VkCommandBuffer                             commandBuffer,
208    uint32_t                                    infoCount,
209    const VkAccelerationStructureBuildGeometryInfoKHR* pInfos,
210    const VkDeviceAddress*                      pIndirectDeviceAddresses,
211    const uint32_t*                             pIndirectStrides,
212    const uint32_t* const*                      ppMaxPrimitiveCounts)
213{
214   unreachable("Unimplemented");
215}
216
217void
218anv_CmdCopyAccelerationStructureKHR(
219    VkCommandBuffer                             commandBuffer,
220    const VkCopyAccelerationStructureInfoKHR*   pInfo)
221{
222   unreachable("Unimplemented");
223}
224
225void
226anv_CmdCopyAccelerationStructureToMemoryKHR(
227    VkCommandBuffer                             commandBuffer,
228    const VkCopyAccelerationStructureToMemoryInfoKHR* pInfo)
229{
230   unreachable("Unimplemented");
231}
232
233void
234anv_CmdCopyMemoryToAccelerationStructureKHR(
235    VkCommandBuffer                             commandBuffer,
236    const VkCopyMemoryToAccelerationStructureInfoKHR* pInfo)
237{
238   unreachable("Unimplemented");
239}
240
241void
242anv_CmdWriteAccelerationStructuresPropertiesKHR(
243    VkCommandBuffer                             commandBuffer,
244    uint32_t                                    accelerationStructureCount,
245    const VkAccelerationStructureKHR*           pAccelerationStructures,
246    VkQueryType                                 queryType,
247    VkQueryPool                                 queryPool,
248    uint32_t                                    firstQuery)
249{
250   unreachable("Unimplemented");
251}
252