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

Go to download
Show more of this group Show more artifacts with this name
Show all versions of lwjgl-vulkan Show documentation
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 java.nio.*;

import org.lwjgl.*;
import org.lwjgl.system.*;

import static org.lwjgl.system.MemoryUtil.*;
import static org.lwjgl.system.MemoryStack.*;

/**
 * Structure containing a rectangle, including layer, changed by vkQueuePresentKHR for a given VkImage.
 * 
 * Valid Usage
 * 
 * 
 * The sum of {@code offset} and {@code extent} must be no greater than the {@code imageExtent} member of the {@link VkSwapchainCreateInfoKHR} structure given to {@link KHRSwapchain#vkCreateSwapchainKHR CreateSwapchainKHR}.
 * {@code layer} must be less than {@code imageArrayLayers} member of the {@link VkSwapchainCreateInfoKHR} structure given to {@link KHRSwapchain#vkCreateSwapchainKHR CreateSwapchainKHR}.
 * 
 * 
 * Some platforms allow the size of a surface to change, and then scale the pixels of the image to fit the surface. VkRectLayerKHR specifies pixels of the swapchain's image(s), which will be constant for the life of the swapchain.
 * 
 * See Also
 * 
 * {@link VkExtent2D}, {@link VkOffset2D}, {@link VkPresentRegionKHR}
 * 
 * Member documentation
 * 
 * 
 * {@code offset} – the origin of the rectangle, in pixels.
 * {@code extent} – the size of the rectangle, in pixels.
 * {@code layer} – the layer of the image. For images with only one layer, the value of {@code layer} must be 0.
 * 
 * 
 * Layout
 * 
 *  * struct VkRectLayerKHR {
 *     {@link VkOffset2D VkOffset2D} offset;
 *     {@link VkExtent2D VkExtent2D} extent;
 *     uint32_t layer;
 * }
 */
public class VkRectLayerKHR extends Struct implements NativeResource {

    /** The struct size in bytes. */
    public static final int SIZEOF;

    public static final int ALIGNOF;

    /** The struct member offsets. */
    public static final int
        OFFSET,
        EXTENT,
        LAYER;

    static {
        Layout layout = __struct(
            __member(VkOffset2D.SIZEOF, VkOffset2D.ALIGNOF),
            __member(VkExtent2D.SIZEOF, VkExtent2D.ALIGNOF),
            __member(4)
        );

        SIZEOF = layout.getSize();
        ALIGNOF = layout.getAlignment();

        OFFSET = layout.offsetof(0);
        EXTENT = layout.offsetof(1);
        LAYER = layout.offsetof(2);
    }

    VkRectLayerKHR(long address, ByteBuffer container) {
        super(address, container);
    }

    /**
     * Creates a {@link VkRectLayerKHR} instance at the current position of the specified {@link ByteBuffer} container. Changes to the buffer's content will be
     * visible to the struct instance and vice versa.
     *
     * The created instance holds a strong reference to the container object.
     */
    public VkRectLayerKHR(ByteBuffer container) {
        this(memAddress(container), checkContainer(container, SIZEOF));
    }

    @Override
    public int sizeof() { return SIZEOF; }

    /** Returns a {@link VkOffset2D} view of the {@code offset} field. */
    public VkOffset2D offset() { return noffset(address()); }
    /** Returns a {@link VkExtent2D} view of the {@code extent} field. */
    public VkExtent2D extent() { return nextent(address()); }
    /** Returns the value of the {@code layer} field. */
    @NativeType("uint32_t")
    public int layer() { return nlayer(address()); }

    /** Copies the specified {@link VkOffset2D} to the {@code offset} field. */
    public VkRectLayerKHR offset(VkOffset2D value) { noffset(address(), value); return this; }
    /** Copies the specified {@link VkExtent2D} to the {@code extent} field. */
    public VkRectLayerKHR extent(VkExtent2D value) { nextent(address(), value); return this; }
    /** Sets the specified value to the {@code layer} field. */
    public VkRectLayerKHR layer(@NativeType("uint32_t") int value) { nlayer(address(), value); return this; }

    /** Initializes this struct with the specified values. */
    public VkRectLayerKHR set(
        VkOffset2D offset,
        VkExtent2D extent,
        int layer
    ) {
        offset(offset);
        extent(extent);
        layer(layer);

        return this;
    }

