Java PointerBuffer.flip方法代码示例

import org.lwjgl.PointerBuffer; //导入方法依赖的package包/类
@Override
public List<File> openMultipleDialog(String title, String defaultPath,
        String[] filterPatterns, String filterDescription) {
    String result = null;
    
    //fix file path characters
    if (Utils.isWindows()) {
        defaultPath = defaultPath.replace("/", "\\");
    } else {
        defaultPath = defaultPath.replace("\\", "/");
    }
    if (filterPatterns != null && filterPatterns.length > 0) {
        try (MemoryStack stack = stackPush()) {
            PointerBuffer pointerBuffer = stack.mallocPointer(filterPatterns.length);

            for (String filterPattern : filterPatterns) {
                pointerBuffer.put(stack.UTF8(filterPattern));
            }
            
            pointerBuffer.flip();
            result = org.lwjgl.util.tinyfd.TinyFileDialogs.tinyfd_openFileDialog(title, defaultPath, pointerBuffer, filterDescription, true);
        }
    } else {
        result = org.lwjgl.util.tinyfd.TinyFileDialogs.tinyfd_openFileDialog(title, defaultPath, null, filterDescription, true);
    }
    
    if (result != null) {
        String[] paths = result.split("\\|");
        ArrayList<File> returnValue = new ArrayList<>();
        for (String path : paths) {
            returnValue.add(new File(path));
        }
        return returnValue;
    } else {
        return null;
    }
}
 

import org.lwjgl.PointerBuffer; //导入方法依赖的package包/类
@Override
public File openDialog(String title, String defaultPath,
        String[] filterPatterns, String filterDescription) {
    String result = null;
    
    //fix file path characters
    if (Utils.isWindows()) {
        defaultPath = defaultPath.replace("/", "\\");
    } else {
        defaultPath = defaultPath.replace("\\", "/");
    }
    
    if (filterPatterns != null && filterPatterns.length > 0) {
        try (MemoryStack stack = stackPush()) {
            PointerBuffer pointerBuffer = stack.mallocPointer(filterPatterns.length);

            for (String filterPattern : filterPatterns) {
                pointerBuffer.put(stack.UTF8(filterPattern));
            }
            
            pointerBuffer.flip();
            result = org.lwjgl.util.tinyfd.TinyFileDialogs.tinyfd_openFileDialog(title, defaultPath, pointerBuffer, filterDescription, false);
        }
    } else {
        result = org.lwjgl.util.tinyfd.TinyFileDialogs.tinyfd_openFileDialog(title, defaultPath, null, filterDescription, false);
    }
    
    if (result != null) {
        return new File(result);
    } else {
        return null;
    }
}
 

import org.lwjgl.PointerBuffer; //导入方法依赖的package包/类
@Override
public File saveDialog(String title, String defaultPath,
        String[] filterPatterns, String filterDescription) {
    String result = null;
    
    //fix file path characters
    if (Utils.isWindows()) {
        defaultPath = defaultPath.replace("/", "\\");
    } else {
        defaultPath = defaultPath.replace("\\", "/");
    }
    
    if (filterPatterns != null && filterPatterns.length > 0) {
        try (MemoryStack stack = stackPush()) {
            PointerBuffer pointerBuffer = null;
            pointerBuffer = stack.mallocPointer(filterPatterns.length);

            for (String filterPattern : filterPatterns) {
                pointerBuffer.put(stack.UTF8(filterPattern));
            }
            
            pointerBuffer.flip();
            result = org.lwjgl.util.tinyfd.TinyFileDialogs.tinyfd_saveFileDialog(title, defaultPath, pointerBuffer, filterDescription);
        }
    } else {
        result = org.lwjgl.util.tinyfd.TinyFileDialogs.tinyfd_saveFileDialog(title, defaultPath, null, filterDescription);
    }
    
    if (result != null) {
        return new File(result);
    } else {
        return null;
    }
}
 

import org.lwjgl.PointerBuffer; //导入方法依赖的package包/类
/**
 * Create a Vulkan instance using LWJGL 3.
 * 
 * @return the VkInstance handle
 */
