All Downloads are FREE. Search and download functionalities are using the official Maven repository.

org.lwjgl.vulkan.EXTExtendedDynamicState Maven / Gradle / Ivy

Go to download

A new generation graphics and compute API that provides high-efficiency, cross-platform access to modern GPUs used in a wide variety of devices from PCs and consoles to mobile phones and embedded platforms.

There is a newer version: 3.3.4
Show newest version
/*
 * Copyright LWJGL. All rights reserved.
 * License terms: https://www.lwjgl.org/license
 * MACHINE GENERATED FILE, DO NOT EDIT
 */
package org.lwjgl.vulkan;

import javax.annotation.*;

import java.nio.*;

import org.lwjgl.system.*;

import static org.lwjgl.system.Checks.*;
import static org.lwjgl.system.JNI.*;
import static org.lwjgl.system.MemoryUtil.*;

/**
 * This extension adds some more dynamic state to support applications that need to reduce the number of pipeline state objects they compile and bind.
 * 
 * 
VK_EXT_extended_dynamic_state
* *
*
Name String
*
{@code VK_EXT_extended_dynamic_state}
*
Extension Type
*
Device extension
*
Registered Extension Number
*
268
*
Revision
*
1
*
Extension and Version Dependencies
*
    *
  • Requires Vulkan 1.0
  • *
  • Requires {@link KHRGetPhysicalDeviceProperties2 VK_KHR_get_physical_device_properties2}
  • *
*
Contact
*
*
* *
Other Extension Metadata
* *
*
Last Modified Date
*
2019-12-09
*
IP Status
*
No known IP claims.
*
Contributors
*
    *
  • Dan Ginsburg, Valve Corporation
  • *
  • Graeme Leese, Broadcom
  • *
  • Hans-Kristian Arntzen, Valve Corporation
  • *
  • Jan-Harald Fredriksen, Arm Limited
  • *
  • Jason Ekstrand, Intel
  • *
  • Jeff Bolz, NVIDIA
  • *
  • Jesse Hall, Google
  • *
  • Philip Rebohle, Valve Corporation
  • *
  • Stuart Smith, Imagination Technologies
  • *
  • Tobias Hector, AMD
  • *
*
*/ public class EXTExtendedDynamicState { /** The extension specification version. */ public static final int VK_EXT_EXTENDED_DYNAMIC_STATE_SPEC_VERSION = 1; /** The extension name. */ public static final String VK_EXT_EXTENDED_DYNAMIC_STATE_EXTENSION_NAME = "VK_EXT_extended_dynamic_state"; /** Extends {@code VkStructureType}. */ public static final int VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT = 1000267000; /** * Extends {@code VkDynamicState}. * *
Enum values:
* *
    *
  • {@link #VK_DYNAMIC_STATE_CULL_MODE_EXT DYNAMIC_STATE_CULL_MODE_EXT}
  • *
  • {@link #VK_DYNAMIC_STATE_FRONT_FACE_EXT DYNAMIC_STATE_FRONT_FACE_EXT}
  • *
  • {@link #VK_DYNAMIC_STATE_PRIMITIVE_TOPOLOGY_EXT DYNAMIC_STATE_PRIMITIVE_TOPOLOGY_EXT}
  • *
  • {@link #VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT}
  • *
  • {@link #VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT_EXT DYNAMIC_STATE_SCISSOR_WITH_COUNT_EXT}
  • *
  • {@link #VK_DYNAMIC_STATE_VERTEX_INPUT_BINDING_STRIDE_EXT DYNAMIC_STATE_VERTEX_INPUT_BINDING_STRIDE_EXT}
  • *
  • {@link #VK_DYNAMIC_STATE_DEPTH_TEST_ENABLE_EXT DYNAMIC_STATE_DEPTH_TEST_ENABLE_EXT}
  • *
  • {@link #VK_DYNAMIC_STATE_DEPTH_WRITE_ENABLE_EXT DYNAMIC_STATE_DEPTH_WRITE_ENABLE_EXT}
  • *
  • {@link #VK_DYNAMIC_STATE_DEPTH_COMPARE_OP_EXT DYNAMIC_STATE_DEPTH_COMPARE_OP_EXT}
  • *
  • {@link #VK_DYNAMIC_STATE_DEPTH_BOUNDS_TEST_ENABLE_EXT DYNAMIC_STATE_DEPTH_BOUNDS_TEST_ENABLE_EXT}
  • *
  • {@link #VK_DYNAMIC_STATE_STENCIL_TEST_ENABLE_EXT DYNAMIC_STATE_STENCIL_TEST_ENABLE_EXT}
  • *
  • {@link #VK_DYNAMIC_STATE_STENCIL_OP_EXT DYNAMIC_STATE_STENCIL_OP_EXT}
  • *
*/ public static final int VK_DYNAMIC_STATE_CULL_MODE_EXT = 1000267000, VK_DYNAMIC_STATE_FRONT_FACE_EXT = 1000267001, VK_DYNAMIC_STATE_PRIMITIVE_TOPOLOGY_EXT = 1000267002, VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT = 1000267003, VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT_EXT = 1000267004, VK_DYNAMIC_STATE_VERTEX_INPUT_BINDING_STRIDE_EXT = 1000267005, VK_DYNAMIC_STATE_DEPTH_TEST_ENABLE_EXT = 1000267006, VK_DYNAMIC_STATE_DEPTH_WRITE_ENABLE_EXT = 1000267007, VK_DYNAMIC_STATE_DEPTH_COMPARE_OP_EXT = 1000267008, VK_DYNAMIC_STATE_DEPTH_BOUNDS_TEST_ENABLE_EXT = 1000267009, VK_DYNAMIC_STATE_STENCIL_TEST_ENABLE_EXT = 1000267010, VK_DYNAMIC_STATE_STENCIL_OP_EXT = 1000267011; protected EXTExtendedDynamicState() { throw new UnsupportedOperationException(); } // --- [ vkCmdSetCullModeEXT ] --- /** * Set cull mode dynamically for a command buffer. * *
C Specification
* *

To dynamically set the cull mode, call:

* *

     * void vkCmdSetCullModeEXT(
     *     VkCommandBuffer                             commandBuffer,
     *     VkCullModeFlags                             cullMode);
* *
Description
* *

This command sets the cull mode for subsequent drawing commands when the graphics pipeline is created with {@link #VK_DYNAMIC_STATE_CULL_MODE_EXT DYNAMIC_STATE_CULL_MODE_EXT} set in {@link VkPipelineDynamicStateCreateInfo}{@code ::pDynamicStates}. Otherwise, this state is specified by the {@link VkPipelineRasterizationStateCreateInfo}{@code ::cullMode} value used to create the currently active pipeline.

* *
Valid Usage
* * * *
Valid Usage (Implicit)
* *
    *
  • {@code commandBuffer} must be a valid {@code VkCommandBuffer} handle
  • *
  • {@code cullMode} must be a valid combination of {@code VkCullModeFlagBits} values
  • *
  • {@code commandBuffer} must be in the recording state
  • *
  • The {@code VkCommandPool} that {@code commandBuffer} was allocated from must support graphics operations
  • *
* *
Host Synchronization
* *
    *
  • Host access to {@code commandBuffer} must be externally synchronized
  • *
  • Host access to the {@code VkCommandPool} that {@code commandBuffer} was allocated from must be externally synchronized
  • *
* *
Command Properties
* * * * *
Command Buffer LevelsRender Pass ScopeSupported Queue Types
Primary SecondaryBothGraphics
* * @param commandBuffer the command buffer into which the command will be recorded. * @param cullMode specifies the cull mode property to use for drawing. */ public static void vkCmdSetCullModeEXT(VkCommandBuffer commandBuffer, @NativeType("VkCullModeFlags") int cullMode) { long __functionAddress = commandBuffer.getCapabilities().vkCmdSetCullModeEXT; if (CHECKS) { check(__functionAddress); } callPV(commandBuffer.address(), cullMode, __functionAddress); } // --- [ vkCmdSetFrontFaceEXT ] --- /** * Set front face orientation dynamically for a command buffer. * *
C Specification
* *

To dynamically set the front face orientation, call:

* *

     * void vkCmdSetFrontFaceEXT(
     *     VkCommandBuffer                             commandBuffer,
     *     VkFrontFace                                 frontFace);
* *
Description
* *

This command sets the front face orientation for subsequent drawing commands when the graphics pipeline is created with {@link #VK_DYNAMIC_STATE_FRONT_FACE_EXT DYNAMIC_STATE_FRONT_FACE_EXT} set in {@link VkPipelineDynamicStateCreateInfo}{@code ::pDynamicStates}. Otherwise, this state is specified by the {@link VkPipelineRasterizationStateCreateInfo}{@code ::frontFace} value used to create the currently active pipeline.

* *
Valid Usage
* * * *
Valid Usage (Implicit)
* *
    *
  • {@code commandBuffer} must be a valid {@code VkCommandBuffer} handle
  • *
  • {@code frontFace} must be a valid {@code VkFrontFace} value
  • *
  • {@code commandBuffer} must be in the recording state
  • *
  • The {@code VkCommandPool} that {@code commandBuffer} was allocated from must support graphics operations
  • *
* *
Host Synchronization
* *
    *
  • Host access to {@code commandBuffer} must be externally synchronized
  • *
  • Host access to the {@code VkCommandPool} that {@code commandBuffer} was allocated from must be externally synchronized
  • *
* *
Command Properties
* * * * *
Command Buffer LevelsRender Pass ScopeSupported Queue Types
Primary SecondaryBothGraphics
* * @param commandBuffer the command buffer into which the command will be recorded. * @param frontFace a {@code VkFrontFace} value specifying the front-facing triangle orientation to be used for culling. */ public static void vkCmdSetFrontFaceEXT(VkCommandBuffer commandBuffer, @NativeType("VkFrontFace") int frontFace) { long __functionAddress = commandBuffer.getCapabilities().vkCmdSetFrontFaceEXT; if (CHECKS) { check(__functionAddress); } callPV(commandBuffer.address(), frontFace, __functionAddress); } // --- [ vkCmdSetPrimitiveTopologyEXT ] --- /** * Set primitive topology state dynamically for a command buffer. * *
C Specification
* *

To dynamically set primitive topology, call:

* *

     * void vkCmdSetPrimitiveTopologyEXT(
     *     VkCommandBuffer                             commandBuffer,
     *     VkPrimitiveTopology                         primitiveTopology);
* *
Description
* *

This command sets the primitive topology for subsequent drawing commands when the graphics pipeline is created with {@link #VK_DYNAMIC_STATE_PRIMITIVE_TOPOLOGY_EXT DYNAMIC_STATE_PRIMITIVE_TOPOLOGY_EXT} set in {@link VkPipelineDynamicStateCreateInfo}{@code ::pDynamicStates}. Otherwise, this state is specified by the {@link VkPipelineInputAssemblyStateCreateInfo}{@code ::topology} value used to create the currently active pipeline.

* *
Valid Usage
* * * *
Valid Usage (Implicit)
* *
    *
  • {@code commandBuffer} must be a valid {@code VkCommandBuffer} handle
  • *
  • {@code primitiveTopology} must be a valid {@code VkPrimitiveTopology} value
  • *
  • {@code commandBuffer} must be in the recording state
  • *
  • The {@code VkCommandPool} that {@code commandBuffer} was allocated from must support graphics operations
  • *
* *
Host Synchronization
* *
    *
  • Host access to {@code commandBuffer} must be externally synchronized
  • *
  • Host access to the {@code VkCommandPool} that {@code commandBuffer} was allocated from must be externally synchronized
  • *
* *
Command Properties
* * * * *
Command Buffer LevelsRender Pass ScopeSupported Queue Types
Primary SecondaryBothGraphics
* * @param commandBuffer the command buffer into which the command will be recorded. * @param primitiveTopology specifies the primitive topology to use for drawing. */ public static void vkCmdSetPrimitiveTopologyEXT(VkCommandBuffer commandBuffer, @NativeType("VkPrimitiveTopology") int primitiveTopology) { long __functionAddress = commandBuffer.getCapabilities().vkCmdSetPrimitiveTopologyEXT; if (CHECKS) { check(__functionAddress); } callPV(commandBuffer.address(), primitiveTopology, __functionAddress); } // --- [ vkCmdSetViewportWithCountEXT ] --- /** * Unsafe version of: {@link #vkCmdSetViewportWithCountEXT CmdSetViewportWithCountEXT} * * @param viewportCount specifies the viewport count. */ public static void nvkCmdSetViewportWithCountEXT(VkCommandBuffer commandBuffer, int viewportCount, long pViewports) { long __functionAddress = commandBuffer.getCapabilities().vkCmdSetViewportWithCountEXT; if (CHECKS) { check(__functionAddress); } callPPV(commandBuffer.address(), viewportCount, pViewports, __functionAddress); } /** * Set the viewport count and viewports dynamically for a command buffer. * *
C Specification
* *

To dynamically set the viewport count and viewports, call:

* *

     * void vkCmdSetViewportWithCountEXT(
     *     VkCommandBuffer                             commandBuffer,
     *     uint32_t                                    viewportCount,
     *     const VkViewport*                           pViewports);
* *
Description
* *

This command sets the viewport count and viewports state for subsequent drawing commands when the graphics pipeline is created with {@link #VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT} set in {@link VkPipelineDynamicStateCreateInfo}{@code ::pDynamicStates}. Otherwise, this state is specified by the corresponding {@link VkPipelineViewportStateCreateInfo}{@code ::viewportCount} and {@code pViewports} values used to create the currently active pipeline.

* *
Valid Usage
* *
    *
  • The extendedDynamicState feature must be enabled
  • *
  • {@code viewportCount} must be between 1 and {@link VkPhysicalDeviceLimits}{@code ::maxViewports}, inclusive
  • *
  • If the multiple viewports feature is not enabled, {@code viewportCount} must be 1
  • *
  • {@code commandBuffer} must not have {@link VkCommandBufferInheritanceViewportScissorInfoNV}{@code ::viewportScissor2D} enabled
  • *
* *
Valid Usage (Implicit)
* *
    *
  • {@code commandBuffer} must be a valid {@code VkCommandBuffer} handle
  • *
  • {@code pViewports} must be a valid pointer to an array of {@code viewportCount} valid {@link VkViewport} structures
  • *
  • {@code commandBuffer} must be in the recording state
  • *
  • The {@code VkCommandPool} that {@code commandBuffer} was allocated from must support graphics operations
  • *
  • {@code viewportCount} must be greater than 0
  • *
* *
Host Synchronization
* *
    *
  • Host access to {@code commandBuffer} must be externally synchronized
  • *
  • Host access to the {@code VkCommandPool} that {@code commandBuffer} was allocated from must be externally synchronized
  • *
* *
Command Properties
* * * * *
Command Buffer LevelsRender Pass ScopeSupported Queue Types
Primary SecondaryBothGraphics
* *
See Also
* *

{@link VkViewport}

* * @param commandBuffer the command buffer into which the command will be recorded. * @param pViewports specifies the viewports to use for drawing. */ public static void vkCmdSetViewportWithCountEXT(VkCommandBuffer commandBuffer, @NativeType("VkViewport const *") VkViewport.Buffer pViewports) { nvkCmdSetViewportWithCountEXT(commandBuffer, pViewports.remaining(), pViewports.address()); } // --- [ vkCmdSetScissorWithCountEXT ] --- /** * Unsafe version of: {@link #vkCmdSetScissorWithCountEXT CmdSetScissorWithCountEXT} * * @param scissorCount specifies the scissor count. */ public static void nvkCmdSetScissorWithCountEXT(VkCommandBuffer commandBuffer, int scissorCount, long pScissors) { long __functionAddress = commandBuffer.getCapabilities().vkCmdSetScissorWithCountEXT; if (CHECKS) { check(__functionAddress); } callPPV(commandBuffer.address(), scissorCount, pScissors, __functionAddress); } /** * Set the scissor count and scissor rectangular bounds dynamically for a command buffer. * *
C Specification
* *

To dynamically set the scissor count and scissor rectangular bounds, call:

* *

     * void vkCmdSetScissorWithCountEXT(
     *     VkCommandBuffer                             commandBuffer,
     *     uint32_t                                    scissorCount,
     *     const VkRect2D*                             pScissors);
* *
Description
* *

This command sets the scissor count and scissor rectangular bounds state for subsequence drawing commands when the graphics pipeline is created with {@link #VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT_EXT DYNAMIC_STATE_SCISSOR_WITH_COUNT_EXT} set in {@link VkPipelineDynamicStateCreateInfo}{@code ::pDynamicStates}. Otherwise, this state is specified by the corresponding {@link VkPipelineViewportStateCreateInfo}{@code ::scissorCount} and {@code pScissors} values used to create the currently active pipeline.

* *
Valid Usage
* *
    *
  • The extendedDynamicState feature must be enabled
  • *
  • {@code scissorCount} must be between 1 and {@link VkPhysicalDeviceLimits}{@code ::maxViewports}, inclusive
  • *
  • If the multiple viewports feature is not enabled, {@code scissorCount} must be 1
  • *
  • The {@code x} and {@code y} members of {@code offset} member of any element of {@code pScissors} must be greater than or equal to 0
  • *
  • Evaluation of (offset.x + extent.width) must not cause a signed integer addition overflow for any element of {@code pScissors}
  • *
  • Evaluation of (offset.y + extent.height) must not cause a signed integer addition overflow for any element of {@code pScissors}
  • *
  • {@code commandBuffer} must not have {@link VkCommandBufferInheritanceViewportScissorInfoNV}{@code ::viewportScissor2D} enabled
  • *
* *
Valid Usage (Implicit)
* *
    *
  • {@code commandBuffer} must be a valid {@code VkCommandBuffer} handle
  • *
  • {@code pScissors} must be a valid pointer to an array of {@code scissorCount} {@link VkRect2D} structures
  • *
  • {@code commandBuffer} must be in the recording state
  • *
  • The {@code VkCommandPool} that {@code commandBuffer} was allocated from must support graphics operations
  • *
  • {@code scissorCount} must be greater than 0
  • *
* *
Host Synchronization
* *
    *
  • Host access to {@code commandBuffer} must be externally synchronized
  • *
  • Host access to the {@code VkCommandPool} that {@code commandBuffer} was allocated from must be externally synchronized
  • *
* *
Command Properties
* * * * *
Command Buffer LevelsRender Pass ScopeSupported Queue Types
Primary SecondaryBothGraphics
* *
See Also
* *

{@link VkRect2D}

* * @param commandBuffer the command buffer into which the command will be recorded. * @param pScissors specifies the scissors to use for drawing. */ public static void vkCmdSetScissorWithCountEXT(VkCommandBuffer commandBuffer, @NativeType("VkRect2D const *") VkRect2D.Buffer pScissors) { nvkCmdSetScissorWithCountEXT(commandBuffer, pScissors.remaining(), pScissors.address()); } // --- [ vkCmdBindVertexBuffers2EXT ] --- /** * Unsafe version of: {@link #vkCmdBindVertexBuffers2EXT CmdBindVertexBuffers2EXT} * * @param bindingCount the number of vertex input bindings whose state is updated by the command. */ public static void nvkCmdBindVertexBuffers2EXT(VkCommandBuffer commandBuffer, int firstBinding, int bindingCount, long pBuffers, long pOffsets, long pSizes, long pStrides) { long __functionAddress = commandBuffer.getCapabilities().vkCmdBindVertexBuffers2EXT; if (CHECKS) { check(__functionAddress); } callPPPPPV(commandBuffer.address(), firstBinding, bindingCount, pBuffers, pOffsets, pSizes, pStrides, __functionAddress); } /** * Bind vertex buffers to a command buffer and dynamically set strides. * *
C Specification
* *

Alternatively, to bind vertex buffers, along with their sizes and strides, to a command buffer for use in subsequent drawing commands, call:

* *

     * void vkCmdBindVertexBuffers2EXT(
     *     VkCommandBuffer                             commandBuffer,
     *     uint32_t                                    firstBinding,
     *     uint32_t                                    bindingCount,
     *     const VkBuffer*                             pBuffers,
     *     const VkDeviceSize*                         pOffsets,
     *     const VkDeviceSize*                         pSizes,
     *     const VkDeviceSize*                         pStrides);
* *
Description
* *

The values taken from elements i of {@code pBuffers} and {@code pOffsets} replace the current state for the vertex input binding firstBinding + i, for i in [0, bindingCount). The vertex input binding is updated to start at the offset indicated by {@code pOffsets}[i] from the start of the buffer {@code pBuffers}[i]. If {@code pSizes} is not {@code NULL} then {@code pSizes}[i] specifies the bound size of the vertex buffer starting from the corresponding elements of {@code pBuffers}[i] plus {@code pOffsets}[i]. All vertex input attributes that use each of these bindings will use these updated addresses in their address calculations for subsequent drawing commands. If the nullDescriptor feature is enabled, elements of {@code pBuffers} can be {@link VK10#VK_NULL_HANDLE NULL_HANDLE}, and can be used by the vertex shader. If a vertex input attribute is bound to a vertex input binding that is {@link VK10#VK_NULL_HANDLE NULL_HANDLE}, the values taken from memory are considered to be zero, and missing G, B, or A components are filled with (0,0,1).

* *

This command also <pipelines-dynamic-state, dynamically sets>> the byte strides between consecutive elements within buffer {@code pBuffers}[i] to the corresponding {@code pStrides}[i] value when the graphics pipeline is created with {@link #VK_DYNAMIC_STATE_VERTEX_INPUT_BINDING_STRIDE_EXT DYNAMIC_STATE_VERTEX_INPUT_BINDING_STRIDE_EXT} set in {@link VkPipelineDynamicStateCreateInfo}{@code ::pDynamicStates}. Otherwise, strides are specified by the {@link VkVertexInputBindingDescription}{@code ::stride} values used to create the currently active pipeline.

* *

If the bound pipeline state object was also created with the {@link EXTVertexInputDynamicState#VK_DYNAMIC_STATE_VERTEX_INPUT_EXT DYNAMIC_STATE_VERTEX_INPUT_EXT} dynamic state enabled then {@link EXTVertexInputDynamicState#vkCmdSetVertexInputEXT CmdSetVertexInputEXT} can be used instead of {@code vkCmdBindVertexBuffers2EXT} to set the stride.

* *
Valid Usage
* *
    *
  • {@code firstBinding} must be less than {@link VkPhysicalDeviceLimits}{@code ::maxVertexInputBindings}
  • *
  • The sum of {@code firstBinding} and {@code bindingCount} must be less than or equal to {@link VkPhysicalDeviceLimits}{@code ::maxVertexInputBindings}
  • *
  • All elements of {@code pOffsets} must be less than the size of the corresponding element in {@code pBuffers}
  • *
  • If {@code pSizes} is not {@code NULL}, all elements of {@code pOffsets} plus {@code pSizes} must be less than or equal to the size of the corresponding element in {@code pBuffers}
  • *
  • All elements of {@code pBuffers} must have been created with the {@link VK10#VK_BUFFER_USAGE_VERTEX_BUFFER_BIT BUFFER_USAGE_VERTEX_BUFFER_BIT} flag
  • *
  • Each element of {@code pBuffers} that is non-sparse must be bound completely and contiguously to a single {@code VkDeviceMemory} object
  • *
  • If the nullDescriptor feature is not enabled, all elements of {@code pBuffers} must not be {@link VK10#VK_NULL_HANDLE NULL_HANDLE}
  • *
  • If an element of {@code pBuffers} is {@link VK10#VK_NULL_HANDLE NULL_HANDLE}, then the corresponding element of {@code pOffsets} must be zero
  • *
  • If {@code pStrides} is not {@code NULL} each element of {@code pStrides} must be less than or equal to {@link VkPhysicalDeviceLimits}{@code ::maxVertexInputBindingStride}
  • *
  • If {@code pStrides} is not {@code NULL} each element of {@code pStrides} must be either 0 or greater than or equal to the maximum extent of all vertex input attributes fetched from the corresponding binding, where the extent is calculated as the {@link VkVertexInputAttributeDescription}{@code ::offset} plus {@link VkVertexInputAttributeDescription}{@code ::format} size
  • *
* *
Valid Usage (Implicit)
* *
    *
  • {@code commandBuffer} must be a valid {@code VkCommandBuffer} handle
  • *
  • {@code pBuffers} must be a valid pointer to an array of {@code bindingCount} valid or {@link VK10#VK_NULL_HANDLE NULL_HANDLE} {@code VkBuffer} handles
  • *
  • {@code pOffsets} must be a valid pointer to an array of {@code bindingCount} {@code VkDeviceSize} values
  • *
  • If {@code pSizes} is not {@code NULL}, {@code pSizes} must be a valid pointer to an array of {@code bindingCount} {@code VkDeviceSize} values
  • *
  • If {@code pStrides} is not {@code NULL}, {@code pStrides} must be a valid pointer to an array of {@code bindingCount} {@code VkDeviceSize} values
  • *
  • {@code commandBuffer} must be in the recording state
  • *
  • The {@code VkCommandPool} that {@code commandBuffer} was allocated from must support graphics operations
  • *
  • If any of {@code pSizes}, or {@code pStrides} are not {@code NULL}, {@code bindingCount} must be greater than 0
  • *
  • Both of {@code commandBuffer}, and the elements of {@code pBuffers} that are valid handles of non-ignored parameters must have been created, allocated, or retrieved from the same {@code VkDevice}
  • *
* *
Host Synchronization
* *
    *
  • Host access to {@code commandBuffer} must be externally synchronized
  • *
  • Host access to the {@code VkCommandPool} that {@code commandBuffer} was allocated from must be externally synchronized
  • *
* *
Command Properties
* * * * *
Command Buffer LevelsRender Pass ScopeSupported Queue Types
Primary SecondaryBothGraphics
* * @param commandBuffer the command buffer into which the command is recorded. * @param firstBinding the index of the first vertex input binding whose state is updated by the command. * @param pBuffers a pointer to an array of buffer handles. * @param pOffsets a pointer to an array of buffer offsets. * @param pSizes {@code NULL} or a pointer to an array of the size in bytes of vertex data bound from {@code pBuffers}. * @param pStrides {@code NULL} or a pointer to an array of buffer strides. */ public static void vkCmdBindVertexBuffers2EXT(VkCommandBuffer commandBuffer, @NativeType("uint32_t") int firstBinding, @NativeType("VkBuffer const *") LongBuffer pBuffers, @NativeType("VkDeviceSize const *") LongBuffer pOffsets, @Nullable @NativeType("VkDeviceSize const *") LongBuffer pSizes, @Nullable @NativeType("VkDeviceSize const *") LongBuffer pStrides) { if (CHECKS) { check(pOffsets, pBuffers.remaining()); checkSafe(pSizes, pBuffers.remaining()); checkSafe(pStrides, pBuffers.remaining()); } nvkCmdBindVertexBuffers2EXT(commandBuffer, firstBinding, pBuffers.remaining(), memAddress(pBuffers), memAddress(pOffsets), memAddressSafe(pSizes), memAddressSafe(pStrides)); } // --- [ vkCmdSetDepthTestEnableEXT ] --- /** * Set depth test enable dynamically for a command buffer. * *
C Specification
* *

To dynamically enable or disable the depth test, call:

* *

     * void vkCmdSetDepthTestEnableEXT(
     *     VkCommandBuffer                             commandBuffer,
     *     VkBool32                                    depthTestEnable);
* *
Description
* *

This command sets the depth test enable for subsequent drawing commands when the graphics pipeline is created with {@link #VK_DYNAMIC_STATE_DEPTH_TEST_ENABLE_EXT DYNAMIC_STATE_DEPTH_TEST_ENABLE_EXT} set in {@link VkPipelineDynamicStateCreateInfo}{@code ::pDynamicStates}. Otherwise, this state is specified by the {@link VkPipelineDepthStencilStateCreateInfo}{@code ::depthTestEnable} value used to create the currently active pipeline.

* *
Valid Usage
* * * *
Valid Usage (Implicit)
* *
    *
  • {@code commandBuffer} must be a valid {@code VkCommandBuffer} handle
  • *
  • {@code commandBuffer} must be in the recording state
  • *
  • The {@code VkCommandPool} that {@code commandBuffer} was allocated from must support graphics operations
  • *
* *
Host Synchronization
* *
    *
  • Host access to {@code commandBuffer} must be externally synchronized
  • *
  • Host access to the {@code VkCommandPool} that {@code commandBuffer} was allocated from must be externally synchronized
  • *
* *
Command Properties
* * * * *
Command Buffer LevelsRender Pass ScopeSupported Queue Types
Primary SecondaryBothGraphics
* * @param commandBuffer the command buffer into which the command will be recorded. * @param depthTestEnable specifies if the depth test is enabled. */ public static void vkCmdSetDepthTestEnableEXT(VkCommandBuffer commandBuffer, @NativeType("VkBool32") boolean depthTestEnable) { long __functionAddress = commandBuffer.getCapabilities().vkCmdSetDepthTestEnableEXT; if (CHECKS) { check(__functionAddress); } callPV(commandBuffer.address(), depthTestEnable ? 1 : 0, __functionAddress); } // --- [ vkCmdSetDepthWriteEnableEXT ] --- /** * Set depth write enable dynamically for a command buffer. * *
C Specification
* *

To dynamically set the depth write enable, call:

* *

     * void vkCmdSetDepthWriteEnableEXT(
     *     VkCommandBuffer                             commandBuffer,
     *     VkBool32                                    depthWriteEnable);
* *
Description
* *

This command sets the depth write enable for subsequent drawing commands when the graphics pipeline is created with {@link #VK_DYNAMIC_STATE_DEPTH_WRITE_ENABLE_EXT DYNAMIC_STATE_DEPTH_WRITE_ENABLE_EXT} set in {@link VkPipelineDynamicStateCreateInfo}{@code ::pDynamicStates}. Otherwise, this state is specified by the {@link VkPipelineDepthStencilStateCreateInfo}{@code ::depthWriteEnable} value used to create the currently active pipeline.

* *
Valid Usage
* * * *
Valid Usage (Implicit)
* *
    *
  • {@code commandBuffer} must be a valid {@code VkCommandBuffer} handle
  • *
  • {@code commandBuffer} must be in the recording state
  • *
  • The {@code VkCommandPool} that {@code commandBuffer} was allocated from must support graphics operations
  • *
* *
Host Synchronization
* *
    *
  • Host access to {@code commandBuffer} must be externally synchronized
  • *
  • Host access to the {@code VkCommandPool} that {@code commandBuffer} was allocated from must be externally synchronized
  • *
* *
Command Properties
* * * * *
Command Buffer LevelsRender Pass ScopeSupported Queue Types
Primary SecondaryBothGraphics
* * @param commandBuffer the command buffer into which the command will be recorded. * @param depthWriteEnable specifies if depth writes are enabled. */ public static void vkCmdSetDepthWriteEnableEXT(VkCommandBuffer commandBuffer, @NativeType("VkBool32") boolean depthWriteEnable) { long __functionAddress = commandBuffer.getCapabilities().vkCmdSetDepthWriteEnableEXT; if (CHECKS) { check(__functionAddress); } callPV(commandBuffer.address(), depthWriteEnable ? 1 : 0, __functionAddress); } // --- [ vkCmdSetDepthCompareOpEXT ] --- /** * Set depth comparison operator dynamically for a command buffer. * *
C Specification
* *

To dynamically set the depth compare operator, call:

* *

     * void vkCmdSetDepthCompareOpEXT(
     *     VkCommandBuffer                             commandBuffer,
     *     VkCompareOp                                 depthCompareOp);
* *
Description
* *

This command sets the depth comparison operator for subsequent drawing commands when the graphics pipeline is created with {@link #VK_DYNAMIC_STATE_DEPTH_COMPARE_OP_EXT DYNAMIC_STATE_DEPTH_COMPARE_OP_EXT} set in {@link VkPipelineDynamicStateCreateInfo}{@code ::pDynamicStates}. Otherwise, this state is specified by the {@link VkPipelineDepthStencilStateCreateInfo}{@code ::depthCompareOp} value used to create the currently active pipeline.

* *
Valid Usage
* * * *
Valid Usage (Implicit)
* *
    *
  • {@code commandBuffer} must be a valid {@code VkCommandBuffer} handle
  • *
  • {@code depthCompareOp} must be a valid {@code VkCompareOp} value
  • *
  • {@code commandBuffer} must be in the recording state
  • *
  • The {@code VkCommandPool} that {@code commandBuffer} was allocated from must support graphics operations
  • *
* *
Host Synchronization
* *
    *
  • Host access to {@code commandBuffer} must be externally synchronized
  • *
  • Host access to the {@code VkCommandPool} that {@code commandBuffer} was allocated from must be externally synchronized
  • *
* *
Command Properties
* * * * *
Command Buffer LevelsRender Pass ScopeSupported Queue Types
Primary SecondaryBothGraphics
* * @param commandBuffer the command buffer into which the command will be recorded. * @param depthCompareOp specifies the depth comparison operator. */ public static void vkCmdSetDepthCompareOpEXT(VkCommandBuffer commandBuffer, @NativeType("VkCompareOp") int depthCompareOp) { long __functionAddress = commandBuffer.getCapabilities().vkCmdSetDepthCompareOpEXT; if (CHECKS) { check(__functionAddress); } callPV(commandBuffer.address(), depthCompareOp, __functionAddress); } // --- [ vkCmdSetDepthBoundsTestEnableEXT ] --- /** * Set depth bounds test enable dynamically for a command buffer. * *
C Specification
* *

To dynamically enable or disable the depth bounds test, call:

* *

     * void vkCmdSetDepthBoundsTestEnableEXT(
     *     VkCommandBuffer                             commandBuffer,
     *     VkBool32                                    depthBoundsTestEnable);
* *
Description
* *

This command sets the depth bounds enable for subsequent drawing commands when the graphics pipeline is created with {@link #VK_DYNAMIC_STATE_DEPTH_BOUNDS_TEST_ENABLE_EXT DYNAMIC_STATE_DEPTH_BOUNDS_TEST_ENABLE_EXT} set in {@link VkPipelineDynamicStateCreateInfo}{@code ::pDynamicStates}. Otherwise, this state is specified by the {@link VkPipelineDepthStencilStateCreateInfo}{@code ::depthBoundsTestEnable} value used to create the currently active pipeline.

* *
Valid Usage
* * * *
Valid Usage (Implicit)
* *
    *
  • {@code commandBuffer} must be a valid {@code VkCommandBuffer} handle
  • *
  • {@code commandBuffer} must be in the recording state
  • *
  • The {@code VkCommandPool} that {@code commandBuffer} was allocated from must support graphics operations
  • *
* *
Host Synchronization
* *
    *
  • Host access to {@code commandBuffer} must be externally synchronized
  • *
  • Host access to the {@code VkCommandPool} that {@code commandBuffer} was allocated from must be externally synchronized
  • *
* *
Command Properties
* * * * *
Command Buffer LevelsRender Pass ScopeSupported Queue Types
Primary SecondaryBothGraphics
* * @param commandBuffer the command buffer into which the command will be recorded. * @param depthBoundsTestEnable specifies if the depth bounds test is enabled. */ public static void vkCmdSetDepthBoundsTestEnableEXT(VkCommandBuffer commandBuffer, @NativeType("VkBool32") boolean depthBoundsTestEnable) { long __functionAddress = commandBuffer.getCapabilities().vkCmdSetDepthBoundsTestEnableEXT; if (CHECKS) { check(__functionAddress); } callPV(commandBuffer.address(), depthBoundsTestEnable ? 1 : 0, __functionAddress); } // --- [ vkCmdSetStencilTestEnableEXT ] --- /** * Set stencil test enable dynamically for a command buffer. * *
C Specification
* *

To dynamically enable or disable the stencil test, call:

* *

     * void vkCmdSetStencilTestEnableEXT(
     *     VkCommandBuffer                             commandBuffer,
     *     VkBool32                                    stencilTestEnable);
* *
Description
* *

This command sets the stencil test enable for subsequent drawing commands when the graphics pipeline is created with {@link #VK_DYNAMIC_STATE_STENCIL_TEST_ENABLE_EXT DYNAMIC_STATE_STENCIL_TEST_ENABLE_EXT} set in {@link VkPipelineDynamicStateCreateInfo}{@code ::pDynamicStates}. Otherwise, this state is specified by the {@link VkPipelineDepthStencilStateCreateInfo}{@code ::stencilTestEnable} value used to create the currently active pipeline.

* *
Valid Usage
* * * *
Valid Usage (Implicit)
* *
    *
  • {@code commandBuffer} must be a valid {@code VkCommandBuffer} handle
  • *
  • {@code commandBuffer} must be in the recording state
  • *
  • The {@code VkCommandPool} that {@code commandBuffer} was allocated from must support graphics operations
  • *
* *
Host Synchronization
* *
    *
  • Host access to {@code commandBuffer} must be externally synchronized
  • *
  • Host access to the {@code VkCommandPool} that {@code commandBuffer} was allocated from must be externally synchronized
  • *
* *
Command Properties
* * * * *
Command Buffer LevelsRender Pass ScopeSupported Queue Types
Primary SecondaryBothGraphics
* * @param commandBuffer the command buffer into which the command will be recorded. * @param stencilTestEnable specifies if the stencil test is enabled. */ public static void vkCmdSetStencilTestEnableEXT(VkCommandBuffer commandBuffer, @NativeType("VkBool32") boolean stencilTestEnable) { long __functionAddress = commandBuffer.getCapabilities().vkCmdSetStencilTestEnableEXT; if (CHECKS) { check(__functionAddress); } callPV(commandBuffer.address(), stencilTestEnable ? 1 : 0, __functionAddress); } // --- [ vkCmdSetStencilOpEXT ] --- /** * Set stencil operation dynamically for a command buffer. * *
C Specification
* *

To dynamically set the stencil operation, call:

* *

     * void vkCmdSetStencilOpEXT(
     *     VkCommandBuffer                             commandBuffer,
     *     VkStencilFaceFlags                          faceMask,
     *     VkStencilOp                                 failOp,
     *     VkStencilOp                                 passOp,
     *     VkStencilOp                                 depthFailOp,
     *     VkCompareOp                                 compareOp);
* *
Description
* *

This command sets the stencil operation for subsequent drawing commands when the graphics pipeline is created with {@link #VK_DYNAMIC_STATE_STENCIL_OP_EXT DYNAMIC_STATE_STENCIL_OP_EXT} set in {@link VkPipelineDynamicStateCreateInfo}{@code ::pDynamicStates}. Otherwise, this state is specified by the corresponding {@link VkPipelineDepthStencilStateCreateInfo}{@code ::failOp}, {@code passOp}, {@code depthFailOp}, and {@code compareOp} values used to create the currently active pipeline, for both front and back faces.

* *
Valid Usage
* * * *
Valid Usage (Implicit)
* *
    *
  • {@code commandBuffer} must be a valid {@code VkCommandBuffer} handle
  • *
  • {@code faceMask} must be a valid combination of {@code VkStencilFaceFlagBits} values
  • *
  • {@code faceMask} must not be 0
  • *
  • {@code failOp} must be a valid {@code VkStencilOp} value
  • *
  • {@code passOp} must be a valid {@code VkStencilOp} value
  • *
  • {@code depthFailOp} must be a valid {@code VkStencilOp} value
  • *
  • {@code compareOp} must be a valid {@code VkCompareOp} value
  • *
  • {@code commandBuffer} must be in the recording state
  • *
  • The {@code VkCommandPool} that {@code commandBuffer} was allocated from must support graphics operations
  • *
* *
Host Synchronization
* *
    *
  • Host access to {@code commandBuffer} must be externally synchronized
  • *
  • Host access to the {@code VkCommandPool} that {@code commandBuffer} was allocated from must be externally synchronized
  • *
* *
Command Properties
* * * * *
Command Buffer LevelsRender Pass ScopeSupported Queue Types
Primary SecondaryBothGraphics
* * @param commandBuffer the command buffer into which the command will be recorded. * @param faceMask a bitmask of {@code VkStencilFaceFlagBits} specifying the set of stencil state for which to update the stencil operation. * @param failOp a {@code VkStencilOp} value specifying the action performed on samples that fail the stencil test. * @param passOp a {@code VkStencilOp} value specifying the action performed on samples that pass both the depth and stencil tests. * @param depthFailOp a {@code VkStencilOp} value specifying the action performed on samples that pass the stencil test and fail the depth test. * @param compareOp a {@code VkCompareOp} value specifying the comparison operator used in the stencil test. */ public static void vkCmdSetStencilOpEXT(VkCommandBuffer commandBuffer, @NativeType("VkStencilFaceFlags") int faceMask, @NativeType("VkStencilOp") int failOp, @NativeType("VkStencilOp") int passOp, @NativeType("VkStencilOp") int depthFailOp, @NativeType("VkCompareOp") int compareOp) { long __functionAddress = commandBuffer.getCapabilities().vkCmdSetStencilOpEXT; if (CHECKS) { check(__functionAddress); } callPV(commandBuffer.address(), faceMask, failOp, passOp, depthFailOp, compareOp, __functionAddress); } /** Array version of: {@link #vkCmdBindVertexBuffers2EXT CmdBindVertexBuffers2EXT} */ public static void vkCmdBindVertexBuffers2EXT(VkCommandBuffer commandBuffer, @NativeType("uint32_t") int firstBinding, @NativeType("VkBuffer const *") long[] pBuffers, @NativeType("VkDeviceSize const *") long[] pOffsets, @Nullable @NativeType("VkDeviceSize const *") long[] pSizes, @Nullable @NativeType("VkDeviceSize const *") long[] pStrides) { long __functionAddress = commandBuffer.getCapabilities().vkCmdBindVertexBuffers2EXT; if (CHECKS) { check(__functionAddress); check(pOffsets, pBuffers.length); checkSafe(pSizes, pBuffers.length); checkSafe(pStrides, pBuffers.length); } callPPPPPV(commandBuffer.address(), firstBinding, pBuffers.length, pBuffers, pOffsets, pSizes, pStrides, __functionAddress); } }




© 2015 - 2024 Weber Informatics LLC | Privacy Policy