Beispiel #1
0
def create_device():
    global physical_device, render_queue_family, device

    # Device selection (use the first available)
    physical_devices = hvk.list_physical_devices(api, instance)
    physical_device = physical_devices[0]

    # Queues setup (A single graphic queue)
    queue_families = hvk.list_queue_families(api, physical_device)
    render_queue_family = next(qf for qf in queue_families if IntFlag(
        vk.QUEUE_GRAPHICS_BIT) in IntFlag(qf.properties.queue_flags))
    render_queue_create_info = hvk.queue_create_info(
        queue_family_index=render_queue_family.index, queue_count=1)

    # Device creation
    extensions = ("VK_KHR_swapchain", )
    device = hvk.create_device(api, physical_device, extensions,
                               (render_queue_create_info, ))
Beispiel #2
0
    def _setup_device(self):
        api, instance = self.api, self.instance
        conf = self.configuration
        queues_conf = conf.get("QUEUES", DEFAULT_ENGINE_CONFIGURATION["QUEUES"])

        # Device selection
        failure_reasons, all_good = [], False
        physical_devices = hvk.list_physical_devices(api, instance)
        
        for index, physical_device in enumerate(physical_devices):
            
            # Features
            supported_features = hvk.physical_device_features(api, physical_device)
            if not "texture_compression_BC" in supported_features:
                failure_reasons.append(f"BC compressed textures are not supported on your machine on device #{index}")
                continue

            # Queues
            queue_families = hvk.list_queue_families(api, physical_device)
            queue_create_infos = []
            mapped_queue_configurations = {}
            render_queue_data = None
            bad_queues = False

            for qconf in queues_conf:
                queue_family = None

                # Find a matching queue family
                for qf in queue_families:
                    if qconf.type in IntFlag(qf.properties.queue_flags):
                        queue_family = qf
                
                # Go to the next device if a required queue configuration could not be found
                if qconf.required and queue_family is None:
                    bad_queues = True
                    failure_reasons.append(f"No queue family matches the required configuration {qconf} on device #{index}")
                    break

                # Update the queue create info array
                new_info = {"queue_family_index": queue_family.index, "queue_count": 0}
                queue_create_info = next((qc for qc in queue_create_infos if qc["queue_family_index"] == queue_family.index), new_info)
                queue_create_infos.append(queue_create_info)
                queue_local_index = queue_create_info["queue_count"]
                queue_create_info["queue_count"] += 1
            
                # Save the index of the required graphics queue that will be used by the renderer
                if render_queue_data is None and QueueType.Graphics in qconf.type:
                    render_queue_data = (queue_family, queue_local_index)

                # Associate the queue configuration with the family and the local index for queue handle fetching
                mapped_queue_configurations[qconf] = (queue_family, queue_local_index)

            if bad_queues:
                continue

            all_good = True
            break

        if not all_good:
            raise RuntimeError(failure_reasons)

        if render_queue_data is None:
            raise RuntimeError("No graphics queue was specified in the engine queues configuration. Protip: use \"QueueConf.Default\" ")

        # Device creation
        queue_create_infos = [hvk.queue_create_info(**args) for args in queue_create_infos]
        extensions = ("VK_KHR_swapchain",)
        features = vk.PhysicalDeviceFeatures(texture_compression_BC = 1)
        device = hvk.create_device(api, physical_device, extensions, queue_create_infos, features)

        # Fetching queues
        # First, fetch the render queue
        render_queue_family, render_family_local_index = render_queue_data
        render_queue_handle = hvk.get_queue(api, device, render_queue_family.index, render_family_local_index)
        render_queue = Queue(render_queue_handle, render_queue_family)

        # Second, fetch all the queues (yes, the render queue is fetched twice)
        queues = {}
        for queue_conf, queue_data in mapped_queue_configurations.items():
            queue_family, local_index = queue_data
            queue_handle = hvk.get_queue(api, device, queue_family.index, local_index)
            queues[queue_conf.name] = Queue(queue_handle, queue_family)

        self.physical_device = physical_device
        self.device = device
        self.render_queue = render_queue
        self.queues = queues