private static VkInstance createInstance() {
    VkApplicationInfo appInfo = VkApplicationInfo.calloc()
            .sType(VK_STRUCTURE_TYPE_APPLICATION_INFO)
            .pApplicationName(memUTF8("AWT Vulkan Demo"))
            .pEngineName(memUTF8(""))
            .apiVersion(VK_MAKE_VERSION(1, 0, 2));
    ByteBuffer VK_KHR_SURFACE_EXTENSION = memUTF8(VK_KHR_SURFACE_EXTENSION_NAME);
    ByteBuffer VK_KHR_OS_SURFACE_EXTENSION;
    if (Platform.get() == Platform.WINDOWS)
        VK_KHR_OS_SURFACE_EXTENSION = memUTF8(VK_KHR_WIN32_SURFACE_EXTENSION_NAME);
    else
        VK_KHR_OS_SURFACE_EXTENSION = memUTF8(VK_KHR_XLIB_SURFACE_EXTENSION_NAME);
    PointerBuffer ppEnabledExtensionNames = memAllocPointer(2);
    ppEnabledExtensionNames.put(VK_KHR_SURFACE_EXTENSION);
    ppEnabledExtensionNames.put(VK_KHR_OS_SURFACE_EXTENSION);
    ppEnabledExtensionNames.flip();
    VkInstanceCreateInfo pCreateInfo = VkInstanceCreateInfo.calloc()
            .sType(VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO)
            .pNext(0L)
            .pApplicationInfo(appInfo);
    if (ppEnabledExtensionNames.remaining() > 0) {
        pCreateInfo.ppEnabledExtensionNames(ppEnabledExtensionNames);
    }
    PointerBuffer pInstance = MemoryUtil.memAllocPointer(1);
    int err = vkCreateInstance(pCreateInfo, null, pInstance);
    if (err != VK_SUCCESS) {
        throw new RuntimeException("Failed to create VkInstance: " + translateVulkanResult(err));
    }
    long instance = pInstance.get(0);
    memFree(pInstance);
    VkInstance ret = new VkInstance(instance, pCreateInfo);
    memFree(ppEnabledExtensionNames);
    memFree(VK_KHR_OS_SURFACE_EXTENSION);
    memFree(VK_KHR_SURFACE_EXTENSION);
    appInfo.free();
    return ret;
}
 

import org.lwjgl.PointerBuffer; //导入方法依赖的package包/类
/**
 * Create a Vulkan {@link VkInstance} using LWJGL 3.
 * <p>
 * The {@link VkInstance} represents a handle to the Vulkan API and we need that instance for about everything we do.
 * 
 * @return the VkInstance handle
 */
private static VkInstance createInstance(PointerBuffer requiredExtensions) {
    // Here we say what the name of our application is and which Vulkan version we are targetting (having this is optional)
    VkApplicationInfo appInfo = VkApplicationInfo.callocStack()
            .sType(VK_STRUCTURE_TYPE_APPLICATION_INFO)
            .pApplicationName(stackUTF8("GLFW Vulkan Demo"))
            .pEngineName(stackUTF8(""))
            .apiVersion(VK_MAKE_VERSION(1, 0, 2));

    // We also need to tell Vulkan which extensions we would like to use.
    // Those include the platform-dependent required extensions we are being told by GLFW to use.
    // This includes stuff like the Window System Interface extensions to actually render something on a window.
    //
    // We also add the debug extension so that validation layers and other things can send log messages to us.
    ByteBuffer VK_EXT_DEBUG_REPORT_EXTENSION = stackUTF8(VK_EXT_DEBUG_REPORT_EXTENSION_NAME);
    PointerBuffer ppEnabledExtensionNames = stackMallocPointer(requiredExtensions.remaining() + 1);
    ppEnabledExtensionNames.put(requiredExtensions) // <- platform-dependent required extensions
                           .put(VK_EXT_DEBUG_REPORT_EXTENSION) // <- the debug extensions
                           .flip();

    // Now comes the validation layers. These layers sit between our application (the Vulkan client) and the
    // Vulkan driver. Those layers will check whether we make any mistakes in using the Vulkan API and yell
    // at us via the debug extension.
    PointerBuffer ppEnabledLayerNames = stackMallocPointer(layers.length);
    for (int i = 0; validation && i < layers.length; i++)
        ppEnabledLayerNames.put(layers[i]);
    ppEnabledLayerNames.flip();

    // Vulkan uses many struct/record types when creating something. This ensures that every information is available
    // at the callsite of the creation and allows for easier validation and also for immutability of the created object.
    // 
    // The following struct defines everything that is needed to create a VkInstance
    VkInstanceCreateInfo pCreateInfo = VkInstanceCreateInfo.callocStack()
            .sType(VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO) // <- identifies what kind of struct this is (this is useful for extending the struct type later)
            .pNext(NULL) // <- must always be NULL until any next Vulkan version tells otherwise
            .pApplicationInfo(appInfo) // <- the application info we created above
            .ppEnabledExtensionNames(ppEnabledExtensionNames) // <- and the extension names themselves
            .ppEnabledLayerNames(ppEnabledLayerNames); // <- and the layer names themselves
    PointerBuffer pInstance = stackMallocPointer(1); // <- create a PointerBuffer which will hold the handle to the created VkInstance
    int err = vkCreateInstance(pCreateInfo, null, pInstance); // <- actually create the VkInstance now!
    long instance = pInstance.get(0); // <- get the VkInstance handle
    // One word about freeing memory:
    // Every host-allocated memory directly or indirectly referenced via a parameter to any Vulkan function can always
    // be freed right after the invocation of the Vulkan function returned.

    // Check whether we succeeded in creating the VkInstance
    if (err != VK_SUCCESS) {
        throw new AssertionError("Failed to create VkInstance: " + translateVulkanResult(err));
    }
    // Create an object-oriented wrapper around the simple VkInstance long handle
    // This is needed by LWJGL to later "dispatch" (i.e. direct calls to) the right Vukan functions.
    VkInstance ret = new VkInstance(instance, pCreateInfo);
    return ret;
}
 