    /**
     * Copies the specified struct data to this struct.
     *
     * @param src the source struct
     *
     * @return this struct
     */
    public VkRectLayerKHR set(VkRectLayerKHR src) {
        memCopy(src.address(), address(), SIZEOF);
        return this;
    }

    // -----------------------------------

    /** Returns a new {@link VkRectLayerKHR} instance allocated with {@link MemoryUtil#memAlloc memAlloc}. The instance must be explicitly freed. */
    public static VkRectLayerKHR malloc() {
        return create(nmemAlloc(SIZEOF));
    }

    /** Returns a new {@link VkRectLayerKHR} instance allocated with {@link MemoryUtil#memCalloc memCalloc}. The instance must be explicitly freed. */
    public static VkRectLayerKHR calloc() {
        return create(nmemCalloc(1, SIZEOF));
    }

    /** Returns a new {@link VkRectLayerKHR} instance allocated with {@link BufferUtils}. */
    public static VkRectLayerKHR create() {
        return new VkRectLayerKHR(BufferUtils.createByteBuffer(SIZEOF));
    }

    /** Returns a new {@link VkRectLayerKHR} instance for the specified memory address or {@code null} if the address is {@code NULL}. */
    public static VkRectLayerKHR create(long address) {
        return address == NULL ? null : new VkRectLayerKHR(address, null);
    }

    /**
     * Returns a new {@link VkRectLayerKHR.Buffer} instance allocated with {@link MemoryUtil#memAlloc memAlloc}. The instance must be explicitly freed.
     *
     * @param capacity the buffer capacity
     */
    public static Buffer malloc(int capacity) {
        return create(__malloc(capacity, SIZEOF), capacity);
    }

    /**
     * Returns a new {@link VkRectLayerKHR.Buffer} instance allocated with {@link MemoryUtil#memCalloc memCalloc}. The instance must be explicitly freed.
     *
     * @param capacity the buffer capacity
     */
    public static Buffer calloc(int capacity) {
        return create(nmemCalloc(capacity, SIZEOF), capacity);
    }

    /**
     * Returns a new {@link VkRectLayerKHR.Buffer} instance allocated with {@link BufferUtils}.
     *
     * @param capacity the buffer capacity
     */
    public static Buffer create(int capacity) {
        return new Buffer(__create(capacity, SIZEOF));
    }

    /**
     * Create a {@link VkRectLayerKHR.Buffer} instance at the specified memory.
     *
     * @param address  the memory address
     * @param capacity the buffer capacity
     */
    public static Buffer create(long address, int capacity) {
        return address == NULL ? null : new Buffer(address, null, -1, 0, capacity, capacity);
    }

    // -----------------------------------

    /** Returns a new {@link VkRectLayerKHR} instance allocated on the thread-local {@link MemoryStack}. */
    public static VkRectLayerKHR mallocStack() {
        return mallocStack(stackGet());
    }

    /** Returns a new {@link VkRectLayerKHR} instance allocated on the thread-local {@link MemoryStack} and initializes all its bits to zero. */
    public static VkRectLayerKHR callocStack() {
        return callocStack(stackGet());
    }

    /**
     * Returns a new {@link VkRectLayerKHR} instance allocated on the specified {@link MemoryStack}.
     *
     * @param stack the stack from which to allocate
     */
    public static VkRectLayerKHR mallocStack(MemoryStack stack) {
        return create(stack.nmalloc(ALIGNOF, SIZEOF));
    }

    /**
     * Returns a new {@link VkRectLayerKHR} instance allocated on the specified {@link MemoryStack} and initializes all its bits to zero.
     *
     * @param stack the stack from which to allocate
     */
    public static VkRectLayerKHR callocStack(MemoryStack stack) {
        return create(stack.ncalloc(ALIGNOF, 1, SIZEOF));
    }

    /**
     * Returns a new {@link VkRectLayerKHR.Buffer} instance allocated on the thread-local {@link MemoryStack}.
     *
     * @param capacity the buffer capacity
     */
    public static Buffer mallocStack(int capacity) {
        return mallocStack(capacity, stackGet());
    }

    /**
     * Returns a new {@link VkRectLayerKHR.Buffer} instance allocated on the thread-local {@link MemoryStack} and initializes all its bits to zero.
     *
     * @param capacity the buffer capacity
     */
    public static Buffer callocStack(int capacity) {
        return callocStack(capacity, stackGet());
    }

