Method prepare

samples/performance/async_compute/async_compute.cpp:227–321

}

bool AsyncComputeSample::prepare(const vkb::ApplicationOptions &options)
{
	// Set setup_queues() for details.
	set_high_priority_graphics_queue_enable(true);

	if (!VulkanSample::prepare(options))
	{
		return false;
	}

	load_scene("scenes/bonza/Bonza.gltf");

	auto &camera_node = vkb::add_free_camera(get_scene(), "main_camera", get_render_context().get_surface_extent());
	camera            = &camera_node.get_component<vkb::sg::Camera>();

	// Attach a shadow camera to the directional light.
	auto lights = get_scene().get_components<vkb::sg::Light>();
	for (auto &light : lights)
	{
		if (light->get_light_type() == vkb::sg::LightType::Directional)
		{
			vkb::sg::LightProperties props{};
			props.color = glm::vec3(50.0f, 40.0f, 30.0f);
			light->set_properties(props);
			auto *node = light->get_node();

			// Hardcoded to fit to the scene.
			auto ortho_camera = std::make_unique<vkb::sg::OrthographicCamera>("shadow_camera",
			                                                                  -2000.0f, 3000.0f,
			                                                                  -2500.0f, 1500.0f,
			                                                                  -2000.0f, 2000.0f);

			ortho_camera->set_node(*node);
			get_scene().add_component(std::move(ortho_camera), *node);
			shadow_camera = &node->get_component<vkb::sg::Camera>();
			break;
		}
	}

	prepare_render_targets();

	vkb::ShaderSource vert_shader("async_compute/forward.vert.spv");
	vkb::ShaderSource frag_shader("async_compute/forward.frag.spv");
	auto              scene_subpass =
	    std::make_unique<ShadowMapForwardSubpass>(get_render_context(), std::move(vert_shader), std::move(frag_shader), get_scene(), *camera, *shadow_camera);

	vkb::ShaderSource shadow_vert_shader("async_compute/shadow.vert.spv");
	vkb::ShaderSource shadow_frag_shader("async_compute/shadow.frag.spv");
	auto              shadow_scene_subpass =
	    std::make_unique<DepthMapSubpass>(get_render_context(), std::move(shadow_vert_shader), std::move(shadow_frag_shader), get_scene(), *shadow_camera);
	shadow_render_pipeline.add_subpass(std::move(shadow_scene_subpass));
	shadow_render_pipeline.set_load_store({{VK_ATTACHMENT_LOAD_OP_CLEAR, VK_ATTACHMENT_STORE_OP_STORE}});

	vkb::ShaderSource composite_vert_shader("async_compute/composite.vert.spv");
	vkb::ShaderSource composite_frag_shader("async_compute/composite.frag.spv");
	auto              composite_scene_subpass =
	    std::make_unique<CompositeSubpass>(get_render_context(), std::move(composite_vert_shader), std::move(composite_frag_shader));