/** Please see header for specification */
Anvil::SwapchainUniquePtr Anvil::Swapchain::create(Anvil::SwapchainCreateInfoUniquePtr in_create_info_ptr)
{
SwapchainUniquePtr result_ptr(nullptr,
std::default_delete<Swapchain>() );
auto window_ptr(in_create_info_ptr->get_window() );
result_ptr.reset(
new Anvil::Swapchain(
std::move(in_create_info_ptr)
)
);
if (result_ptr)
{
if (!result_ptr->init() )
{
result_ptr.reset();
goto end;
}
if (window_ptr != nullptr &&
window_ptr->get_platform() == WINDOW_PLATFORM_DUMMY_WITH_PNG_SNAPSHOTS)
{
dynamic_cast<Anvil::DummyWindowWithPNGSnapshots*>(window_ptr)->set_swapchain(result_ptr.get() );
}
}
end:
return result_ptr;
}
/** Please see header for specification */
Anvil::DescriptorSetLayoutUniquePtr Anvil::DescriptorSetLayout::create(Anvil::DescriptorSetCreateInfoUniquePtr in_ds_create_info_ptr,
const Anvil::BaseDevice* in_device_ptr,
MTSafety in_mt_safety)
{
const bool mt_safe = Anvil::Utils::convert_mt_safety_enum_to_boolean(in_mt_safety,
in_device_ptr);
DescriptorSetLayoutUniquePtr result_ptr(nullptr,
std::default_delete<Anvil::DescriptorSetLayout>() );
result_ptr.reset(
new Anvil::DescriptorSetLayout(std::move(in_ds_create_info_ptr),
in_device_ptr,
mt_safe)
);
if (result_ptr != nullptr)
{
if (!result_ptr->init() )
{
result_ptr.reset();
}
}
return result_ptr;
}
Anvil::EventCreateInfoUniquePtr Anvil::EventCreateInfo::create(const Anvil::BaseDevice* in_device_ptr)
{
Anvil::EventCreateInfoUniquePtr result_ptr(nullptr,
std::default_delete<Anvil::EventCreateInfo>() );
result_ptr.reset(
new Anvil::EventCreateInfo(in_device_ptr,
Anvil::MTSafety::INHERIT_FROM_PARENT_DEVICE)
);
return result_ptr;
}
shared_ptr<IfcRotationalStiffnessSelect> IfcRotationalStiffnessSelect::createObjectFromStepData( const std::string& arg, const std::map<int,shared_ptr<IfcPPEntity> >& map )
{
// Read SELECT TYPE
if( arg.size() == 0 ){ return shared_ptr<IfcRotationalStiffnessSelect>(); }
if( arg[0] == '#' )
{
int id=atoi( arg.substr(1,arg.length()-1).c_str() );
std::map<int,shared_ptr<IfcPPEntity> >::const_iterator it_entity = map.find( id );
if( it_entity != map.end() )
{
shared_ptr<IfcRotationalStiffnessSelect> type_object = dynamic_pointer_cast<IfcRotationalStiffnessSelect>(it_entity->second);
return type_object;
}
else
{
std::stringstream strs;
strs << "Object width id " << id << " not found";
throw IfcPPException( strs.str() );
}
}
else if( arg.compare("$")==0 )
{
return shared_ptr<IfcRotationalStiffnessSelect>();
}
else if( arg.compare("*")==0 )
{
return shared_ptr<IfcRotationalStiffnessSelect>();
}
else
{
// inline arguments
std::string keyword;
std::string inline_arg;
tokenizeInlineArgument( arg, keyword, inline_arg );
shared_ptr<IfcPPObject> result_object( nullptr );
readInlineTypeOrEntity( keyword, inline_arg, result_object, map );
if( result_object )
{
shared_ptr<IfcPPObject> result_ptr( result_object );
shared_ptr<IfcRotationalStiffnessSelect> result_ptr_self = dynamic_pointer_cast<IfcRotationalStiffnessSelect>( result_ptr );
if( result_ptr_self )
{
return result_ptr_self;
}
}
std::stringstream strs;
strs << "unhandled inline argument: " << arg << " in function IfcRotationalStiffnessSelect::readStepData" << std::endl;
throw IfcPPException( strs.str() );
}
return shared_ptr<IfcRotationalStiffnessSelect>();
}
Anvil::FenceCreateInfoUniquePtr Anvil::FenceCreateInfo::create(const Anvil::BaseDevice* in_device_ptr,
bool in_create_signalled)
{
Anvil::FenceCreateInfoUniquePtr result_ptr(nullptr,
std::default_delete<Anvil::FenceCreateInfo>() );
result_ptr.reset(
new Anvil::FenceCreateInfo(in_device_ptr,
in_create_signalled,
Anvil::MT_SAFETY_INHERIT_FROM_PARENT_DEVICE)
);
return result_ptr;
}
/* Please see header for specification */
Anvil::PipelineLayoutManagerUniquePtr Anvil::PipelineLayoutManager::create(const Anvil::BaseDevice* in_device_ptr,
bool in_mt_safe)
{
PipelineLayoutManagerUniquePtr result_ptr(nullptr,
std::default_delete<PipelineLayoutManager>() );
result_ptr.reset(
new Anvil::PipelineLayoutManager(in_device_ptr,
in_mt_safe)
);
anvil_assert(result_ptr != nullptr);
return result_ptr;
}
Anvil::ImageCreateInfoUniquePtr Anvil::ImageCreateInfo::create_nonsparse_alloc(const Anvil::BaseDevice* in_device_ptr,
VkImageType in_type,
VkFormat in_format,
VkImageTiling in_tiling,
VkImageUsageFlags in_usage,
uint32_t in_base_mipmap_width,
uint32_t in_base_mipmap_height,
uint32_t in_base_mipmap_depth,
uint32_t in_n_layers,
VkSampleCountFlagBits in_sample_count,
Anvil::QueueFamilyBits in_queue_families,
VkSharingMode in_sharing_mode,
bool in_use_full_mipmap_chain,
MemoryFeatureFlags in_memory_features,
ImageCreateFlags in_create_flags,
VkImageLayout in_post_alloc_image_layout,
const std::vector<MipmapRawData>* in_opt_mipmaps_ptr)
{
Anvil::ImageCreateInfoUniquePtr result_ptr(nullptr,
std::default_delete<Anvil::ImageCreateInfo>() );
result_ptr.reset(
new ImageCreateInfo(Anvil::ImageType::NONSPARSE_ALLOC,
in_device_ptr,
in_type,
in_format,
in_tiling,
in_sharing_mode,
in_usage,
in_base_mipmap_width,
in_base_mipmap_height,
in_base_mipmap_depth,
in_n_layers,
in_sample_count,
in_use_full_mipmap_chain,
in_create_flags,
in_queue_families,
((in_opt_mipmaps_ptr != nullptr) && (in_opt_mipmaps_ptr->size() > 0)) ? VK_IMAGE_LAYOUT_PREINITIALIZED : VK_IMAGE_LAYOUT_UNDEFINED,
in_post_alloc_image_layout,
in_opt_mipmaps_ptr,
Anvil::MT_SAFETY_INHERIT_FROM_PARENT_DEVICE,
0, /* in_external_memory_handle_types */
in_memory_features,
Anvil::SPARSE_RESIDENCY_SCOPE_UNDEFINED)
);
return result_ptr;
}
/** Please see header for specification */
Anvil::PipelineCacheUniquePtr Anvil::PipelineCache::create(const Anvil::BaseDevice* in_device_ptr,
bool in_mt_safe,
size_t in_initial_data_size,
const void* in_initial_data)
{
PipelineCacheUniquePtr result_ptr(nullptr,
std::default_delete<PipelineCache>() );
result_ptr.reset(
new Anvil::PipelineCache(in_device_ptr,
in_mt_safe,
in_initial_data_size,
in_initial_data)
);
return result_ptr;
}
Anvil::ImageCreateInfoUniquePtr Anvil::ImageCreateInfo::create_sparse_no_alloc(const Anvil::BaseDevice* in_device_ptr,
VkImageType in_type,
VkFormat in_format,
VkImageTiling in_tiling,
VkImageUsageFlags in_usage,
uint32_t in_base_mipmap_width,
uint32_t in_base_mipmap_height,
uint32_t in_base_mipmap_depth,
uint32_t in_n_layers,
VkSampleCountFlagBits in_sample_count,
Anvil::QueueFamilyBits in_queue_families,
VkSharingMode in_sharing_mode,
bool in_use_full_mipmap_chain,
ImageCreateFlags in_create_flags,
Anvil::SparseResidencyScope in_residency_scope)
{
Anvil::ImageCreateInfoUniquePtr result_ptr(nullptr,
std::default_delete<Anvil::ImageCreateInfo>() );
result_ptr.reset(
new ImageCreateInfo(Anvil::ImageType::SPARSE_NO_ALLOC,
in_device_ptr,
in_type,
in_format,
in_tiling,
in_sharing_mode,
in_usage,
in_base_mipmap_width,
in_base_mipmap_height,
in_base_mipmap_depth,
in_n_layers,
in_sample_count,
in_use_full_mipmap_chain,
in_create_flags,
in_queue_families,
VK_IMAGE_LAYOUT_UNDEFINED,
VK_IMAGE_LAYOUT_UNDEFINED,
nullptr, /* in_opt_mipmaps_ptr */
Anvil::MT_SAFETY_INHERIT_FROM_PARENT_DEVICE,
0, /* in_external_memory_handle_types */
0, /* in_memory_features */
in_residency_scope)
);
return result_ptr;
}
/* Please see header for specification */
Anvil::EventUniquePtr Anvil::Event::create(Anvil::EventCreateInfoUniquePtr in_create_info_ptr)
{
Anvil::EventUniquePtr result_ptr(nullptr,
std::default_delete<Anvil::Event>() );
result_ptr.reset(
new Anvil::Event(std::move(in_create_info_ptr) )
);
if (result_ptr != nullptr)
{
if (!result_ptr->init() )
{
result_ptr.reset();
}
}
return result_ptr;
}
bool c_ip46_addr::is_ipv4(const string &ipstr) {
as_zerofill< addrinfo > hint;
struct addrinfo *result = nullptr;
hint.ai_family = PF_UNSPEC;
hint.ai_flags = AI_NUMERICHOST;
int ret = getaddrinfo(ipstr.c_str(), nullptr, &hint, &result);
if (ret) {
_throw_error( std::invalid_argument("unknown address format") );
}
auto result_deleter = [&](struct addrinfo *result){freeaddrinfo(result);};
std::unique_ptr<struct addrinfo, decltype(result_deleter)> result_ptr(result, result_deleter);
if(result_ptr->ai_family == AF_INET) {
return true;
}
else if (result_ptr->ai_family == AF_INET6) {
return false;
}
_assert(false);
}
Anvil::ImageCreateInfoUniquePtr Anvil::ImageCreateInfo::create_swapchain_wrapper(const Anvil::BaseDevice* in_device_ptr,
const Anvil::Swapchain* in_swapchain_ptr,
const VkImage& in_image,
const uint32_t& in_n_swapchain_image)
{
Anvil::ImageCreateInfoUniquePtr result_ptr (nullptr,
std::default_delete<Anvil::ImageCreateInfo>() );
const auto& swapchain_create_info_ptr(in_swapchain_ptr->get_create_info_ptr() );
result_ptr.reset(
new Anvil::ImageCreateInfo(Anvil::ImageType::SWAPCHAIN_WRAPPER,
in_device_ptr,
VK_IMAGE_TYPE_2D,
swapchain_create_info_ptr->get_format(),
VK_IMAGE_TILING_OPTIMAL,
VK_SHARING_MODE_EXCLUSIVE,
swapchain_create_info_ptr->get_usage_flags(),
swapchain_create_info_ptr->get_rendering_surface()->get_width (),
swapchain_create_info_ptr->get_rendering_surface()->get_height(),
1, /* base_mipmap_depth */
1, /* in_n_layers */
VK_SAMPLE_COUNT_1_BIT,
false, /* in_use_full_mipmap_chain */
0, /* in_create_flags */
0, /* in_queue_families */
VK_IMAGE_LAYOUT_UNDEFINED,
VK_IMAGE_LAYOUT_UNDEFINED,
nullptr, /* in_opt_mipmaps_ptr */
Anvil::MT_SAFETY_INHERIT_FROM_PARENT_DEVICE,
0, /* in_external_memory_handle_types */
0, /* in_memory_features */
Anvil::SPARSE_RESIDENCY_SCOPE_UNDEFINED)
);
if (result_ptr != nullptr)
{
result_ptr->m_swapchain_image = in_image;
result_ptr->m_n_swapchain_image = in_n_swapchain_image;
result_ptr->m_swapchain_ptr = in_swapchain_ptr;
}
return result_ptr;
}
/** Please see header for specification */
Anvil::SemaphoreUniquePtr Anvil::Semaphore::create(Anvil::SemaphoreCreateInfoUniquePtr in_create_info_ptr)
{
SemaphoreUniquePtr result_ptr(nullptr,
std::default_delete<Semaphore>() );
result_ptr.reset(
new Anvil::Semaphore(std::move(in_create_info_ptr) )
);
if (result_ptr != nullptr)
{
if (!result_ptr->reset() )
{
result_ptr.reset();
}
}
return result_ptr;
}
/* Please see header for specification */
Anvil::RenderingSurfaceUniquePtr Anvil::RenderingSurface::create(Anvil::RenderingSurfaceCreateInfoUniquePtr in_create_info_ptr)
{
RenderingSurfaceUniquePtr result_ptr(nullptr,
std::default_delete<RenderingSurface>() );
result_ptr.reset(
new Anvil::RenderingSurface(
std::move(in_create_info_ptr)
)
);
if (result_ptr != nullptr)
{
if (!result_ptr->init() )
{
result_ptr.reset();
}
}
return result_ptr;
}
/* Please see header for specification */
Anvil::RenderPassUniquePtr Anvil::RenderPass::create(Anvil::RenderPassCreateInfoUniquePtr in_renderpass_create_info_ptr,
Anvil::Swapchain* in_opt_swapchain_ptr)
{
std::unique_ptr<RenderPass> result_ptr(nullptr,
std::default_delete<RenderPass>() );
result_ptr.reset(
new Anvil::RenderPass(std::move(in_renderpass_create_info_ptr),
in_opt_swapchain_ptr)
);
if (result_ptr != nullptr)
{
if (!result_ptr->init() )
{
result_ptr.reset();
}
}
return std::move(result_ptr);
}
/* Please see header for specification */
Anvil::GLSLShaderToSPIRVGeneratorUniquePtr Anvil::GLSLShaderToSPIRVGenerator::create(const Anvil::BaseDevice* in_opt_device_ptr,
const Mode& in_mode,
std::string in_data,
ShaderStage in_shader_stage,
SpvVersion in_spirv_version)
{
Anvil::GLSLShaderToSPIRVGeneratorUniquePtr result_ptr(nullptr,
std::default_delete<Anvil::GLSLShaderToSPIRVGenerator>() );
result_ptr.reset(
new Anvil::GLSLShaderToSPIRVGenerator(in_opt_device_ptr,
in_mode,
in_data,
in_shader_stage,
in_spirv_version)
);
Anvil::ObjectTracker::get()->register_object(Anvil::ObjectType::ANVIL_GLSL_SHADER_TO_SPIRV_GENERATOR,
result_ptr.get() );
return result_ptr;
}