    /**
     * Returns a new {@link VkRectLayerKHR.Buffer} instance allocated on the specified {@link MemoryStack}.
     *
     * @param stack the stack from which to allocate
     * @param capacity the buffer capacity
     */
    public static Buffer mallocStack(int capacity, MemoryStack stack) {
        return create(stack.nmalloc(ALIGNOF, capacity * SIZEOF), capacity);
    }

    /**
     * Returns a new {@link VkRectLayerKHR.Buffer} instance allocated on the specified {@link MemoryStack} and initializes all its bits to zero.
     *
     * @param stack the stack from which to allocate
     * @param capacity the buffer capacity
     */
    public static Buffer callocStack(int capacity, MemoryStack stack) {
        return create(stack.ncalloc(ALIGNOF, capacity, SIZEOF), capacity);
    }

    // -----------------------------------

    /** Unsafe version of {@link #offset}. */
    public static VkOffset2D noffset(long struct) { return VkOffset2D.create(struct + VkRectLayerKHR.OFFSET); }
    /** Unsafe version of {@link #extent}. */
    public static VkExtent2D nextent(long struct) { return VkExtent2D.create(struct + VkRectLayerKHR.EXTENT); }
    /** Unsafe version of {@link #layer}. */
    public static int nlayer(long struct) { return memGetInt(struct + VkRectLayerKHR.LAYER); }

    /** Unsafe version of {@link #offset(VkOffset2D) offset}. */
    public static void noffset(long struct, VkOffset2D value) { memCopy(value.address(), struct + VkRectLayerKHR.OFFSET, VkOffset2D.SIZEOF); }
    /** Unsafe version of {@link #extent(VkExtent2D) extent}. */
    public static void nextent(long struct, VkExtent2D value) { memCopy(value.address(), struct + VkRectLayerKHR.EXTENT, VkExtent2D.SIZEOF); }
    /** Unsafe version of {@link #layer(int) layer}. */
    public static void nlayer(long struct, int value) { memPutInt(struct + VkRectLayerKHR.LAYER, value); }

    // -----------------------------------

    /** An array of {@link VkRectLayerKHR} structs. */
    public static class Buffer extends StructBuffer implements NativeResource {

        /**
         * Creates a new {@link VkRectLayerKHR.Buffer} instance backed by the specified container.
         *
         * Changes to the container's content will be visible to the struct buffer instance and vice versa. The two buffers' position, limit, and mark values
         * will be independent. The new buffer's position will be zero, its capacity and its limit will be the number of bytes remaining in this buffer divided
         * by {@link VkRectLayerKHR#SIZEOF}, and its mark will be undefined.
         *
         * The created buffer instance holds a strong reference to the container object.
         */
        public Buffer(ByteBuffer container) {
            super(container, container.remaining() / SIZEOF);
        }

        Buffer(long address, ByteBuffer container, int mark, int pos, int lim, int cap) {
            super(address, container, mark, pos, lim, cap);
        }

        @Override
        protected Buffer self() {
            return this;
        }

        @Override
        protected Buffer newBufferInstance(long address, ByteBuffer container, int mark, int pos, int lim, int cap) {
            return new Buffer(address, container, mark, pos, lim, cap);
        }

        @Override
        protected VkRectLayerKHR newInstance(long address) {
            return new VkRectLayerKHR(address, container);
        }

        @Override
        public int sizeof() {
            return SIZEOF;
        }

        /** Returns a {@link VkOffset2D} view of the {@code offset} field. */
        public VkOffset2D offset() { return VkRectLayerKHR.noffset(address()); }
        /** Returns a {@link VkExtent2D} view of the {@code extent} field. */
        public VkExtent2D extent() { return VkRectLayerKHR.nextent(address()); }
        /** Returns the value of the {@code layer} field. */
        @NativeType("uint32_t")
        public int layer() { return VkRectLayerKHR.nlayer(address()); }

        /** Copies the specified {@link VkOffset2D} to the {@code offset} field. */
        public VkRectLayerKHR.Buffer offset(VkOffset2D value) { VkRectLayerKHR.noffset(address(), value); return this; }
        /** Copies the specified {@link VkExtent2D} to the {@code extent} field. */
        public VkRectLayerKHR.Buffer extent(VkExtent2D value) { VkRectLayerKHR.nextent(address(), value); return this; }
        /** Sets the specified value to the {@code layer} field. */
        public VkRectLayerKHR.Buffer layer(@NativeType("uint32_t") int value) { VkRectLayerKHR.nlayer(address(), value); return this; }

    }

}