Use latest Level Zero RT API (#595)
* Update vendored Level Zero ze_api.h to upstream * Migrate Embree RTAS integration from EXP to EXT API * Check for relaxed allocation limit L0 extension before using it
This commit is contained in:
Stefan Werner
@@ -665,18 +665,22 @@ namespace embree
|
||||
bool ze_rtas_builder = false;
|
||||
for (uint32_t i=0; i<extensions.size(); i++)
|
||||
{
|
||||
if (strncmp("ZE_experimental_rtas_builder",extensions[i].name,sizeof(extensions[i].name)) == 0)
|
||||
if (strncmp("ZE_extension_rtas",extensions[i].name,sizeof(extensions[i].name)) == 0) {
|
||||
ze_rtas_builder = true;
|
||||
}
|
||||
if (strncmp("ZE_experimental_relaxed_allocation_limits", extensions[i].name, sizeof(extensions[i].name)) == 0) {
|
||||
hasRelaxedAllocationLimits = true;
|
||||
}
|
||||
}
|
||||
if (!ze_rtas_builder)
|
||||
throw_RTCError(RTC_ERROR_LEVEL_ZERO_RAYTRACING_SUPPORT_MISSING, "ZE_experimental_rtas_builder extension not found. Please install a recent driver. On Linux, make sure that the package intel-level-zero-gpu-raytracing is installed");
|
||||
throw_RTCError(RTC_ERROR_LEVEL_ZERO_RAYTRACING_SUPPORT_MISSING, "ZE_extension_rtas extension not found. Please install a recent driver. On Linux, make sure that the package intel-level-zero-gpu-raytracing is installed");
|
||||
|
||||
result = ZeWrapper::initRTASBuilder(hDriver);
|
||||
if (result == ZE_RESULT_ERROR_DEPENDENCY_UNAVAILABLE) {
|
||||
throw_RTCError(RTC_ERROR_LEVEL_ZERO_RAYTRACING_SUPPORT_MISSING, "cannot load ZE_experimental_rtas_builder extension. Please install a recent driver. On Linux, make sure that the package intel-level-zero-gpu-raytracing is installed");
|
||||
throw_RTCError(RTC_ERROR_LEVEL_ZERO_RAYTRACING_SUPPORT_MISSING, "cannot load ZE_extension_rtas extension. Please install a recent driver. On Linux, make sure that the package intel-level-zero-gpu-raytracing is installed");
|
||||
}
|
||||
if (result != ZE_RESULT_SUCCESS)
|
||||
throw_RTCError(RTC_ERROR_UNKNOWN, "cannot initialize ZE_experimental_rtas_builder extension");
|
||||
throw_RTCError(RTC_ERROR_UNKNOWN, "cannot initialize ZE_extension_rtas extension");
|
||||
|
||||
if (State::verbosity(1))
|
||||
{
|
||||
@@ -684,12 +688,12 @@ namespace embree
|
||||
}
|
||||
|
||||
/* check if extension library can get loaded */
|
||||
ze_rtas_parallel_operation_exp_handle_t hParallelOperation;
|
||||
result = ZeWrapper::zeRTASParallelOperationCreateExp(hDriver, &hParallelOperation);
|
||||
ze_rtas_parallel_operation_ext_handle_t hParallelOperation;
|
||||
result = ZeWrapper::zeRTASParallelOperationCreateExt(hDriver, &hParallelOperation);
|
||||
if (result == ZE_RESULT_ERROR_DEPENDENCY_UNAVAILABLE)
|
||||
throw_RTCError(RTC_ERROR_UNKNOWN, "Level Zero RTAS Build Extension cannot get loaded");
|
||||
if (result == ZE_RESULT_SUCCESS)
|
||||
ZeWrapper::zeRTASParallelOperationDestroyExp(hParallelOperation);
|
||||
ZeWrapper::zeRTASParallelOperationDestroyExt(hParallelOperation);
|
||||
|
||||
gpu_maxWorkGroupSize = getGPUDevice().get_info<sycl::info::device::max_work_group_size>();
|
||||
gpu_maxComputeUnits = getGPUDevice().get_info<sycl::info::device::max_compute_units>();
|
||||
@@ -704,7 +708,7 @@ namespace embree
|
||||
std::cout << std::endl;
|
||||
}
|
||||
|
||||
dispatchGlobalsPtr = zeRTASInitExp(gpu_device, gpu_context);
|
||||
dispatchGlobalsPtr = zeRTASInit(gpu_device, gpu_context);
|
||||
}
|
||||
|
||||
DeviceGPU::~DeviceGPU()
|
||||
|
||||
@@ -209,7 +209,8 @@ namespace embree
|
||||
|
||||
unsigned int gpu_maxWorkGroupSize;
|
||||
unsigned int gpu_maxComputeUnits;
|
||||
|
||||
bool hasRelaxedAllocationLimits = false;
|
||||
|
||||
public:
|
||||
void* dispatchGlobalsPtr = nullptr;
|
||||
|
||||
@@ -218,6 +219,8 @@ namespace embree
|
||||
inline sycl::context &getGPUContext() { return gpu_context; }
|
||||
|
||||
inline unsigned int getGPUMaxWorkGroupSize() { return gpu_maxWorkGroupSize; }
|
||||
inline bool relaxedAllocationLimitsSupported() const { return hasRelaxedAllocationLimits; }
|
||||
|
||||
|
||||
void init_rthw_level_zero();
|
||||
void init_rthw_opencl();
|
||||
|
||||
+5877
-439
File diff suppressed because it is too large
Load Diff
@@ -35,16 +35,16 @@ static decltype(zeDriverGetExtensionProperties)* zeDriverGetExtensionPropertiesI
|
||||
static decltype(zeDeviceGetProperties)* zeDeviceGetPropertiesInternal = nullptr;
|
||||
static decltype(zeDeviceGetModuleProperties)* zeDeviceGetModulePropertiesInternal = nullptr;
|
||||
|
||||
static decltype(zeRTASBuilderCreateExp)* zeRTASBuilderCreateExpInternal = nullptr;
|
||||
static decltype(zeRTASBuilderDestroyExp)* zeRTASBuilderDestroyExpInternal = nullptr;
|
||||
static decltype(zeDriverRTASFormatCompatibilityCheckExp)* zeDriverRTASFormatCompatibilityCheckExpInternal = nullptr;
|
||||
static decltype(zeRTASBuilderGetBuildPropertiesExp)* zeRTASBuilderGetBuildPropertiesExpInternal = nullptr;
|
||||
static decltype(zeRTASBuilderBuildExp)* zeRTASBuilderBuildExpInternal = nullptr;
|
||||
static decltype(zeRTASBuilderCreateExt)* zeRTASBuilderCreateExtInternal = nullptr;
|
||||
static decltype(zeRTASBuilderDestroyExt)* zeRTASBuilderDestroyExtInternal = nullptr;
|
||||
static decltype(zeDriverRTASFormatCompatibilityCheckExt)* zeDriverRTASFormatCompatibilityCheckExtInternal = nullptr;
|
||||
static decltype(zeRTASBuilderGetBuildPropertiesExt)* zeRTASBuilderGetBuildPropertiesExtInternal = nullptr;
|
||||
static decltype(zeRTASBuilderBuildExt)* zeRTASBuilderBuildExtInternal = nullptr;
|
||||
|
||||
static decltype(zeRTASParallelOperationCreateExp)* zeRTASParallelOperationCreateExpInternal = nullptr;
|
||||
static decltype(zeRTASParallelOperationDestroyExp)* zeRTASParallelOperationDestroyExpInternal = nullptr;
|
||||
static decltype(zeRTASParallelOperationGetPropertiesExp)* zeRTASParallelOperationGetPropertiesExpInternal = nullptr;
|
||||
static decltype(zeRTASParallelOperationJoinExp)* zeRTASParallelOperationJoinExpInternal = nullptr;
|
||||
static decltype(zeRTASParallelOperationCreateExt)* zeRTASParallelOperationCreateExtInternal = nullptr;
|
||||
static decltype(zeRTASParallelOperationDestroyExt)* zeRTASParallelOperationDestroyExtInternal = nullptr;
|
||||
static decltype(zeRTASParallelOperationGetPropertiesExt)* zeRTASParallelOperationGetPropertiesExtInternal = nullptr;
|
||||
static decltype(zeRTASParallelOperationJoinExt)* zeRTASParallelOperationJoinExtInternal = nullptr;
|
||||
|
||||
template<typename T>
|
||||
T find_symbol(void* handle, std::string const& symbol) {
|
||||
@@ -94,31 +94,31 @@ ze_result_t selectLevelZeroRTASBuilder(ze_driver_handle_t hDriver)
|
||||
if (ZeWrapper::rtas_builder_selected)
|
||||
return ZE_RESULT_SUCCESS;
|
||||
|
||||
auto zeRTASBuilderCreateExpTemp = find_symbol<decltype(zeRTASBuilderCreateExp)*>(handle,"zeRTASBuilderCreateExp");
|
||||
auto zeRTASBuilderDestroyExpTemp = find_symbol<decltype(zeRTASBuilderDestroyExp)*>(handle,"zeRTASBuilderDestroyExp");
|
||||
auto zeRTASBuilderCreateExtTemp = find_symbol<decltype(zeRTASBuilderCreateExt)*>(handle,"zeRTASBuilderCreateExt");
|
||||
auto zeRTASBuilderDestroyExtTemp = find_symbol<decltype(zeRTASBuilderDestroyExt)*>(handle,"zeRTASBuilderDestroyExt");
|
||||
|
||||
ze_rtas_builder_exp_desc_t builderDesc = { ZE_STRUCTURE_TYPE_RTAS_BUILDER_EXP_DESC };
|
||||
ze_rtas_builder_exp_handle_t hBuilder = nullptr;
|
||||
ze_result_t err = zeRTASBuilderCreateExpTemp(hDriver, &builderDesc, &hBuilder);
|
||||
ze_rtas_builder_ext_desc_t builderDesc = { ZE_STRUCTURE_TYPE_RTAS_BUILDER_EXT_DESC, nullptr, ZE_RTAS_BUILDER_EXT_VERSION_CURRENT };
|
||||
ze_rtas_builder_ext_handle_t hBuilder = nullptr;
|
||||
ze_result_t err = zeRTASBuilderCreateExtTemp(hDriver, &builderDesc, &hBuilder);
|
||||
|
||||
/* when ZE_RESULT_ERROR_DEPENDENCY_UNAVAILABLE is reported extension cannot get loaded */
|
||||
if (err == ZE_RESULT_ERROR_DEPENDENCY_UNAVAILABLE)
|
||||
return err;
|
||||
|
||||
if (err == ZE_RESULT_SUCCESS)
|
||||
zeRTASBuilderDestroyExpTemp(hBuilder);
|
||||
zeRTASBuilderDestroyExtTemp(hBuilder);
|
||||
|
||||
zeRTASBuilderCreateExpInternal = zeRTASBuilderCreateExpTemp;
|
||||
zeRTASBuilderDestroyExpInternal = zeRTASBuilderDestroyExpTemp;
|
||||
zeRTASBuilderCreateExtInternal = zeRTASBuilderCreateExtTemp;
|
||||
zeRTASBuilderDestroyExtInternal = zeRTASBuilderDestroyExtTemp;
|
||||
|
||||
zeDriverRTASFormatCompatibilityCheckExpInternal = find_symbol<decltype(zeDriverRTASFormatCompatibilityCheckExp)*>(handle,"zeDriverRTASFormatCompatibilityCheckExp");
|
||||
zeRTASBuilderGetBuildPropertiesExpInternal = find_symbol<decltype(zeRTASBuilderGetBuildPropertiesExp)*>(handle,"zeRTASBuilderGetBuildPropertiesExp");
|
||||
zeRTASBuilderBuildExpInternal = find_symbol<decltype(zeRTASBuilderBuildExp)*>(handle,"zeRTASBuilderBuildExp");
|
||||
zeDriverRTASFormatCompatibilityCheckExtInternal = find_symbol<decltype(zeDriverRTASFormatCompatibilityCheckExt)*>(handle,"zeDriverRTASFormatCompatibilityCheckExt");
|
||||
zeRTASBuilderGetBuildPropertiesExtInternal = find_symbol<decltype(zeRTASBuilderGetBuildPropertiesExt)*>(handle,"zeRTASBuilderGetBuildPropertiesExt");
|
||||
zeRTASBuilderBuildExtInternal = find_symbol<decltype(zeRTASBuilderBuildExt)*>(handle,"zeRTASBuilderBuildExt");
|
||||
|
||||
zeRTASParallelOperationCreateExpInternal = find_symbol<decltype(zeRTASParallelOperationCreateExp)*>(handle,"zeRTASParallelOperationCreateExp");
|
||||
zeRTASParallelOperationDestroyExpInternal = find_symbol<decltype(zeRTASParallelOperationDestroyExp)*>(handle,"zeRTASParallelOperationDestroyExp");
|
||||
zeRTASParallelOperationGetPropertiesExpInternal = find_symbol<decltype(zeRTASParallelOperationGetPropertiesExp)*>(handle,"zeRTASParallelOperationGetPropertiesExp");
|
||||
zeRTASParallelOperationJoinExpInternal = find_symbol<decltype(zeRTASParallelOperationJoinExp)*>(handle,"zeRTASParallelOperationJoinExp");
|
||||
zeRTASParallelOperationCreateExtInternal = find_symbol<decltype(zeRTASParallelOperationCreateExt)*>(handle,"zeRTASParallelOperationCreateExt");
|
||||
zeRTASParallelOperationDestroyExtInternal = find_symbol<decltype(zeRTASParallelOperationDestroyExt)*>(handle,"zeRTASParallelOperationDestroyExt");
|
||||
zeRTASParallelOperationGetPropertiesExtInternal = find_symbol<decltype(zeRTASParallelOperationGetPropertiesExt)*>(handle,"zeRTASParallelOperationGetPropertiesExt");
|
||||
zeRTASParallelOperationJoinExtInternal = find_symbol<decltype(zeRTASParallelOperationJoinExt)*>(handle,"zeRTASParallelOperationJoinExt");
|
||||
|
||||
ZeWrapper::rtas_builder_selected = true;
|
||||
return ZE_RESULT_SUCCESS;
|
||||
@@ -214,12 +214,12 @@ ze_result_t validate(ze_device_handle_t hDevice)
|
||||
return ZE_RESULT_SUCCESS;
|
||||
}
|
||||
|
||||
ze_result_t validate(ze_rtas_device_exp_properties_t* pProperties)
|
||||
{
|
||||
ze_result_t validate(ze_rtas_device_ext_properties_t* pProperties)
|
||||
{
|
||||
if (pProperties == nullptr)
|
||||
return ZE_RESULT_ERROR_INVALID_NULL_POINTER;
|
||||
|
||||
if (pProperties->stype != ZE_STRUCTURE_TYPE_RTAS_DEVICE_EXP_PROPERTIES)
|
||||
if (pProperties->stype != ZE_STRUCTURE_TYPE_RTAS_DEVICE_EXT_PROPERTIES)
|
||||
return ZE_RESULT_ERROR_INVALID_ENUMERATION;
|
||||
|
||||
//if (!checkDescChain((zet_base_desc_t_*)pProperties))
|
||||
@@ -244,84 +244,84 @@ ze_result_t ZeWrapper::zeDeviceGetModuleProperties(ze_device_handle_t ze_handle,
|
||||
return zeDeviceGetModulePropertiesInternal(ze_handle, props);
|
||||
}
|
||||
|
||||
ze_result_t ZeWrapper::zeRTASBuilderCreateExp(ze_driver_handle_t hDriver, const ze_rtas_builder_exp_desc_t *pDescriptor, ze_rtas_builder_exp_handle_t *phBuilder)
|
||||
ze_result_t ZeWrapper::zeRTASBuilderCreateExt(ze_driver_handle_t hDriver, const ze_rtas_builder_ext_desc_t *pDescriptor, ze_rtas_builder_ext_handle_t *phBuilder)
|
||||
{
|
||||
if (!handle || !zeRTASBuilderCreateExpInternal)
|
||||
if (!handle || !zeRTASBuilderCreateExtInternal)
|
||||
throw std::runtime_error("ZeWrapper not initialized, call ZeWrapper::init() first.");
|
||||
|
||||
return zeRTASBuilderCreateExpInternal(hDriver,pDescriptor,phBuilder);
|
||||
return zeRTASBuilderCreateExtInternal(hDriver,pDescriptor,phBuilder);
|
||||
}
|
||||
|
||||
ze_result_t ZeWrapper::zeRTASBuilderDestroyExp(ze_rtas_builder_exp_handle_t hBuilder)
|
||||
ze_result_t ZeWrapper::zeRTASBuilderDestroyExt(ze_rtas_builder_ext_handle_t hBuilder)
|
||||
{
|
||||
if (!handle || !zeRTASBuilderDestroyExpInternal)
|
||||
if (!handle || !zeRTASBuilderDestroyExtInternal)
|
||||
throw std::runtime_error("ZeWrapper not initialized, call ZeWrapper::init() first.");
|
||||
|
||||
return zeRTASBuilderDestroyExpInternal(hBuilder);
|
||||
return zeRTASBuilderDestroyExtInternal(hBuilder);
|
||||
}
|
||||
|
||||
ze_result_t ZeWrapper::zeDriverRTASFormatCompatibilityCheckExp( ze_driver_handle_t hDriver,
|
||||
const ze_rtas_format_exp_t accelFormat,
|
||||
const ze_rtas_format_exp_t otherAccelFormat)
|
||||
ze_result_t ZeWrapper::zeDriverRTASFormatCompatibilityCheckExt(ze_driver_handle_t hDriver,
|
||||
const ze_rtas_format_ext_t accelFormat,
|
||||
const ze_rtas_format_ext_t otherAccelFormat)
|
||||
{
|
||||
if (!handle || !zeDriverRTASFormatCompatibilityCheckExpInternal)
|
||||
if (!handle || !zeDriverRTASFormatCompatibilityCheckExtInternal)
|
||||
throw std::runtime_error("ZeWrapper not initialized, call ZeWrapper::init() first.");
|
||||
|
||||
return zeDriverRTASFormatCompatibilityCheckExpInternal( hDriver, accelFormat, otherAccelFormat);
|
||||
return zeDriverRTASFormatCompatibilityCheckExtInternal(hDriver, accelFormat, otherAccelFormat);
|
||||
}
|
||||
|
||||
ze_result_t ZeWrapper::zeRTASBuilderGetBuildPropertiesExp(ze_rtas_builder_exp_handle_t hBuilder,
|
||||
const ze_rtas_builder_build_op_exp_desc_t* args,
|
||||
ze_rtas_builder_exp_properties_t* pProp)
|
||||
ze_result_t ZeWrapper::zeRTASBuilderGetBuildPropertiesExt(ze_rtas_builder_ext_handle_t hBuilder,
|
||||
const ze_rtas_builder_build_op_ext_desc_t* args,
|
||||
ze_rtas_builder_ext_properties_t* pProp)
|
||||
{
|
||||
if (!handle || !zeRTASBuilderGetBuildPropertiesExpInternal)
|
||||
if (!handle || !zeRTASBuilderGetBuildPropertiesExtInternal)
|
||||
throw std::runtime_error("ZeWrapper not initialized, call ZeWrapper::init() first.");
|
||||
|
||||
return zeRTASBuilderGetBuildPropertiesExpInternal(hBuilder, args, pProp);
|
||||
return zeRTASBuilderGetBuildPropertiesExtInternal(hBuilder, args, pProp);
|
||||
}
|
||||
|
||||
ze_result_t ZeWrapper::zeRTASBuilderBuildExp(ze_rtas_builder_exp_handle_t hBuilder,
|
||||
const ze_rtas_builder_build_op_exp_desc_t* args,
|
||||
ze_result_t ZeWrapper::zeRTASBuilderBuildExt(ze_rtas_builder_ext_handle_t hBuilder,
|
||||
const ze_rtas_builder_build_op_ext_desc_t* args,
|
||||
void *pScratchBuffer, size_t scratchBufferSizeBytes,
|
||||
void *pRtasBuffer, size_t rtasBufferSizeBytes,
|
||||
ze_rtas_parallel_operation_exp_handle_t hParallelOperation,
|
||||
void *pBuildUserPtr, ze_rtas_aabb_exp_t *pBounds, size_t *pRtasBufferSizeBytes)
|
||||
ze_rtas_parallel_operation_ext_handle_t hParallelOperation,
|
||||
void *pBuildUserPtr, ze_rtas_aabb_ext_t *pBounds, size_t *pRtasBufferSizeBytes)
|
||||
{
|
||||
if (!handle || !zeRTASBuilderBuildExpInternal)
|
||||
if (!handle || !zeRTASBuilderBuildExtInternal)
|
||||
throw std::runtime_error("ZeWrapper not initialized, call ZeWrapper::init() first.");
|
||||
|
||||
return zeRTASBuilderBuildExpInternal(hBuilder, args, pScratchBuffer, scratchBufferSizeBytes, pRtasBuffer, rtasBufferSizeBytes,
|
||||
return zeRTASBuilderBuildExtInternal(hBuilder, args, pScratchBuffer, scratchBufferSizeBytes, pRtasBuffer, rtasBufferSizeBytes,
|
||||
hParallelOperation, pBuildUserPtr, pBounds, pRtasBufferSizeBytes);
|
||||
}
|
||||
|
||||
ze_result_t ZeWrapper::zeRTASParallelOperationCreateExp(ze_driver_handle_t hDriver, ze_rtas_parallel_operation_exp_handle_t* phParallelOperation)
|
||||
ze_result_t ZeWrapper::zeRTASParallelOperationCreateExt(ze_driver_handle_t hDriver, ze_rtas_parallel_operation_ext_handle_t* phParallelOperation)
|
||||
{
|
||||
if (!handle || !zeRTASParallelOperationCreateExpInternal)
|
||||
if (!handle || !zeRTASParallelOperationCreateExtInternal)
|
||||
throw std::runtime_error("ZeWrapper not initialized, call ZeWrapper::init() first.");
|
||||
|
||||
return zeRTASParallelOperationCreateExpInternal(hDriver, phParallelOperation);
|
||||
return zeRTASParallelOperationCreateExtInternal(hDriver, phParallelOperation);
|
||||
}
|
||||
|
||||
ze_result_t ZeWrapper::zeRTASParallelOperationDestroyExp( ze_rtas_parallel_operation_exp_handle_t hParallelOperation )
|
||||
ze_result_t ZeWrapper::zeRTASParallelOperationDestroyExt(ze_rtas_parallel_operation_ext_handle_t hParallelOperation)
|
||||
{
|
||||
if (!handle || !zeRTASParallelOperationDestroyExpInternal)
|
||||
if (!handle || !zeRTASParallelOperationDestroyExtInternal)
|
||||
throw std::runtime_error("ZeWrapper not initialized, call ZeWrapper::init() first.");
|
||||
|
||||
return zeRTASParallelOperationDestroyExpInternal( hParallelOperation );
|
||||
return zeRTASParallelOperationDestroyExtInternal(hParallelOperation);
|
||||
};
|
||||
|
||||
ze_result_t ZeWrapper::zeRTASParallelOperationGetPropertiesExp( ze_rtas_parallel_operation_exp_handle_t hParallelOperation, ze_rtas_parallel_operation_exp_properties_t* pProperties )
|
||||
ze_result_t ZeWrapper::zeRTASParallelOperationGetPropertiesExt(ze_rtas_parallel_operation_ext_handle_t hParallelOperation, ze_rtas_parallel_operation_ext_properties_t* pProperties)
|
||||
{
|
||||
if (!handle || !zeRTASParallelOperationGetPropertiesExpInternal)
|
||||
if (!handle || !zeRTASParallelOperationGetPropertiesExtInternal)
|
||||
throw std::runtime_error("ZeWrapper not initialized, call ZeWrapper::init() first.");
|
||||
|
||||
return zeRTASParallelOperationGetPropertiesExpInternal( hParallelOperation, pProperties );
|
||||
return zeRTASParallelOperationGetPropertiesExtInternal(hParallelOperation, pProperties);
|
||||
}
|
||||
|
||||
ze_result_t ZeWrapper::zeRTASParallelOperationJoinExp( ze_rtas_parallel_operation_exp_handle_t hParallelOperation)
|
||||
ze_result_t ZeWrapper::zeRTASParallelOperationJoinExt(ze_rtas_parallel_operation_ext_handle_t hParallelOperation)
|
||||
{
|
||||
if (!handle || !zeRTASParallelOperationJoinExpInternal)
|
||||
if (!handle || !zeRTASParallelOperationJoinExtInternal)
|
||||
throw std::runtime_error("ZeWrapper not initialized, call ZeWrapper::init() first.");
|
||||
|
||||
return zeRTASParallelOperationJoinExpInternal(hParallelOperation);
|
||||
return zeRTASParallelOperationJoinExtInternal(hParallelOperation);
|
||||
}
|
||||
|
||||
@@ -5,10 +5,6 @@
|
||||
|
||||
#include "ze_api.h"
|
||||
|
||||
#if !defined(ZE_RTAS_BUILDER_EXP_NAME)
|
||||
#include "ze_rtas.h"
|
||||
#endif
|
||||
|
||||
//////////////////////
|
||||
// Debug extension
|
||||
|
||||
@@ -40,25 +36,25 @@ struct ZeWrapper
|
||||
static ze_result_t zeDeviceGetProperties(ze_device_handle_t, ze_device_properties_t*);
|
||||
static ze_result_t zeDeviceGetModuleProperties(ze_device_handle_t, ze_device_module_properties_t*);
|
||||
|
||||
static ze_result_t zeRTASBuilderCreateExp(ze_driver_handle_t hDriver, const ze_rtas_builder_exp_desc_t *pDescriptor, ze_rtas_builder_exp_handle_t *phBuilder);
|
||||
static ze_result_t zeRTASBuilderDestroyExp(ze_rtas_builder_exp_handle_t hBuilder);
|
||||
static ze_result_t zeDriverRTASFormatCompatibilityCheckExp( ze_driver_handle_t hDriver,
|
||||
const ze_rtas_format_exp_t accelFormat,
|
||||
const ze_rtas_format_exp_t otherAccelFormat);
|
||||
static ze_result_t zeRTASBuilderGetBuildPropertiesExp(ze_rtas_builder_exp_handle_t hBuilder,
|
||||
const ze_rtas_builder_build_op_exp_desc_t* args,
|
||||
ze_rtas_builder_exp_properties_t* pProp);
|
||||
static ze_result_t zeRTASBuilderBuildExp(ze_rtas_builder_exp_handle_t hBuilder,
|
||||
const ze_rtas_builder_build_op_exp_desc_t* args,
|
||||
static ze_result_t zeRTASBuilderCreateExt(ze_driver_handle_t hDriver, const ze_rtas_builder_ext_desc_t *pDescriptor, ze_rtas_builder_ext_handle_t *phBuilder);
|
||||
static ze_result_t zeRTASBuilderDestroyExt(ze_rtas_builder_ext_handle_t hBuilder);
|
||||
static ze_result_t zeDriverRTASFormatCompatibilityCheckExt(ze_driver_handle_t hDriver,
|
||||
const ze_rtas_format_ext_t accelFormat,
|
||||
const ze_rtas_format_ext_t otherAccelFormat);
|
||||
static ze_result_t zeRTASBuilderGetBuildPropertiesExt(ze_rtas_builder_ext_handle_t hBuilder,
|
||||
const ze_rtas_builder_build_op_ext_desc_t* args,
|
||||
ze_rtas_builder_ext_properties_t* pProp);
|
||||
static ze_result_t zeRTASBuilderBuildExt(ze_rtas_builder_ext_handle_t hBuilder,
|
||||
const ze_rtas_builder_build_op_ext_desc_t* args,
|
||||
void *pScratchBuffer, size_t scratchBufferSizeBytes,
|
||||
void *pRtasBuffer, size_t rtasBufferSizeBytes,
|
||||
ze_rtas_parallel_operation_exp_handle_t hParallelOperation,
|
||||
void *pBuildUserPtr, ze_rtas_aabb_exp_t *pBounds, size_t *pRtasBufferSizeBytes);
|
||||
ze_rtas_parallel_operation_ext_handle_t hParallelOperation,
|
||||
void *pBuildUserPtr, ze_rtas_aabb_ext_t *pBounds, size_t *pRtasBufferSizeBytes);
|
||||
|
||||
static ze_result_t zeRTASParallelOperationCreateExp(ze_driver_handle_t hDriver, ze_rtas_parallel_operation_exp_handle_t* phParallelOperation);
|
||||
static ze_result_t zeRTASParallelOperationDestroyExp( ze_rtas_parallel_operation_exp_handle_t hParallelOperation );
|
||||
static ze_result_t zeRTASParallelOperationGetPropertiesExp( ze_rtas_parallel_operation_exp_handle_t hParallelOperation, ze_rtas_parallel_operation_exp_properties_t* pProperties );
|
||||
static ze_result_t zeRTASParallelOperationJoinExp( ze_rtas_parallel_operation_exp_handle_t hParallelOperation);
|
||||
static ze_result_t zeRTASParallelOperationCreateExt(ze_driver_handle_t hDriver, ze_rtas_parallel_operation_ext_handle_t* phParallelOperation);
|
||||
static ze_result_t zeRTASParallelOperationDestroyExt(ze_rtas_parallel_operation_ext_handle_t hParallelOperation);
|
||||
static ze_result_t zeRTASParallelOperationGetPropertiesExt(ze_rtas_parallel_operation_ext_handle_t hParallelOperation, ze_rtas_parallel_operation_ext_properties_t* pProperties);
|
||||
static ze_result_t zeRTASParallelOperationJoinExt(ze_rtas_parallel_operation_ext_handle_t hParallelOperation);
|
||||
|
||||
static bool rtas_builder_selected;
|
||||
};
|
||||
|
||||
@@ -45,7 +45,7 @@ namespace embree
|
||||
}
|
||||
};
|
||||
|
||||
void* zeRTASInitExp(sycl::device device, sycl::context context)
|
||||
void* zeRTASInit(sycl::device device, sycl::context context)
|
||||
{
|
||||
if (ZeWrapper::init() != ZE_RESULT_SUCCESS)
|
||||
return nullptr;
|
||||
@@ -114,10 +114,10 @@ namespace embree
|
||||
{
|
||||
//std::cout << extensions[i].name << " version " << extensions[i].version << std::endl;
|
||||
|
||||
if (strncmp("ZE_extension_raytracing",extensions[i].name,sizeof(extensions[i].name)) == 0)
|
||||
if (strncmp(ZE_RAYTRACING_EXT_NAME,extensions[i].name,sizeof(extensions[i].name)) == 0)
|
||||
ze_extension_ray_tracing = true;
|
||||
|
||||
if (strncmp("ZE_experimental_rtas_builder",extensions[i].name,sizeof(extensions[i].name)) == 0)
|
||||
if (strncmp(ZE_RTAS_EXT_NAME,extensions[i].name,sizeof(extensions[i].name)) == 0)
|
||||
ze_rtas_builder = true;
|
||||
}
|
||||
if (!ze_extension_ray_tracing)
|
||||
@@ -172,12 +172,34 @@ namespace embree
|
||||
return pvc;
|
||||
}
|
||||
|
||||
static bool hasDriverExtension(ze_driver_handle_t hDriver, const char* extensionName)
|
||||
{
|
||||
uint32_t count = 0;
|
||||
ze_result_t result = ZeWrapper::zeDriverGetExtensionProperties(hDriver, &count, nullptr);
|
||||
if (result != ZE_RESULT_SUCCESS)
|
||||
return false;
|
||||
|
||||
std::vector<ze_driver_extension_properties_t> extensions(count);
|
||||
result = ZeWrapper::zeDriverGetExtensionProperties(hDriver, &count, extensions.data());
|
||||
if (result != ZE_RESULT_SUCCESS)
|
||||
return false;
|
||||
|
||||
for (uint32_t i = 0; i < count; i++)
|
||||
{
|
||||
if (strncmp(extensionName, extensions[i].name, sizeof(extensions[i].name)) == 0)
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
void* rthwifAllocAccelBuffer(Device* embree_device, size_t bytes, sycl::device device, sycl::context context, sycl::usm::alloc alloc_type)
|
||||
{
|
||||
ze_context_handle_t hContext = sycl::get_native<sycl::backend::ext_oneapi_level_zero>(context);
|
||||
ze_device_handle_t hDevice = sycl::get_native<sycl::backend::ext_oneapi_level_zero>(device);
|
||||
sycl::platform platform = device.get_platform();
|
||||
ze_driver_handle_t hDriver = sycl::get_native<sycl::backend::ext_oneapi_level_zero>(platform);
|
||||
|
||||
ze_rtas_device_exp_properties_t rtasProp = { ZE_STRUCTURE_TYPE_RTAS_DEVICE_EXP_PROPERTIES };
|
||||
ze_rtas_device_ext_properties_t rtasProp = { ZE_STRUCTURE_TYPE_RTAS_DEVICE_EXT_PROPERTIES };
|
||||
ze_device_properties_t devProp = { ZE_STRUCTURE_TYPE_DEVICE_PROPERTIES, &rtasProp };
|
||||
ze_result_t err = ZeWrapper::zeDeviceGetProperties(hDevice, &devProp );
|
||||
if (err != ZE_RESULT_SUCCESS)
|
||||
@@ -192,10 +214,17 @@ namespace embree
|
||||
relaxed.stype = ZE_STRUCTURE_TYPE_RELAXED_ALLOCATION_LIMITS_EXP_DESC;
|
||||
relaxed.pNext = &rt_desc;
|
||||
relaxed.flags = ZE_RELAXED_ALLOCATION_LIMITS_EXP_FLAG_MAX_SIZE;
|
||||
|
||||
bool hasRelaxedAllocationLimits = false;
|
||||
if (embree_device) {
|
||||
DeviceGPU* gpu_device = dynamic_cast<DeviceGPU*>(embree_device);
|
||||
if (gpu_device)
|
||||
hasRelaxedAllocationLimits = gpu_device->relaxedAllocationLimitsSupported();
|
||||
}
|
||||
|
||||
ze_memory_compression_hints_ext_desc_t compressed;
|
||||
compressed.stype = ZE_STRUCTURE_TYPE_MEMORY_COMPRESSION_HINTS_EXT_DESC;
|
||||
compressed.pNext = &relaxed;
|
||||
compressed.pNext = hasRelaxedAllocationLimits ? (void*) &relaxed : (void*) &rt_desc;
|
||||
compressed.flags = ZE_MEMORY_COMPRESSION_HINTS_EXT_FLAG_UNCOMPRESSED;
|
||||
|
||||
ze_device_mem_alloc_desc_t device_desc;
|
||||
@@ -251,27 +280,27 @@ namespace embree
|
||||
throw_RTCError(RTC_ERROR_OUT_OF_MEMORY,"rtas memory free failed");
|
||||
}
|
||||
|
||||
struct GEOMETRY_INSTANCE_DESC : ze_rtas_builder_instance_geometry_info_exp_t
|
||||
struct GEOMETRY_INSTANCE_DESC : ze_rtas_builder_instance_geometry_info_ext_t
|
||||
{
|
||||
ze_rtas_transform_float3x4_aligned_column_major_exp_t xfmdata;
|
||||
ze_rtas_transform_float3x4_aligned_column_major_ext_t xfmdata;
|
||||
};
|
||||
|
||||
struct GEOMETRY_TYPE
|
||||
{
|
||||
GEOMETRY_TYPE(ze_rtas_builder_geometry_type_exp_t type, size_t extraBytes = 0)
|
||||
GEOMETRY_TYPE(ze_rtas_builder_geometry_type_ext_t type, size_t extraBytes = 0)
|
||||
: type(type), extraBytes(extraBytes) {}
|
||||
|
||||
ze_rtas_builder_geometry_type_exp_t type;
|
||||
ze_rtas_builder_geometry_type_ext_t type;
|
||||
size_t extraBytes;
|
||||
};
|
||||
|
||||
size_t sizeof_RTHWIF_GEOMETRY(GEOMETRY_TYPE type)
|
||||
{
|
||||
switch (type.type) {
|
||||
case ZE_RTAS_BUILDER_GEOMETRY_TYPE_EXP_TRIANGLES : return sizeof(ze_rtas_builder_triangles_geometry_info_exp_t)+type.extraBytes;
|
||||
case ZE_RTAS_BUILDER_GEOMETRY_TYPE_EXP_QUADS : return sizeof(ze_rtas_builder_quads_geometry_info_exp_t)+type.extraBytes;
|
||||
case ZE_RTAS_BUILDER_GEOMETRY_TYPE_EXP_PROCEDURAL: return sizeof(ze_rtas_builder_procedural_geometry_info_exp_t)+type.extraBytes;
|
||||
case ZE_RTAS_BUILDER_GEOMETRY_TYPE_EXP_INSTANCE : return sizeof(ze_rtas_builder_instance_geometry_info_exp_t)+type.extraBytes;
|
||||
case ZE_RTAS_BUILDER_GEOMETRY_TYPE_EXT_TRIANGLES : return sizeof(ze_rtas_builder_triangles_geometry_info_ext_t)+type.extraBytes;
|
||||
case ZE_RTAS_BUILDER_GEOMETRY_TYPE_EXT_QUADS : return sizeof(ze_rtas_builder_quads_geometry_info_ext_t)+type.extraBytes;
|
||||
case ZE_RTAS_BUILDER_GEOMETRY_TYPE_EXT_PROCEDURAL: return sizeof(ze_rtas_builder_procedural_geometry_info_ext_t)+type.extraBytes;
|
||||
case ZE_RTAS_BUILDER_GEOMETRY_TYPE_EXT_INSTANCE : return sizeof(ze_rtas_builder_instance_geometry_info_ext_t)+type.extraBytes;
|
||||
default: assert(false); return 0;
|
||||
}
|
||||
}
|
||||
@@ -279,69 +308,69 @@ namespace embree
|
||||
size_t alignof_RTHWIF_GEOMETRY(GEOMETRY_TYPE type)
|
||||
{
|
||||
switch (type.type) {
|
||||
case ZE_RTAS_BUILDER_GEOMETRY_TYPE_EXP_TRIANGLES : return alignof(ze_rtas_builder_triangles_geometry_info_exp_t);
|
||||
case ZE_RTAS_BUILDER_GEOMETRY_TYPE_EXP_QUADS : return alignof(ze_rtas_builder_quads_geometry_info_exp_t);
|
||||
case ZE_RTAS_BUILDER_GEOMETRY_TYPE_EXP_PROCEDURAL: return alignof(ze_rtas_builder_procedural_geometry_info_exp_t);
|
||||
case ZE_RTAS_BUILDER_GEOMETRY_TYPE_EXP_INSTANCE : return alignof(ze_rtas_builder_instance_geometry_info_exp_t);
|
||||
case ZE_RTAS_BUILDER_GEOMETRY_TYPE_EXT_TRIANGLES : return alignof(ze_rtas_builder_triangles_geometry_info_ext_t);
|
||||
case ZE_RTAS_BUILDER_GEOMETRY_TYPE_EXT_QUADS : return alignof(ze_rtas_builder_quads_geometry_info_ext_t);
|
||||
case ZE_RTAS_BUILDER_GEOMETRY_TYPE_EXT_PROCEDURAL: return alignof(ze_rtas_builder_procedural_geometry_info_ext_t);
|
||||
case ZE_RTAS_BUILDER_GEOMETRY_TYPE_EXT_INSTANCE : return alignof(ze_rtas_builder_instance_geometry_info_ext_t);
|
||||
default: assert(false); return 0;
|
||||
}
|
||||
}
|
||||
|
||||
ze_rtas_builder_geometry_exp_flags_t getGeometryFlags(Scene* scene, Geometry* geom)
|
||||
ze_rtas_builder_geometry_ext_flags_t getGeometryFlags(Scene* scene, Geometry* geom)
|
||||
{
|
||||
/* invoke any hit callback when Embree filter functions are present */
|
||||
ze_rtas_builder_geometry_exp_flags_t gflags = 0;
|
||||
ze_rtas_builder_geometry_ext_flags_t gflags = 0;
|
||||
if (geom->hasArgumentFilterFunctions() || geom->hasGeometryFilterFunctions())
|
||||
gflags = ZE_RTAS_BUILDER_GEOMETRY_EXP_FLAG_NON_OPAQUE;
|
||||
gflags = ZE_RTAS_BUILDER_GEOMETRY_EXT_FLAG_NON_OPAQUE;
|
||||
|
||||
#if defined(EMBREE_RAY_MASK)
|
||||
/* invoke any hit callback when high mask bits are enabled */
|
||||
if (geom->mask & 0xFFFFFF80)
|
||||
gflags = ZE_RTAS_BUILDER_GEOMETRY_EXP_FLAG_NON_OPAQUE;
|
||||
gflags = ZE_RTAS_BUILDER_GEOMETRY_EXT_FLAG_NON_OPAQUE;
|
||||
#endif
|
||||
|
||||
return gflags;
|
||||
}
|
||||
|
||||
void createGeometryDesc(ze_rtas_builder_triangles_geometry_info_exp_t* out, Scene* scene, TriangleMesh* geom)
|
||||
void createGeometryDesc(ze_rtas_builder_triangles_geometry_info_ext_t* out, Scene* scene, TriangleMesh* geom)
|
||||
{
|
||||
memset(out,0,sizeof(ze_rtas_builder_triangles_geometry_info_exp_t));
|
||||
out->geometryType = ZE_RTAS_BUILDER_GEOMETRY_TYPE_EXP_TRIANGLES;
|
||||
memset(out,0,sizeof(ze_rtas_builder_triangles_geometry_info_ext_t));
|
||||
out->geometryType = ZE_RTAS_BUILDER_GEOMETRY_TYPE_EXT_TRIANGLES;
|
||||
out->geometryFlags = getGeometryFlags(scene,geom);
|
||||
out->geometryMask = mask32_to_mask8(geom->mask);
|
||||
out->triangleFormat = ZE_RTAS_BUILDER_INPUT_DATA_FORMAT_EXP_TRIANGLE_INDICES_UINT32;
|
||||
out->vertexFormat = ZE_RTAS_BUILDER_INPUT_DATA_FORMAT_EXP_FLOAT3;
|
||||
out->pTriangleBuffer = (ze_rtas_triangle_indices_uint32_exp_t*) geom->triangles.getPtr();
|
||||
out->triangleFormat = ZE_RTAS_BUILDER_INPUT_DATA_FORMAT_EXT_TRIANGLE_INDICES_UINT32;
|
||||
out->vertexFormat = ZE_RTAS_BUILDER_INPUT_DATA_FORMAT_EXT_FLOAT3;
|
||||
out->pTriangleBuffer = (ze_rtas_triangle_indices_uint32_ext_t*) geom->triangles.getPtr();
|
||||
out->triangleCount = geom->triangles.size();
|
||||
out->triangleStride = geom->triangles.getStride();
|
||||
out->pVertexBuffer = (ze_rtas_float3_exp_t*) geom->vertices0.getPtr();
|
||||
out->pVertexBuffer = (ze_rtas_float3_ext_t*) geom->vertices0.getPtr();
|
||||
out->vertexCount = geom->vertices0.size();
|
||||
out->vertexStride = geom->vertices0.getStride();
|
||||
}
|
||||
|
||||
void createGeometryDesc(ze_rtas_builder_quads_geometry_info_exp_t* out, Scene* scene, QuadMesh* geom)
|
||||
void createGeometryDesc(ze_rtas_builder_quads_geometry_info_ext_t* out, Scene* scene, QuadMesh* geom)
|
||||
{
|
||||
memset(out,0,sizeof(ze_rtas_builder_quads_geometry_info_exp_t));
|
||||
out->geometryType = ZE_RTAS_BUILDER_GEOMETRY_TYPE_EXP_QUADS;
|
||||
memset(out,0,sizeof(ze_rtas_builder_quads_geometry_info_ext_t));
|
||||
out->geometryType = ZE_RTAS_BUILDER_GEOMETRY_TYPE_EXT_QUADS;
|
||||
out->geometryFlags = getGeometryFlags(scene,geom);
|
||||
out->geometryMask = mask32_to_mask8(geom->mask);
|
||||
out->quadFormat = ZE_RTAS_BUILDER_INPUT_DATA_FORMAT_EXP_QUAD_INDICES_UINT32;
|
||||
out->vertexFormat = ZE_RTAS_BUILDER_INPUT_DATA_FORMAT_EXP_FLOAT3;
|
||||
out->pQuadBuffer = (ze_rtas_quad_indices_uint32_exp_t*) geom->quads.getPtr();
|
||||
out->quadFormat = ZE_RTAS_BUILDER_INPUT_DATA_FORMAT_EXT_QUAD_INDICES_UINT32;
|
||||
out->vertexFormat = ZE_RTAS_BUILDER_INPUT_DATA_FORMAT_EXT_FLOAT3;
|
||||
out->pQuadBuffer = (ze_rtas_quad_indices_uint32_ext_t*) geom->quads.getPtr();
|
||||
out->quadCount = geom->quads.size();
|
||||
out->quadStride = geom->quads.getStride();
|
||||
out->pVertexBuffer = (ze_rtas_float3_exp_t*) geom->vertices0.getPtr();
|
||||
out->pVertexBuffer = (ze_rtas_float3_ext_t*) geom->vertices0.getPtr();
|
||||
out->vertexCount = geom->vertices0.size();
|
||||
out->vertexStride = geom->vertices0.getStride();
|
||||
}
|
||||
|
||||
void getProceduralAABB(ze_rtas_geometry_aabbs_exp_cb_params_t* params)
|
||||
void getProceduralAABB(ze_rtas_geometry_aabbs_ext_cb_params_t* params)
|
||||
{
|
||||
assert(params->stype == ZE_STRUCTURE_TYPE_RTAS_GEOMETRY_AABBS_EXP_CB_PARAMS);
|
||||
assert(params->stype == ZE_STRUCTURE_TYPE_RTAS_GEOMETRY_AABBS_EXT_CB_PARAMS);
|
||||
|
||||
BBox1f time_range = * (BBox1f*) params->pBuildUserPtr;
|
||||
Geometry* geom = (Geometry*) params->pGeomUserPtr;
|
||||
ze_rtas_aabb_exp_t* boundsOut = params->pBoundsOut;
|
||||
ze_rtas_aabb_ext_t* boundsOut = params->pBoundsOut;
|
||||
|
||||
for (uint32_t i=0; i<params->primIDCount; i++)
|
||||
{
|
||||
@@ -379,14 +408,14 @@ namespace embree
|
||||
}
|
||||
};
|
||||
|
||||
void createGeometryDescProcedural(ze_rtas_builder_procedural_geometry_info_exp_t* out, Scene* scene, Geometry* geom)
|
||||
void createGeometryDescProcedural(ze_rtas_builder_procedural_geometry_info_ext_t* out, Scene* scene, Geometry* geom)
|
||||
{
|
||||
uint32_t numPrimitives = geom->size();
|
||||
if (GridMesh* mesh = dynamic_cast<GridMesh*>(geom))
|
||||
numPrimitives = mesh->getNumTotalQuads(); // FIXME: slow
|
||||
|
||||
memset(out,0,sizeof(ze_rtas_builder_procedural_geometry_info_exp_t));
|
||||
out->geometryType = ZE_RTAS_BUILDER_GEOMETRY_TYPE_EXP_PROCEDURAL;
|
||||
memset(out,0,sizeof(ze_rtas_builder_procedural_geometry_info_ext_t));
|
||||
out->geometryType = ZE_RTAS_BUILDER_GEOMETRY_TYPE_EXT_PROCEDURAL;
|
||||
out->geometryFlags = 0;
|
||||
out->geometryMask = mask32_to_mask8(geom->mask);
|
||||
out->primCount = numPrimitives;
|
||||
@@ -398,64 +427,64 @@ namespace embree
|
||||
{
|
||||
assert(geom->gsubtype == AccelSet::GTY_SUBTYPE_INSTANCE_QUATERNION);
|
||||
memset(out,0,sizeof(GEOMETRY_INSTANCE_DESC));
|
||||
out->geometryType = ZE_RTAS_BUILDER_GEOMETRY_TYPE_EXP_INSTANCE;
|
||||
out->geometryType = ZE_RTAS_BUILDER_GEOMETRY_TYPE_EXT_INSTANCE;
|
||||
out->instanceFlags = 0;
|
||||
out->geometryMask = mask32_to_mask8(geom->mask);
|
||||
out->instanceUserID = 0;
|
||||
const AffineSpace3fa local2world = geom->getLocal2World();
|
||||
out->transformFormat = ZE_RTAS_BUILDER_INPUT_DATA_FORMAT_EXP_FLOAT3X4_ALIGNED_COLUMN_MAJOR;
|
||||
out->transformFormat = ZE_RTAS_BUILDER_INPUT_DATA_FORMAT_EXT_FLOAT3X4_ALIGNED_COLUMN_MAJOR;
|
||||
out->pTransform = (float*) &out->xfmdata;
|
||||
out->pBounds = (ze_rtas_aabb_exp_t*) &dynamic_cast<Scene*>(geom->object)->accelBuffer.getBounds();
|
||||
out->xfmdata = *(ze_rtas_transform_float3x4_aligned_column_major_exp_t*) &local2world;
|
||||
out->pBounds = (ze_rtas_aabb_ext_t*) &dynamic_cast<Scene*>(geom->object)->accelBuffer.getBounds();
|
||||
out->xfmdata = *(ze_rtas_transform_float3x4_aligned_column_major_ext_t*) &local2world;
|
||||
out->pAccelerationStructure = dynamic_cast<Scene*>(geom->object)->accelBuffer.getAccelBufferDeviceData(0);
|
||||
}
|
||||
|
||||
void createGeometryDesc(ze_rtas_builder_instance_geometry_info_exp_t* out, Scene* scene, Instance* geom)
|
||||
void createGeometryDesc(ze_rtas_builder_instance_geometry_info_ext_t* out, Scene* scene, Instance* geom)
|
||||
{
|
||||
assert(geom->gsubtype == AccelSet::GTY_SUBTYPE_DEFAULT);
|
||||
memset(out,0,sizeof(ze_rtas_builder_instance_geometry_info_exp_t));
|
||||
out->geometryType = ZE_RTAS_BUILDER_GEOMETRY_TYPE_EXP_INSTANCE;
|
||||
memset(out,0,sizeof(ze_rtas_builder_instance_geometry_info_ext_t));
|
||||
out->geometryType = ZE_RTAS_BUILDER_GEOMETRY_TYPE_EXT_INSTANCE;
|
||||
out->instanceFlags = 0;
|
||||
out->geometryMask = mask32_to_mask8(geom->mask);
|
||||
out->instanceUserID = 0;
|
||||
out->transformFormat = ZE_RTAS_BUILDER_INPUT_DATA_FORMAT_EXP_FLOAT3X4_ALIGNED_COLUMN_MAJOR;
|
||||
out->transformFormat = ZE_RTAS_BUILDER_INPUT_DATA_FORMAT_EXT_FLOAT3X4_ALIGNED_COLUMN_MAJOR;
|
||||
out->pTransform = (float*) &geom->local2world[0];
|
||||
out->pBounds = (ze_rtas_aabb_exp_t*) &dynamic_cast<Scene*>(geom->object)->accelBuffer.getBounds();
|
||||
out->pBounds = (ze_rtas_aabb_ext_t*) &dynamic_cast<Scene*>(geom->object)->accelBuffer.getBounds();
|
||||
out->pAccelerationStructure = dynamic_cast<Scene*>(geom->object)->accelBuffer.getAccelBufferDeviceData(0);
|
||||
}
|
||||
|
||||
void createGeometryDesc(char* out, Scene* scene, Geometry* geom, GEOMETRY_TYPE type)
|
||||
{
|
||||
switch (type.type) {
|
||||
case ZE_RTAS_BUILDER_GEOMETRY_TYPE_EXP_TRIANGLES : return createGeometryDesc((ze_rtas_builder_triangles_geometry_info_exp_t*)out,scene,dynamic_cast<TriangleMesh*>(geom));
|
||||
case ZE_RTAS_BUILDER_GEOMETRY_TYPE_EXP_QUADS : return createGeometryDesc((ze_rtas_builder_quads_geometry_info_exp_t*)out,scene,dynamic_cast<QuadMesh*>(geom));
|
||||
case ZE_RTAS_BUILDER_GEOMETRY_TYPE_EXP_PROCEDURAL: return createGeometryDescProcedural((ze_rtas_builder_procedural_geometry_info_exp_t*)out,scene,geom);
|
||||
case ZE_RTAS_BUILDER_GEOMETRY_TYPE_EXP_INSTANCE:
|
||||
case ZE_RTAS_BUILDER_GEOMETRY_TYPE_EXT_TRIANGLES : return createGeometryDesc((ze_rtas_builder_triangles_geometry_info_ext_t*)out,scene,dynamic_cast<TriangleMesh*>(geom));
|
||||
case ZE_RTAS_BUILDER_GEOMETRY_TYPE_EXT_QUADS : return createGeometryDesc((ze_rtas_builder_quads_geometry_info_ext_t*)out,scene,dynamic_cast<QuadMesh*>(geom));
|
||||
case ZE_RTAS_BUILDER_GEOMETRY_TYPE_EXT_PROCEDURAL: return createGeometryDescProcedural((ze_rtas_builder_procedural_geometry_info_ext_t*)out,scene,geom);
|
||||
case ZE_RTAS_BUILDER_GEOMETRY_TYPE_EXT_INSTANCE:
|
||||
if (type.extraBytes) return createGeometryDesc((GEOMETRY_INSTANCE_DESC*)out,scene,dynamic_cast<Instance*>(geom));
|
||||
else return createGeometryDesc((ze_rtas_builder_instance_geometry_info_exp_t*)out,scene,dynamic_cast<Instance*>(geom));
|
||||
else return createGeometryDesc((ze_rtas_builder_instance_geometry_info_ext_t*)out,scene,dynamic_cast<Instance*>(geom));
|
||||
default: assert(false);
|
||||
}
|
||||
}
|
||||
|
||||
ze_rtas_builder_build_quality_hint_exp_t convertBuildQuality(RTCBuildQuality quality_flags)
|
||||
ze_rtas_builder_build_quality_hint_ext_t convertBuildQuality(RTCBuildQuality quality_flags)
|
||||
{
|
||||
switch (quality_flags) {
|
||||
case RTC_BUILD_QUALITY_LOW : return ZE_RTAS_BUILDER_BUILD_QUALITY_HINT_EXP_LOW;
|
||||
case RTC_BUILD_QUALITY_MEDIUM : return ZE_RTAS_BUILDER_BUILD_QUALITY_HINT_EXP_MEDIUM;
|
||||
case RTC_BUILD_QUALITY_HIGH : return ZE_RTAS_BUILDER_BUILD_QUALITY_HINT_EXP_HIGH;
|
||||
case RTC_BUILD_QUALITY_REFIT : return ZE_RTAS_BUILDER_BUILD_QUALITY_HINT_EXP_LOW;
|
||||
default : return ZE_RTAS_BUILDER_BUILD_QUALITY_HINT_EXP_MEDIUM;
|
||||
case RTC_BUILD_QUALITY_LOW : return ZE_RTAS_BUILDER_BUILD_QUALITY_HINT_EXT_LOW;
|
||||
case RTC_BUILD_QUALITY_MEDIUM : return ZE_RTAS_BUILDER_BUILD_QUALITY_HINT_EXT_MEDIUM;
|
||||
case RTC_BUILD_QUALITY_HIGH : return ZE_RTAS_BUILDER_BUILD_QUALITY_HINT_EXT_HIGH;
|
||||
case RTC_BUILD_QUALITY_REFIT : return ZE_RTAS_BUILDER_BUILD_QUALITY_HINT_EXT_LOW;
|
||||
default : return ZE_RTAS_BUILDER_BUILD_QUALITY_HINT_EXT_MEDIUM;
|
||||
}
|
||||
}
|
||||
|
||||
ze_rtas_builder_build_op_exp_flags_t convertBuildFlags(RTCSceneFlags scene_flags, RTCBuildQuality quality_flags)
|
||||
ze_rtas_builder_build_op_ext_flags_t convertBuildFlags(RTCSceneFlags scene_flags, RTCBuildQuality quality_flags)
|
||||
{
|
||||
ze_rtas_builder_build_op_exp_flags_t result = 0;
|
||||
if (scene_flags & RTC_SCENE_FLAG_COMPACT) result |= ZE_RTAS_BUILDER_BUILD_OP_EXP_FLAG_COMPACT;
|
||||
ze_rtas_builder_build_op_ext_flags_t result = 0;
|
||||
if (scene_flags & RTC_SCENE_FLAG_COMPACT) result |= ZE_RTAS_BUILDER_BUILD_OP_EXT_FLAG_COMPACT;
|
||||
|
||||
/* only in high quality build mode spatial splits are allowed in Embree */
|
||||
if (quality_flags != RTC_BUILD_QUALITY_HIGH)
|
||||
result |= ZE_RTAS_BUILDER_BUILD_OP_EXP_FLAG_NO_DUPLICATE_ANYHIT_INVOCATION;
|
||||
result |= ZE_RTAS_BUILDER_BUILD_OP_EXT_FLAG_NO_DUPLICATE_ANYHIT_INVOCATION;
|
||||
|
||||
return result;
|
||||
}
|
||||
@@ -474,9 +503,9 @@ namespace embree
|
||||
ze_driver_handle_t hDriver = sycl::get_native<sycl::backend::ext_oneapi_level_zero>(platform);
|
||||
|
||||
/* create L0 builder object */
|
||||
ze_rtas_builder_exp_desc_t builderDesc = { ZE_STRUCTURE_TYPE_RTAS_BUILDER_EXP_DESC };
|
||||
ze_rtas_builder_exp_handle_t hBuilder = nullptr;
|
||||
ze_result_t err = ZeWrapper::zeRTASBuilderCreateExp(hDriver, &builderDesc, &hBuilder);
|
||||
ze_rtas_builder_ext_desc_t builderDesc = { ZE_STRUCTURE_TYPE_RTAS_BUILDER_EXT_DESC, nullptr, ZE_RTAS_BUILDER_EXT_VERSION_CURRENT };
|
||||
ze_rtas_builder_ext_handle_t hBuilder = nullptr;
|
||||
ze_result_t err = ZeWrapper::zeRTASBuilderCreateExt(hDriver, &builderDesc, &hBuilder);
|
||||
if (err != ZE_RESULT_SUCCESS)
|
||||
throw_RTCError(RTC_ERROR_UNKNOWN, "ze_rtas_builder creation failed");
|
||||
|
||||
@@ -484,59 +513,59 @@ namespace embree
|
||||
{
|
||||
/* no HW support for MB yet */
|
||||
if (scene->get(geomID)->numTimeSegments() > 0)
|
||||
return ZE_RTAS_BUILDER_GEOMETRY_TYPE_EXP_PROCEDURAL;
|
||||
return ZE_RTAS_BUILDER_GEOMETRY_TYPE_EXT_PROCEDURAL;
|
||||
|
||||
switch (scene->get(geomID)->getType()) {
|
||||
case Geometry::GTY_FLAT_LINEAR_CURVE : return ZE_RTAS_BUILDER_GEOMETRY_TYPE_EXP_PROCEDURAL; break;
|
||||
case Geometry::GTY_ROUND_LINEAR_CURVE : return ZE_RTAS_BUILDER_GEOMETRY_TYPE_EXP_PROCEDURAL; break;
|
||||
case Geometry::GTY_ORIENTED_LINEAR_CURVE: return ZE_RTAS_BUILDER_GEOMETRY_TYPE_EXP_PROCEDURAL; break;
|
||||
case Geometry::GTY_CONE_LINEAR_CURVE : return ZE_RTAS_BUILDER_GEOMETRY_TYPE_EXP_PROCEDURAL; break;
|
||||
case Geometry::GTY_FLAT_LINEAR_CURVE : return ZE_RTAS_BUILDER_GEOMETRY_TYPE_EXT_PROCEDURAL; break;
|
||||
case Geometry::GTY_ROUND_LINEAR_CURVE : return ZE_RTAS_BUILDER_GEOMETRY_TYPE_EXT_PROCEDURAL; break;
|
||||
case Geometry::GTY_ORIENTED_LINEAR_CURVE: return ZE_RTAS_BUILDER_GEOMETRY_TYPE_EXT_PROCEDURAL; break;
|
||||
case Geometry::GTY_CONE_LINEAR_CURVE : return ZE_RTAS_BUILDER_GEOMETRY_TYPE_EXT_PROCEDURAL; break;
|
||||
|
||||
case Geometry::GTY_FLAT_BEZIER_CURVE : return ZE_RTAS_BUILDER_GEOMETRY_TYPE_EXP_PROCEDURAL; break;
|
||||
case Geometry::GTY_ROUND_BEZIER_CURVE : return ZE_RTAS_BUILDER_GEOMETRY_TYPE_EXP_PROCEDURAL; break;
|
||||
case Geometry::GTY_ORIENTED_BEZIER_CURVE: return ZE_RTAS_BUILDER_GEOMETRY_TYPE_EXP_PROCEDURAL; break;
|
||||
case Geometry::GTY_FLAT_BEZIER_CURVE : return ZE_RTAS_BUILDER_GEOMETRY_TYPE_EXT_PROCEDURAL; break;
|
||||
case Geometry::GTY_ROUND_BEZIER_CURVE : return ZE_RTAS_BUILDER_GEOMETRY_TYPE_EXT_PROCEDURAL; break;
|
||||
case Geometry::GTY_ORIENTED_BEZIER_CURVE: return ZE_RTAS_BUILDER_GEOMETRY_TYPE_EXT_PROCEDURAL; break;
|
||||
|
||||
case Geometry::GTY_FLAT_BSPLINE_CURVE : return ZE_RTAS_BUILDER_GEOMETRY_TYPE_EXP_PROCEDURAL; break;
|
||||
case Geometry::GTY_ROUND_BSPLINE_CURVE : return ZE_RTAS_BUILDER_GEOMETRY_TYPE_EXP_PROCEDURAL; break;
|
||||
case Geometry::GTY_ORIENTED_BSPLINE_CURVE: return ZE_RTAS_BUILDER_GEOMETRY_TYPE_EXP_PROCEDURAL; break;
|
||||
case Geometry::GTY_FLAT_BSPLINE_CURVE : return ZE_RTAS_BUILDER_GEOMETRY_TYPE_EXT_PROCEDURAL; break;
|
||||
case Geometry::GTY_ROUND_BSPLINE_CURVE : return ZE_RTAS_BUILDER_GEOMETRY_TYPE_EXT_PROCEDURAL; break;
|
||||
case Geometry::GTY_ORIENTED_BSPLINE_CURVE: return ZE_RTAS_BUILDER_GEOMETRY_TYPE_EXT_PROCEDURAL; break;
|
||||
|
||||
case Geometry::GTY_FLAT_HERMITE_CURVE : return ZE_RTAS_BUILDER_GEOMETRY_TYPE_EXP_PROCEDURAL; break;
|
||||
case Geometry::GTY_ROUND_HERMITE_CURVE : return ZE_RTAS_BUILDER_GEOMETRY_TYPE_EXP_PROCEDURAL; break;
|
||||
case Geometry::GTY_ORIENTED_HERMITE_CURVE: return ZE_RTAS_BUILDER_GEOMETRY_TYPE_EXP_PROCEDURAL; break;
|
||||
case Geometry::GTY_FLAT_HERMITE_CURVE : return ZE_RTAS_BUILDER_GEOMETRY_TYPE_EXT_PROCEDURAL; break;
|
||||
case Geometry::GTY_ROUND_HERMITE_CURVE : return ZE_RTAS_BUILDER_GEOMETRY_TYPE_EXT_PROCEDURAL; break;
|
||||
case Geometry::GTY_ORIENTED_HERMITE_CURVE: return ZE_RTAS_BUILDER_GEOMETRY_TYPE_EXT_PROCEDURAL; break;
|
||||
|
||||
case Geometry::GTY_FLAT_CATMULL_ROM_CURVE : return ZE_RTAS_BUILDER_GEOMETRY_TYPE_EXP_PROCEDURAL; break;
|
||||
case Geometry::GTY_ROUND_CATMULL_ROM_CURVE : return ZE_RTAS_BUILDER_GEOMETRY_TYPE_EXP_PROCEDURAL; break;
|
||||
case Geometry::GTY_ORIENTED_CATMULL_ROM_CURVE: return ZE_RTAS_BUILDER_GEOMETRY_TYPE_EXP_PROCEDURAL; break;
|
||||
case Geometry::GTY_FLAT_CATMULL_ROM_CURVE : return ZE_RTAS_BUILDER_GEOMETRY_TYPE_EXT_PROCEDURAL; break;
|
||||
case Geometry::GTY_ROUND_CATMULL_ROM_CURVE : return ZE_RTAS_BUILDER_GEOMETRY_TYPE_EXT_PROCEDURAL; break;
|
||||
case Geometry::GTY_ORIENTED_CATMULL_ROM_CURVE: return ZE_RTAS_BUILDER_GEOMETRY_TYPE_EXT_PROCEDURAL; break;
|
||||
|
||||
case Geometry::GTY_TRIANGLE_MESH: return ZE_RTAS_BUILDER_GEOMETRY_TYPE_EXP_TRIANGLES; break;
|
||||
case Geometry::GTY_QUAD_MESH : return ZE_RTAS_BUILDER_GEOMETRY_TYPE_EXP_QUADS; break;
|
||||
case Geometry::GTY_GRID_MESH : return ZE_RTAS_BUILDER_GEOMETRY_TYPE_EXP_PROCEDURAL; break;
|
||||
case Geometry::GTY_SUBDIV_MESH : assert(false); return ZE_RTAS_BUILDER_GEOMETRY_TYPE_EXP_PROCEDURAL; break;
|
||||
case Geometry::GTY_TRIANGLE_MESH: return ZE_RTAS_BUILDER_GEOMETRY_TYPE_EXT_TRIANGLES; break;
|
||||
case Geometry::GTY_QUAD_MESH : return ZE_RTAS_BUILDER_GEOMETRY_TYPE_EXT_QUADS; break;
|
||||
case Geometry::GTY_GRID_MESH : return ZE_RTAS_BUILDER_GEOMETRY_TYPE_EXT_PROCEDURAL; break;
|
||||
case Geometry::GTY_SUBDIV_MESH : assert(false); return ZE_RTAS_BUILDER_GEOMETRY_TYPE_EXT_PROCEDURAL; break;
|
||||
|
||||
case Geometry::GTY_SPHERE_POINT : return ZE_RTAS_BUILDER_GEOMETRY_TYPE_EXP_PROCEDURAL; break;
|
||||
case Geometry::GTY_DISC_POINT : return ZE_RTAS_BUILDER_GEOMETRY_TYPE_EXP_PROCEDURAL; break;
|
||||
case Geometry::GTY_ORIENTED_DISC_POINT: return ZE_RTAS_BUILDER_GEOMETRY_TYPE_EXP_PROCEDURAL; break;
|
||||
case Geometry::GTY_SPHERE_POINT : return ZE_RTAS_BUILDER_GEOMETRY_TYPE_EXT_PROCEDURAL; break;
|
||||
case Geometry::GTY_DISC_POINT : return ZE_RTAS_BUILDER_GEOMETRY_TYPE_EXT_PROCEDURAL; break;
|
||||
case Geometry::GTY_ORIENTED_DISC_POINT: return ZE_RTAS_BUILDER_GEOMETRY_TYPE_EXT_PROCEDURAL; break;
|
||||
|
||||
case Geometry::GTY_USER_GEOMETRY : return ZE_RTAS_BUILDER_GEOMETRY_TYPE_EXP_PROCEDURAL; break;
|
||||
case Geometry::GTY_INSTANCE_ARRAY : return ZE_RTAS_BUILDER_GEOMETRY_TYPE_EXP_PROCEDURAL; break;
|
||||
case Geometry::GTY_USER_GEOMETRY : return ZE_RTAS_BUILDER_GEOMETRY_TYPE_EXT_PROCEDURAL; break;
|
||||
case Geometry::GTY_INSTANCE_ARRAY : return ZE_RTAS_BUILDER_GEOMETRY_TYPE_EXT_PROCEDURAL; break;
|
||||
|
||||
#if RTC_MAX_INSTANCE_LEVEL_COUNT < 2
|
||||
case Geometry::GTY_INSTANCE_CHEAP :
|
||||
case Geometry::GTY_INSTANCE_EXPENSIVE: {
|
||||
Instance* instance = scene->get<Instance>(geomID);
|
||||
Scene* instanced_scene = (Scene*)instance->object;
|
||||
if (instanced_scene->hasMotionBlur()) return ZE_RTAS_BUILDER_GEOMETRY_TYPE_EXP_PROCEDURAL; // we need to handle instances in procedural mode if instanced scene has motion blur
|
||||
if (instance->mask & 0xFFFFFF80) return ZE_RTAS_BUILDER_GEOMETRY_TYPE_EXP_PROCEDURAL; // we need to handle instances in procedural mode if high mask bits are set
|
||||
if (instanced_scene->hasMotionBlur()) return ZE_RTAS_BUILDER_GEOMETRY_TYPE_EXT_PROCEDURAL; // we need to handle instances in procedural mode if instanced scene has motion blur
|
||||
if (instance->mask & 0xFFFFFF80) return ZE_RTAS_BUILDER_GEOMETRY_TYPE_EXT_PROCEDURAL; // we need to handle instances in procedural mode if high mask bits are set
|
||||
else if (instance->gsubtype == AccelSet::GTY_SUBTYPE_INSTANCE_QUATERNION)
|
||||
return GEOMETRY_TYPE(ZE_RTAS_BUILDER_GEOMETRY_TYPE_EXP_INSTANCE,sizeof(GEOMETRY_INSTANCE_DESC)-sizeof(ze_rtas_builder_instance_geometry_info_exp_t));
|
||||
else return ZE_RTAS_BUILDER_GEOMETRY_TYPE_EXP_INSTANCE;
|
||||
return GEOMETRY_TYPE(ZE_RTAS_BUILDER_GEOMETRY_TYPE_EXT_INSTANCE,sizeof(GEOMETRY_INSTANCE_DESC)-sizeof(ze_rtas_builder_instance_geometry_info_ext_t));
|
||||
else return ZE_RTAS_BUILDER_GEOMETRY_TYPE_EXT_INSTANCE;
|
||||
}
|
||||
#else
|
||||
case Geometry::GTY_INSTANCE_CHEAP : return ZE_RTAS_BUILDER_GEOMETRY_TYPE_EXP_PROCEDURAL; break;
|
||||
case Geometry::GTY_INSTANCE_EXPENSIVE: return ZE_RTAS_BUILDER_GEOMETRY_TYPE_EXP_PROCEDURAL; break;
|
||||
case Geometry::GTY_INSTANCE_CHEAP : return ZE_RTAS_BUILDER_GEOMETRY_TYPE_EXT_PROCEDURAL; break;
|
||||
case Geometry::GTY_INSTANCE_EXPENSIVE: return ZE_RTAS_BUILDER_GEOMETRY_TYPE_EXT_PROCEDURAL; break;
|
||||
#endif
|
||||
|
||||
default: assert(false); return ZE_RTAS_BUILDER_GEOMETRY_TYPE_EXP_PROCEDURAL;
|
||||
default: assert(false); return ZE_RTAS_BUILDER_GEOMETRY_TYPE_EXT_PROCEDURAL;
|
||||
}
|
||||
};
|
||||
|
||||
@@ -560,7 +589,7 @@ namespace embree
|
||||
}
|
||||
|
||||
/* fill geomdesc buffers */
|
||||
mvector<ze_rtas_builder_geometry_info_exp_t*> geomDescr(scene->device, scene->size());
|
||||
mvector<ze_rtas_builder_geometry_info_ext_t*> geomDescr(scene->device, scene->size());
|
||||
mvector<char> geomDescrData(scene->device,totalBytes);
|
||||
|
||||
size_t offset = 0;
|
||||
@@ -573,17 +602,17 @@ namespace embree
|
||||
const GEOMETRY_TYPE type = getType(geomID);
|
||||
align(offset,alignof_RTHWIF_GEOMETRY(type));
|
||||
createGeometryDesc(&geomDescrData[offset],scene,scene->get(geomID),type);
|
||||
geomDescr[geomID] = (ze_rtas_builder_geometry_info_exp_t*) &geomDescrData[offset];
|
||||
geomDescr[geomID] = (ze_rtas_builder_geometry_info_ext_t*) &geomDescrData[offset];
|
||||
offset += sizeof_RTHWIF_GEOMETRY(type);
|
||||
assert(offset <= geomDescrData.size());
|
||||
}
|
||||
|
||||
ze_rtas_parallel_operation_exp_handle_t parallelOperation = nullptr;
|
||||
err = ZeWrapper::zeRTASParallelOperationCreateExp(hDriver, ¶llelOperation);
|
||||
ze_rtas_parallel_operation_ext_handle_t parallelOperation = nullptr;
|
||||
err = ZeWrapper::zeRTASParallelOperationCreateExt(hDriver, ¶llelOperation);
|
||||
if (err != ZE_RESULT_SUCCESS)
|
||||
throw_RTCError(RTC_ERROR_UNKNOWN, "parallel operation creation failed");
|
||||
|
||||
ze_rtas_device_exp_properties_t rtasProp = { ZE_STRUCTURE_TYPE_RTAS_DEVICE_EXP_PROPERTIES };
|
||||
ze_rtas_device_ext_properties_t rtasProp = { ZE_STRUCTURE_TYPE_RTAS_DEVICE_EXT_PROPERTIES };
|
||||
ze_device_properties_t devProp = { ZE_STRUCTURE_TYPE_DEVICE_PROPERTIES, &rtasProp };
|
||||
err = ZeWrapper::zeDeviceGetProperties(hDevice, &devProp );
|
||||
if (err != ZE_RESULT_SUCCESS)
|
||||
@@ -591,15 +620,15 @@ namespace embree
|
||||
|
||||
/* estimate static accel size */
|
||||
BBox1f time_range(0,1);
|
||||
ze_rtas_aabb_exp_t bounds;
|
||||
ze_rtas_builder_build_op_exp_desc_t args;
|
||||
ze_rtas_aabb_ext_t bounds;
|
||||
ze_rtas_builder_build_op_ext_desc_t args;
|
||||
memset(&args,0,sizeof(args));
|
||||
args.stype = ZE_STRUCTURE_TYPE_RTAS_BUILDER_BUILD_OP_EXP_DESC;
|
||||
args.stype = ZE_STRUCTURE_TYPE_RTAS_BUILDER_BUILD_OP_EXT_DESC;
|
||||
args.pNext = nullptr;
|
||||
args.rtasFormat = rtasProp.rtasFormat;
|
||||
args.buildQuality = convertBuildQuality(scene->quality_flags);
|
||||
args.buildFlags = convertBuildFlags(scene->scene_flags,scene->quality_flags);
|
||||
args.ppGeometries = (const ze_rtas_builder_geometry_info_exp_t**) geomDescr.data();
|
||||
args.ppGeometries = (const ze_rtas_builder_geometry_info_ext_t**) geomDescr.data();
|
||||
args.numGeometries = geomDescr.size();
|
||||
|
||||
/* just for debugging purposes */
|
||||
@@ -609,8 +638,8 @@ namespace embree
|
||||
args.pNext = &buildOpDebug;
|
||||
#endif
|
||||
|
||||
ze_rtas_builder_exp_properties_t sizeTotal = { ZE_STRUCTURE_TYPE_RTAS_BUILDER_EXP_PROPERTIES };
|
||||
err = ZeWrapper::zeRTASBuilderGetBuildPropertiesExp(hBuilder,&args,&sizeTotal);
|
||||
ze_rtas_builder_ext_properties_t sizeTotal = { ZE_STRUCTURE_TYPE_RTAS_BUILDER_EXT_PROPERTIES };
|
||||
err = ZeWrapper::zeRTASBuilderGetBuildPropertiesExt(hBuilder,&args,&sizeTotal);
|
||||
if (err != ZE_RESULT_SUCCESS)
|
||||
throw_RTCError(RTC_ERROR_UNKNOWN,"BVH size estimate failed");
|
||||
|
||||
@@ -622,7 +651,7 @@ namespace embree
|
||||
while (true)
|
||||
{
|
||||
/* estimate size of all mblur BVHs */
|
||||
ze_rtas_builder_exp_properties_t size = { ZE_STRUCTURE_TYPE_RTAS_BUILDER_EXP_PROPERTIES };
|
||||
ze_rtas_builder_ext_properties_t size = { ZE_STRUCTURE_TYPE_RTAS_BUILDER_EXT_PROPERTIES };
|
||||
size.rtasBufferSizeBytesExpected = maxTimeSegments*sizeTotal.rtasBufferSizeBytesExpected;
|
||||
size.rtasBufferSizeBytesMaxRequired = maxTimeSegments*sizeTotal.rtasBufferSizeBytesMaxRequired;
|
||||
size_t bytes = size.rtasBufferSizeBytesExpected;
|
||||
@@ -642,26 +671,26 @@ namespace embree
|
||||
size_t accelBufferBytes = sizeTotal.rtasBufferSizeBytesExpected;
|
||||
bounds = { { INFINITY, INFINITY, INFINITY }, { -INFINITY, -INFINITY, -INFINITY } };
|
||||
|
||||
err = ZeWrapper::zeRTASBuilderBuildExp(hBuilder,&args,
|
||||
err = ZeWrapper::zeRTASBuilderBuildExt(hBuilder,&args,
|
||||
scratchBuffer.data(),scratchBuffer.size(),
|
||||
accelBuffer, accelBufferBytes,
|
||||
parallelOperation,
|
||||
&time_range, &bounds, nullptr);
|
||||
if (parallelOperation)
|
||||
{
|
||||
assert(err == ZE_RESULT_EXP_RTAS_BUILD_DEFERRED);
|
||||
assert(err == ZE_RESULT_EXT_RTAS_BUILD_DEFERRED);
|
||||
|
||||
ze_rtas_parallel_operation_exp_properties_t prop = { ZE_STRUCTURE_TYPE_RTAS_PARALLEL_OPERATION_EXP_PROPERTIES };
|
||||
err = ZeWrapper::zeRTASParallelOperationGetPropertiesExp(parallelOperation,&prop);
|
||||
ze_rtas_parallel_operation_ext_properties_t prop = { ZE_STRUCTURE_TYPE_RTAS_PARALLEL_OPERATION_EXT_PROPERTIES };
|
||||
err = ZeWrapper::zeRTASParallelOperationGetPropertiesExt(parallelOperation,&prop);
|
||||
if (err != ZE_RESULT_SUCCESS)
|
||||
throw_RTCError(RTC_ERROR_UNKNOWN, "get max concurrency failed");
|
||||
|
||||
parallel_for(prop.maxConcurrency, [&](uint32_t) { err = ZeWrapper::zeRTASParallelOperationJoinExp(parallelOperation); });
|
||||
parallel_for(prop.maxConcurrency, [&](uint32_t) { err = ZeWrapper::zeRTASParallelOperationJoinExt(parallelOperation); });
|
||||
}
|
||||
|
||||
fullBounds.extend(*(BBox3f*) &bounds);
|
||||
|
||||
if (err == ZE_RESULT_EXP_RTAS_BUILD_RETRY)
|
||||
if (err == ZE_RESULT_EXT_RTAS_BUILD_RETRY)
|
||||
{
|
||||
if (sizeTotal.rtasBufferSizeBytesExpected == sizeTotal.rtasBufferSizeBytesMaxRequired)
|
||||
throw_RTCError(RTC_ERROR_UNKNOWN,"build error");
|
||||
@@ -672,19 +701,19 @@ namespace embree
|
||||
|
||||
if (err != ZE_RESULT_SUCCESS) break;
|
||||
}
|
||||
if (err != ZE_RESULT_EXP_RTAS_BUILD_RETRY) break;
|
||||
if (err != ZE_RESULT_EXT_RTAS_BUILD_RETRY) break;
|
||||
}
|
||||
|
||||
if (err != ZE_RESULT_SUCCESS)
|
||||
throw_RTCError(RTC_ERROR_UNKNOWN,"build error");
|
||||
|
||||
/* destroy parallel operation */
|
||||
err = ZeWrapper::zeRTASParallelOperationDestroyExp(parallelOperation);
|
||||
err = ZeWrapper::zeRTASParallelOperationDestroyExt(parallelOperation);
|
||||
if (err != ZE_RESULT_SUCCESS)
|
||||
throw_RTCError(RTC_ERROR_UNKNOWN, "parallel operation destruction failed");
|
||||
|
||||
/* destroy rtas builder again */
|
||||
err = ZeWrapper::zeRTASBuilderDestroyExp(hBuilder);
|
||||
err = ZeWrapper::zeRTASBuilderDestroyExt(hBuilder);
|
||||
if (err != ZE_RESULT_SUCCESS)
|
||||
throw_RTCError(RTC_ERROR_UNKNOWN, "ze_rtas_builder destruction failed");
|
||||
|
||||
|
||||
@@ -17,7 +17,7 @@ namespace embree
|
||||
|
||||
void rthwifFreeAccelBuffer(Device* embree_device, void* ptr, size_t bytes, sycl::context context);
|
||||
|
||||
void* zeRTASInitExp(sycl::device device, sycl::context context);
|
||||
void* zeRTASInit(sycl::device device, sycl::context context);
|
||||
|
||||
void rthwifCleanup(Device* embree_device, void* dispatchGlobalsPtr, sycl::context context);
|
||||
|
||||
|
||||
@@ -26,10 +26,10 @@ namespace embree {
|
||||
{
|
||||
//std::cout << extensions[i].name << " version " << extensions[i].version << std::endl;
|
||||
|
||||
if (strncmp("ZE_extension_raytracing",extensions[i].name,sizeof(extensions[i].name)) == 0)
|
||||
if (strncmp(ZE_RAYTRACING_EXT_NAME ,extensions[i].name,sizeof(extensions[i].name)) == 0)
|
||||
has_raytracing = true;
|
||||
|
||||
if (has_raytracing && strncmp("ZE_experimental_rtas_builder",extensions[i].name,sizeof(extensions[i].name)) == 0) {
|
||||
if (has_raytracing && strncmp(ZE_RTAS_EXT_NAME, extensions[i].name,sizeof(extensions[i].name)) == 0) {
|
||||
ze_result_t result_rtas_builder = ZeWrapper::initRTASBuilder(hDriver);
|
||||
if (result_rtas_builder == ZE_RESULT_ERROR_DEPENDENCY_UNAVAILABLE) {
|
||||
return;
|
||||
|
||||
Reference in New Issue
Block a user