Merge changes I97efd6c9,I6460f8f0,Ic67e4290,I16214514,Ieaa4e463, ... into nyc-dev (094848e9) · Commits · e / os / android_frameworks_native-old

vulkan/libvulkan/layers_extensions.cpp

+252 −198

Original line number	Original line	Diff line number	Diff line
	@@ -43,75 +43,118 @@
	// probably want to intern strings, etc., and will need some custom/manual data		// probably want to intern strings, etc., and will need some custom/manual data
	// structures.		// structures.

	// TODO(jessehall): Currently we have separate lists for instance and device
	// layers. Most layers are both; we should use one entry for each layer name,
	// with a mask saying what kind(s) it is.

	namespace vulkan {		namespace vulkan {
	namespace api {		namespace api {

	struct Layer {		struct Layer {
	VkLayerProperties properties;		VkLayerProperties properties;
	size_t library_idx;		size_t library_idx;
	std::vector<VkExtensionProperties> extensions;
			bool is_global;

			std::vector<VkExtensionProperties> instance_extensions;
			std::vector<VkExtensionProperties> device_extensions;
	};		};

	namespace {		namespace {

	std::mutex g_library_mutex;		class LayerLibrary {
	struct LayerLibrary {		public:
	std::string path;		LayerLibrary(const std::string& path)
	void* dlhandle;		: path_(path), dlhandle_(nullptr), refcount_(0) {}
	size_t refcount;
			LayerLibrary(LayerLibrary&& other)
			: path_(std::move(other.path_)),
			dlhandle_(other.dlhandle_),
			refcount_(other.refcount_) {
			other.dlhandle_ = nullptr;
			other.refcount_ = 0;
			}

			LayerLibrary(const LayerLibrary&) = delete;
			LayerLibrary& operator=(const LayerLibrary&) = delete;

			// these are thread-safe
			bool Open();
			void Close();

			bool EnumerateLayers(size_t library_idx,
			std::vector<Layer>& instance_layers) const;

			void* GetGPA(const Layer& layer,
			const char* gpa_name,
			size_t gpa_name_len) const;

			private:
			const std::string path_;

			std::mutex mutex_;
			void* dlhandle_;
			size_t refcount_;
	};		};
	std::vector<LayerLibrary> g_layer_libraries;
	std::vector<Layer> g_instance_layers;
	std::vector<Layer> g_device_layers;

	void AddLayerLibrary(const std::string& path) {		bool LayerLibrary::Open() {
	ALOGV("examining layer library '%s'", path.c_str());		std::lock_guard<std::mutex> lock(mutex_);

	void* dlhandle = dlopen(path.c_str(), RTLD_NOW \| RTLD_LOCAL);		if (refcount_++ == 0) {
	if (!dlhandle) {		dlhandle_ = dlopen(path_.c_str(), RTLD_NOW \| RTLD_LOCAL);
	ALOGW("failed to load layer library '%s': %s", path.c_str(), dlerror());		ALOGV("Opening library %s", path_.c_str());
	return;		if (!dlhandle_) {
			ALOGE("failed to load layer library '%s': %s", path_.c_str(),
			dlerror());
			refcount_ = 0;
			return false;
			}
			}
			ALOGV("Refcount on activate is %zu", refcount_);
			return true;
			}

			void LayerLibrary::Close() {
			std::lock_guard<std::mutex> lock(mutex_);

			if (--refcount_ == 0) {
			ALOGV("Closing library %s", path_.c_str());
			dlclose(dlhandle_);
			dlhandle_ = nullptr;
			}
			ALOGV("Refcount on destruction is %zu", refcount_);
	}		}

			bool LayerLibrary::EnumerateLayers(size_t library_idx,
			std::vector<Layer>& instance_layers) const {
	PFN_vkEnumerateInstanceLayerProperties enumerate_instance_layers =		PFN_vkEnumerateInstanceLayerProperties enumerate_instance_layers =
	reinterpret_cast<PFN_vkEnumerateInstanceLayerProperties>(		reinterpret_cast<PFN_vkEnumerateInstanceLayerProperties>(
	dlsym(dlhandle, "vkEnumerateInstanceLayerProperties"));		dlsym(dlhandle_, "vkEnumerateInstanceLayerProperties"));
	PFN_vkEnumerateInstanceExtensionProperties enumerate_instance_extensions =		PFN_vkEnumerateInstanceExtensionProperties enumerate_instance_extensions =
	reinterpret_cast<PFN_vkEnumerateInstanceExtensionProperties>(		reinterpret_cast<PFN_vkEnumerateInstanceExtensionProperties>(
	dlsym(dlhandle, "vkEnumerateInstanceExtensionProperties"));		dlsym(dlhandle_, "vkEnumerateInstanceExtensionProperties"));
			if (!enumerate_instance_layers \|\| !enumerate_instance_extensions) {
			ALOGV("layer library '%s' misses some instance enumeraion functions",
			path_.c_str());
			return false;
			}

			// device functions are optional
	PFN_vkEnumerateDeviceLayerProperties enumerate_device_layers =		PFN_vkEnumerateDeviceLayerProperties enumerate_device_layers =
	reinterpret_cast<PFN_vkEnumerateDeviceLayerProperties>(		reinterpret_cast<PFN_vkEnumerateDeviceLayerProperties>(
	dlsym(dlhandle, "vkEnumerateDeviceLayerProperties"));		dlsym(dlhandle_, "vkEnumerateDeviceLayerProperties"));
	PFN_vkEnumerateDeviceExtensionProperties enumerate_device_extensions =		PFN_vkEnumerateDeviceExtensionProperties enumerate_device_extensions =
	reinterpret_cast<PFN_vkEnumerateDeviceExtensionProperties>(		reinterpret_cast<PFN_vkEnumerateDeviceExtensionProperties>(
	dlsym(dlhandle, "vkEnumerateDeviceExtensionProperties"));		dlsym(dlhandle_, "vkEnumerateDeviceExtensionProperties"));
	if (!((enumerate_instance_layers && enumerate_instance_extensions) \|\|
	(enumerate_device_layers && enumerate_device_extensions))) {
	ALOGV(
	"layer library '%s' has neither instance nor device enumeraion "
	"functions",
	path.c_str());
	dlclose(dlhandle);
	return;
	}

	VkResult result;		// get layer counts
	uint32_t num_instance_layers = 0;		uint32_t num_instance_layers = 0;
	uint32_t num_device_layers = 0;		uint32_t num_device_layers = 0;
	if (enumerate_instance_layers) {		VkResult result = enumerate_instance_layers(&num_instance_layers, nullptr);
	result = enumerate_instance_layers(&num_instance_layers, nullptr);		if (result != VK_SUCCESS \|\| !num_instance_layers) {
	if (result != VK_SUCCESS) {		if (result != VK_SUCCESS) {
	ALOGW(		ALOGW(
	"vkEnumerateInstanceLayerProperties failed for library '%s': "		"vkEnumerateInstanceLayerProperties failed for library '%s': "
	"%d",		"%d",
	path.c_str(), result);		path_.c_str(), result);
	dlclose(dlhandle);
	return;
	}		}
			return false;
	}		}
	if (enumerate_device_layers) {		if (enumerate_device_layers) {
	result = enumerate_device_layers(VK_NULL_HANDLE, &num_device_layers,		result = enumerate_device_layers(VK_NULL_HANDLE, &num_device_layers,
	@@ -119,23 +162,19 @@ void AddLayerLibrary(const std::string& path) {
	if (result != VK_SUCCESS) {		if (result != VK_SUCCESS) {
	ALOGW(		ALOGW(
	"vkEnumerateDeviceLayerProperties failed for library '%s': %d",		"vkEnumerateDeviceLayerProperties failed for library '%s': %d",
	path.c_str(), result);		path_.c_str(), result);
	dlclose(dlhandle);		return false;
	return;
	}		}
	}		}

			// get layer properties
	VkLayerProperties* properties = static_cast<VkLayerProperties*>(alloca(		VkLayerProperties* properties = static_cast<VkLayerProperties*>(alloca(
	(num_instance_layers + num_device_layers) * sizeof(VkLayerProperties)));		(num_instance_layers + num_device_layers) * sizeof(VkLayerProperties)));
	if (num_instance_layers > 0) {
	result = enumerate_instance_layers(&num_instance_layers, properties);		result = enumerate_instance_layers(&num_instance_layers, properties);
	if (result != VK_SUCCESS) {		if (result != VK_SUCCESS) {
	ALOGW(		ALOGW("vkEnumerateInstanceLayerProperties failed for library '%s': %d",
	"vkEnumerateInstanceLayerProperties failed for library '%s': "		path_.c_str(), result);
	"%d",		return false;
	path.c_str(), result);
	dlclose(dlhandle);
	return;
	}
	}		}
	if (num_device_layers > 0) {		if (num_device_layers > 0) {
	result = enumerate_device_layers(VK_NULL_HANDLE, &num_device_layers,		result = enumerate_device_layers(VK_NULL_HANDLE, &num_device_layers,
	@@ -143,102 +182,121 @@ void AddLayerLibrary(const std::string& path) {
	if (result != VK_SUCCESS) {		if (result != VK_SUCCESS) {
	ALOGW(		ALOGW(
	"vkEnumerateDeviceLayerProperties failed for library '%s': %d",		"vkEnumerateDeviceLayerProperties failed for library '%s': %d",
	path.c_str(), result);		path_.c_str(), result);
	dlclose(dlhandle);		return false;
	return;
	}		}
	}		}

	size_t library_idx = g_layer_libraries.size();		// append layers to instance_layers
	size_t prev_num_instance_layers = g_instance_layers.size();		size_t prev_num_instance_layers = instance_layers.size();
	size_t prev_num_device_layers = g_device_layers.size();		instance_layers.reserve(prev_num_instance_layers + num_instance_layers);
	g_instance_layers.reserve(prev_num_instance_layers + num_instance_layers);
	g_device_layers.reserve(prev_num_device_layers + num_device_layers);
	for (size_t i = 0; i < num_instance_layers; i++) {		for (size_t i = 0; i < num_instance_layers; i++) {
	const VkLayerProperties& props = properties[i];		const VkLayerProperties& props = properties[i];

	Layer layer;		Layer layer;
	layer.properties = props;		layer.properties = props;
	layer.library_idx = library_idx;		layer.library_idx = library_idx;
			layer.is_global = false;

	if (enumerate_instance_extensions) {
	uint32_t count = 0;		uint32_t count = 0;
	result =		result =
	enumerate_instance_extensions(props.layerName, &count, nullptr);		enumerate_instance_extensions(props.layerName, &count, nullptr);
	if (result != VK_SUCCESS) {		if (result != VK_SUCCESS) {
	ALOGW(		ALOGW(
	"vkEnumerateInstanceExtensionProperties(%s) failed for "		"vkEnumerateInstanceExtensionProperties(%s) failed for library "
	"library "
	"'%s': %d",		"'%s': %d",
	props.layerName, path.c_str(), result);		props.layerName, path_.c_str(), result);
	g_instance_layers.resize(prev_num_instance_layers);		instance_layers.resize(prev_num_instance_layers);
	dlclose(dlhandle);		return false;
	return;
	}		}
	layer.extensions.resize(count);		layer.instance_extensions.resize(count);
	result = enumerate_instance_extensions(props.layerName, &count,		result = enumerate_instance_extensions(
	layer.extensions.data());		props.layerName, &count, layer.instance_extensions.data());
	if (result != VK_SUCCESS) {		if (result != VK_SUCCESS) {
	ALOGW(		ALOGW(
	"vkEnumerateInstanceExtensionProperties(%s) failed for "		"vkEnumerateInstanceExtensionProperties(%s) failed for library "
	"library "
	"'%s': %d",		"'%s': %d",
	props.layerName, path.c_str(), result);		props.layerName, path_.c_str(), result);
	g_instance_layers.resize(prev_num_instance_layers);		instance_layers.resize(prev_num_instance_layers);
	dlclose(dlhandle);		return false;
	return;
	}
	}		}

	g_instance_layers.push_back(layer);		for (size_t j = 0; j < num_device_layers; j++) {
	ALOGV(" added instance layer '%s'", props.layerName);		const auto& dev_props = properties[num_instance_layers + j];
			if (memcmp(&props, &dev_props, sizeof(props)) == 0) {
			layer.is_global = true;
			break;
			}
	}		}
	for (size_t i = 0; i < num_device_layers; i++) {
	const VkLayerProperties& props = properties[num_instance_layers + i];

	Layer layer;
	layer.properties = props;
	layer.library_idx = library_idx;

	if (enumerate_device_extensions) {		if (layer.is_global && enumerate_device_extensions) {
	uint32_t count;
	result = enumerate_device_extensions(		result = enumerate_device_extensions(
	VK_NULL_HANDLE, props.layerName, &count, nullptr);		VK_NULL_HANDLE, props.layerName, &count, nullptr);
	if (result != VK_SUCCESS) {		if (result != VK_SUCCESS) {
	ALOGW(		ALOGW(
	"vkEnumerateDeviceExtensionProperties(%s) failed for "		"vkEnumerateDeviceExtensionProperties(%s) failed for "
	"library "		"library '%s': %d",
	"'%s': %d",		props.layerName, path_.c_str(), result);
	props.layerName, path.c_str(), result);		instance_layers.resize(prev_num_instance_layers);
	g_instance_layers.resize(prev_num_instance_layers);		return false;
	g_device_layers.resize(prev_num_device_layers);
	dlclose(dlhandle);
	return;
	}		}
	layer.extensions.resize(count);		layer.device_extensions.resize(count);
	result =		result = enumerate_device_extensions(
	enumerate_device_extensions(VK_NULL_HANDLE, props.layerName,		VK_NULL_HANDLE, props.layerName, &count,
	&count, layer.extensions.data());		layer.device_extensions.data());
	if (result != VK_SUCCESS) {		if (result != VK_SUCCESS) {
	ALOGW(		ALOGW(
	"vkEnumerateDeviceExtensionProperties(%s) failed for "		"vkEnumerateDeviceExtensionProperties(%s) failed for "
	"library "		"library '%s': %d",
	"'%s': %d",		props.layerName, path_.c_str(), result);
	props.layerName, path.c_str(), result);		instance_layers.resize(prev_num_instance_layers);
	g_instance_layers.resize(prev_num_instance_layers);		return false;
	g_device_layers.resize(prev_num_device_layers);
	dlclose(dlhandle);
	return;
	}		}
	}		}

	g_device_layers.push_back(layer);		instance_layers.push_back(layer);
	ALOGV(" added device layer '%s'", props.layerName);		ALOGV(" added %s layer '%s'",
			(layer.is_global) ? "global" : "instance", props.layerName);
	}		}

	dlclose(dlhandle);		return true;
			}

	g_layer_libraries.push_back(LayerLibrary{path, nullptr, 0});		void* LayerLibrary::GetGPA(const Layer& layer,
			const char* gpa_name,
			size_t gpa_name_len) const {
			void* gpa;
			size_t layer_name_len =
			std::max(size_t{2}, strlen(layer.properties.layerName));
			char* name = static_cast<char*>(alloca(layer_name_len + gpa_name_len + 1));
			strcpy(name, layer.properties.layerName);
			strcpy(name + layer_name_len, gpa_name);
			if (!(gpa = dlsym(dlhandle_, name))) {
			strcpy(name, "vk");
			strcpy(name + 2, gpa_name);
			gpa = dlsym(dlhandle_, name);
			}
			return gpa;
			}

			std::vector<LayerLibrary> g_layer_libraries;
			std::vector<Layer> g_instance_layers;

			void AddLayerLibrary(const std::string& path) {
			ALOGV("examining layer library '%s'", path.c_str());

			LayerLibrary library(path);
			if (!library.Open())
			return;

			if (!library.EnumerateLayers(g_layer_libraries.size(), g_instance_layers)) {
			library.Close();
			return;
			}

			library.Close();

			g_layer_libraries.emplace_back(std::move(library));
	}		}

	void DiscoverLayersInDirectory(const std::string& dir_path) {		void DiscoverLayersInDirectory(const std::string& dir_path) {
	@@ -271,71 +329,25 @@ void DiscoverLayersInDirectory(const std::string& dir_path) {
	closedir(directory);		closedir(directory);
	}		}

	void* GetLayerGetProcAddr(const Layer& layer,		const Layer* FindInstanceLayer(const char* name) {
	const char* gpa_name,
	size_t gpa_name_len) {
	const LayerLibrary& library = g_layer_libraries[layer.library_idx];
	void* gpa;
	size_t layer_name_len = std::max(size_t{2}, strlen(layer.properties.layerName));
	char* name = static_cast<char*>(alloca(layer_name_len + gpa_name_len + 1));
	strcpy(name, layer.properties.layerName);
	strcpy(name + layer_name_len, gpa_name);
	if (!(gpa = dlsym(library.dlhandle, name))) {
	strcpy(name, "vk");
	strcpy(name + 2, gpa_name);
	gpa = dlsym(library.dlhandle, name);
	}
	return gpa;
	}

	uint32_t EnumerateLayers(const std::vector<Layer>& layers,
	uint32_t count,
	VkLayerProperties* properties) {
	uint32_t n = std::min(count, static_cast<uint32_t>(layers.size()));
	for (uint32_t i = 0; i < n; i++) {
	properties[i] = layers[i].properties;
	}
	return static_cast<uint32_t>(layers.size());
	}

	void GetLayerExtensions(const std::vector<Layer>& layers,
	const char* name,
	const VkExtensionProperties** properties,
	uint32_t* count) {
	auto layer =		auto layer =
	std::find_if(layers.cbegin(), layers.cend(), [=](const Layer& entry) {		std::find_if(g_instance_layers.cbegin(), g_instance_layers.cend(),
			[=](const Layer& entry) {
	return strcmp(entry.properties.layerName, name) == 0;		return strcmp(entry.properties.layerName, name) == 0;
	});		});
	if (layer == layers.cend()) {		return (layer != g_instance_layers.cend()) ? &*layer : nullptr;
	*properties = nullptr;
	*count = 0;
	} else {
	*properties = layer->extensions.data();
	*count = static_cast<uint32_t>(layer->extensions.size());
	}
	}		}

	LayerRef GetLayerRef(std::vector<Layer>& layers, const char* name) {		const Layer* FindDeviceLayer(const char* name) {
	for (uint32_t id = 0; id < layers.size(); id++) {		const Layer* layer = FindInstanceLayer(name);
	if (strcmp(name, layers[id].properties.layerName) == 0) {		return (layer && layer->is_global) ? layer : nullptr;
	LayerLibrary& library = g_layer_libraries[layers[id].library_idx];
	std::lock_guard<std::mutex> lock(g_library_mutex);
	if (library.refcount++ == 0) {
	library.dlhandle =
	dlopen(library.path.c_str(), RTLD_NOW \| RTLD_LOCAL);
	ALOGV("Opening library %s", library.path.c_str());
	if (!library.dlhandle) {
	ALOGE("failed to load layer library '%s': %s",
	library.path.c_str(), dlerror());
	library.refcount = 0;
	return LayerRef(nullptr);
	}
	}
	ALOGV("Refcount on activate is %zu", library.refcount);
	return LayerRef(&layers[id]);
	}
	}		}
	return LayerRef(nullptr);
			void* GetLayerGetProcAddr(const Layer& layer,
			const char* gpa_name,
			size_t gpa_name_len) {
			const LayerLibrary& library = g_layer_libraries[layer.library_idx];
			return library.GetGPA(layer, gpa_name, gpa_name_len);
	}		}

	} // anonymous namespace		} // anonymous namespace
	@@ -349,45 +361,84 @@ void DiscoverLayers() {

	uint32_t EnumerateInstanceLayers(uint32_t count,		uint32_t EnumerateInstanceLayers(uint32_t count,
	VkLayerProperties* properties) {		VkLayerProperties* properties) {
	return EnumerateLayers(g_instance_layers, count, properties);		uint32_t n =
			std::min(count, static_cast<uint32_t>(g_instance_layers.size()));
			for (uint32_t i = 0; i < n; i++)
			properties[i] = g_instance_layers[i].properties;

			return static_cast<uint32_t>(g_instance_layers.size());
	}		}

	uint32_t EnumerateDeviceLayers(uint32_t count, VkLayerProperties* properties) {		uint32_t EnumerateDeviceLayers(uint32_t count, VkLayerProperties* properties) {
	return EnumerateLayers(g_device_layers, count, properties);		uint32_t n = 0;
			for (const auto& layer : g_instance_layers) {
			// ignore non-global layers
			if (!layer.is_global)
			continue;

			if (n < count)
			properties[n] = layer.properties;
			n++;
			}

			return n;
	}		}

	void GetInstanceLayerExtensions(const char* name,		void GetInstanceLayerExtensions(const char* name,
	const VkExtensionProperties** properties,		const VkExtensionProperties** properties,
	uint32_t* count) {		uint32_t* count) {
	GetLayerExtensions(g_instance_layers, name, properties, count);		const Layer* layer = FindInstanceLayer(name);
			if (layer) {
			*properties = layer->instance_extensions.data();
			*count = static_cast<uint32_t>(layer->instance_extensions.size());
			} else {
			*properties = nullptr;
			*count = 0;
			}
	}		}

	void GetDeviceLayerExtensions(const char* name,		void GetDeviceLayerExtensions(const char* name,
	const VkExtensionProperties** properties,		const VkExtensionProperties** properties,
	uint32_t* count) {		uint32_t* count) {
	GetLayerExtensions(g_device_layers, name, properties, count);		const Layer* layer = FindDeviceLayer(name);
			if (layer) {
			*properties = layer->device_extensions.data();
			*count = static_cast<uint32_t>(layer->device_extensions.size());
			} else {
			*properties = nullptr;
			*count = 0;
			}
	}		}

	LayerRef GetInstanceLayerRef(const char* name) {		LayerRef GetInstanceLayerRef(const char* name) {
	return GetLayerRef(g_instance_layers, name);		const Layer* layer = FindInstanceLayer(name);
			if (layer) {
			LayerLibrary& library = g_layer_libraries[layer->library_idx];
			if (!library.Open())
			layer = nullptr;
			}

			return LayerRef(layer, true);
	}		}

	LayerRef GetDeviceLayerRef(const char* name) {		LayerRef GetDeviceLayerRef(const char* name) {
	return GetLayerRef(g_device_layers, name);		const Layer* layer = FindDeviceLayer(name);
			if (layer) {
			LayerLibrary& library = g_layer_libraries[layer->library_idx];
			if (!library.Open())
			layer = nullptr;
	}		}

	LayerRef::LayerRef(Layer* layer) : layer_(layer) {}		return LayerRef(layer, false);
			}

			LayerRef::LayerRef(const Layer* layer, bool is_instance)
			: layer_(layer), is_instance_(is_instance) {}

	LayerRef::~LayerRef() {		LayerRef::~LayerRef() {
	if (layer_) {		if (layer_) {
	LayerLibrary& library = g_layer_libraries[layer_->library_idx];		LayerLibrary& library = g_layer_libraries[layer_->library_idx];
	std::lock_guard<std::mutex> lock(g_library_mutex);		library.Close();
	if (--library.refcount == 0) {
	ALOGV("Closing library %s", library.path.c_str());
	dlclose(library.dlhandle);
	library.dlhandle = nullptr;
	}
	ALOGV("Refcount on destruction is %zu", library.refcount);
	}		}
	}		}

	@@ -395,11 +446,12 @@ const char* LayerRef::GetName() const {
	return layer_->properties.layerName;		return layer_->properties.layerName;
	}		}

	uint32_t LayerRef::GetSpecVersion() {		uint32_t LayerRef::GetSpecVersion() const {
	return layer_->properties.specVersion;		return layer_->properties.specVersion;
	}		}

	LayerRef::LayerRef(LayerRef&& other) : layer_(std::move(other.layer_)) {		LayerRef::LayerRef(LayerRef&& other)
			: layer_(other.layer_), is_instance_(other.is_instance_) {
	other.layer_ = nullptr;		other.layer_ = nullptr;
	}		}

	@@ -416,10 +468,12 @@ PFN_vkGetDeviceProcAddr LayerRef::GetGetDeviceProcAddr() const {
	}		}

	bool LayerRef::SupportsExtension(const char* name) const {		bool LayerRef::SupportsExtension(const char* name) const {
	return std::find_if(layer_->extensions.cbegin(), layer_->extensions.cend(),		const auto& extensions = (is_instance_) ? layer_->instance_extensions
			: layer_->device_extensions;
			return std::find_if(extensions.cbegin(), extensions.cend(),
	[=](const VkExtensionProperties& ext) {		[=](const VkExtensionProperties& ext) {
	return strcmp(ext.extensionName, name) == 0;		return strcmp(ext.extensionName, name) == 0;
	}) != layer_->extensions.cend();		}) != extensions.cend();
	}		}

	} // namespace api		} // namespace api

vulkan/libvulkan/layers_extensions.h

+4 −3

Original line number	Original line	Diff line number	Diff line
	@@ -25,14 +25,14 @@ namespace api {
	struct Layer;		struct Layer;
	class LayerRef {		class LayerRef {
	public:		public:
	LayerRef(Layer* layer);		LayerRef(const Layer* layer, bool is_instance);
	LayerRef(LayerRef&& other);		LayerRef(LayerRef&& other);
	~LayerRef();		~LayerRef();
	LayerRef(const LayerRef&) = delete;		LayerRef(const LayerRef&) = delete;
	LayerRef& operator=(const LayerRef&) = delete;		LayerRef& operator=(const LayerRef&) = delete;

	const char* GetName() const;		const char* GetName() const;
	uint32_t GetSpecVersion();		uint32_t GetSpecVersion() const;

	// provides bool-like behavior		// provides bool-like behavior
	operator const Layer*() const { return layer_; }		operator const Layer*() const { return layer_; }
	@@ -43,7 +43,8 @@ class LayerRef {
	bool SupportsExtension(const char* name) const;		bool SupportsExtension(const char* name) const;

	private:		private:
	Layer* layer_;		const Layer* layer_;
			bool is_instance_;
	};		};

	void DiscoverLayers();		void DiscoverLayers();