import org.lwjgl.PointerBuffer; //导入方法依赖的package包/类
private static DeviceAndGraphicsQueueFamily createDeviceAndGetGraphicsQueueFamily(VkPhysicalDevice physicalDevice) {
    IntBuffer pQueueFamilyPropertyCount = stackMallocInt(1);
    vkGetPhysicalDeviceQueueFamilyProperties(physicalDevice, pQueueFamilyPropertyCount, null);
    int queueCount = pQueueFamilyPropertyCount.get(0);
    VkQueueFamilyProperties.Buffer queueProps = VkQueueFamilyProperties.callocStack(queueCount);
    vkGetPhysicalDeviceQueueFamilyProperties(physicalDevice, pQueueFamilyPropertyCount, queueProps);
    int graphicsQueueFamilyIndex;
    for (graphicsQueueFamilyIndex = 0; graphicsQueueFamilyIndex < queueCount; graphicsQueueFamilyIndex++) {
        if ((queueProps.get(graphicsQueueFamilyIndex).queueFlags() & VK_QUEUE_GRAPHICS_BIT) != 0)
            break;
    }
    VkDeviceQueueCreateInfo.Buffer queueCreateInfo = VkDeviceQueueCreateInfo.callocStack(1)
            .sType(VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO)
            .queueFamilyIndex(graphicsQueueFamilyIndex)
            .pQueuePriorities(stackFloats(0.0f));

    PointerBuffer extensions = stackMallocPointer(1);
    ByteBuffer VK_KHR_SWAPCHAIN_EXTENSION = stackUTF8(VK_KHR_SWAPCHAIN_EXTENSION_NAME);
    extensions.put(VK_KHR_SWAPCHAIN_EXTENSION);
    extensions.flip();
    PointerBuffer ppEnabledLayerNames = stackMallocPointer(layers.length);
    for (int i = 0; validation && i < layers.length; i++)
        ppEnabledLayerNames.put(layers[i]);
    ppEnabledLayerNames.flip();

    VkDeviceCreateInfo deviceCreateInfo = VkDeviceCreateInfo.callocStack()
            .sType(VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO)
            .pNext(NULL)
            .pQueueCreateInfos(queueCreateInfo)
            .ppEnabledExtensionNames(extensions)
            .ppEnabledLayerNames(ppEnabledLayerNames);

    PointerBuffer pDevice = stackMallocPointer(1);
    int err = vkCreateDevice(physicalDevice, deviceCreateInfo, null, pDevice);
    long device = pDevice.get(0);
    if (err != VK_SUCCESS) {
        throw new AssertionError("Failed to create device: " + translateVulkanResult(err));
    }

    DeviceAndGraphicsQueueFamily ret = new DeviceAndGraphicsQueueFamily();
    ret.device = new VkDevice(device, physicalDevice, deviceCreateInfo);
    ret.queueFamilyIndex = graphicsQueueFamilyIndex;
    return ret;
}
 

import org.lwjgl.PointerBuffer; //导入方法依赖的package包/类
@Override
public VkInstance initVulkan()
{
    // We need to say which extensions to enable at the time of creating the instance. We should also add in the
    // extensions required by GLFW to create the surface. Note that this should not be freed manually.
    PointerBuffer glfwExtensions = glfwGetRequiredInstanceExtensions();

    // Create a PointerBuffer with memory enough to hold pointers for all the extension names.
    PointerBuffer enabledExtensionNames = memAllocPointer(glfwExtensions.remaining() + 1);

    // Encode the surface extension names into a ByteBuffer so we can put it in the PointerBuffer.
    ByteBuffer KHR_SURFACE_EXTENSION = memASCII(VK_KHR_SURFACE_EXTENSION_NAME);

    // Add the extensions to the PointerBuffer and flip the buffer. In order to present something
    // we must request the KHR_SURFACE_EXTENSION, without which, the instance will act like an offscreen context.
    enabledExtensionNames.put(KHR_SURFACE_EXTENSION);

    // Also put in the GLFW extensions into the enabledExtensionNames list so they get enabled too.
    while (glfwExtensions.remaining() > 0)
        enabledExtensionNames.put(glfwExtensions.get());

    // Flip the buffer so that the system can read from the buffer.
    enabledExtensionNames.flip();

    // The VkApplicationInfo struct contains information about the application that we are going to create.
    VkApplicationInfo appInfo = VkApplicationInfo.calloc()
            .sType(VK_STRUCTURE_TYPE_APPLICATION_INFO)
            .pApplicationName(memASCII("Vulkan Instance Example"))
            .pEngineName(memASCII(""))
            .apiVersion(VK_MAKE_VERSION(1, 0, 4));

    // The VkInstanceCreateInfo struct contains information about the Vulkan instance, and refers to the appInfo.
    VkInstanceCreateInfo instInfo = VkInstanceCreateInfo.calloc()
            .sType(VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO)
            .pNext(NULL)
            .pApplicationInfo(appInfo)
            .ppEnabledExtensionNames(enabledExtensionNames);

    // The PointerBuffer enough to hold one pointer, the PointerBuffer is not a pointer, but it's contents are.
    PointerBuffer pInstance = memAllocPointer(1);

    // Create the instance. The instance handle is stored in the PointerBuffer which we can use now.
    vkCreateInstance(instInfo, null, pInstance);

    // Get the VkInstance handle from the pointer
    instance = new VkInstance(pInstance.get(), instInfo);

    // Free the pointer buffer, not the VkInstance struct
    memFree(pInstance);

    // Free the VkApplicationInfo and VkInstanceCreateInfo structs, we no longer need them in our application.
    appInfo.free();
    instInfo.free();

    // Free the extension names, we don't need them now.
    memFree(enabledExtensionNames);
    memFree(KHR_SURFACE_EXTENSION);

    // Print out the instance capabilities
    VKCapabilities capabilities = instance.getCapabilities();

    System.out.println("Vulkan10: " + capabilities.Vulkan10);
    System.out.println("VK_KHR_display: " + capabilities.VK_KHR_display);
    System.out.println("VK_KHR_surface: " + capabilities.VK_KHR_surface);
    System.out.println("VK_KHR_swapchain: " + capabilities.VK_KHR_swapchain);
    System.out.println("VK_EXT_debug_report: " + capabilities.VK_EXT_debug_report);
    System.out.println("VK_KHR_xlib_surface: " + capabilities.VK_KHR_xlib_surface);
    System.out.println("VK_KHR_win32_surface: " + capabilities.VK_KHR_win32_surface);
    System.out.println("VK_KHR_display_swapchain: " + capabilities.VK_KHR_display_swapchain);
    System.out.println("VK_KHR_sampler_mirror_clamp_to_edge: " + capabilities.VK_KHR_sampler_mirror_clamp_to_edge);

    // Return instance to attach to the display so rendering can be done.
    return instance;
}