Class GL44C

    • Method Detail

      • nglBufferStorage

        public static void nglBufferStorage​(int target,
                                            long size,
                                            long data,
                                            int flags)
        Unsafe version of: BufferStorage
        Parameters:
        size - the size of the data store in basic machine units
      • glBufferStorage

        public static void glBufferStorage​(int target,
                                           long size,
                                           int flags)
        Creates the data store of a buffer object.

        The data store of the buffer object bound to target is allocated as a result of a call to this function and cannot be de-allocated until the buffer is deleted with a call to DeleteBuffers. Such a store may not be re-allocated through further calls to BufferStorage or BufferData.

        BufferStorage deletes any existing data store. If any portion of the buffer object is mapped in the current context or any context current to another thread, it is as though UnmapBuffer is executed in each such context prior to deleting the existing data store.

        Parameters:
        target - the buffer object target. One of:
        ARRAY_BUFFERELEMENT_ARRAY_BUFFERPIXEL_PACK_BUFFERPIXEL_UNPACK_BUFFER
        TRANSFORM_FEEDBACK_BUFFERUNIFORM_BUFFERTEXTURE_BUFFERCOPY_READ_BUFFER
        COPY_WRITE_BUFFERDRAW_INDIRECT_BUFFERATOMIC_COUNTER_BUFFERDISPATCH_INDIRECT_BUFFER
        SHADER_STORAGE_BUFFERPARAMETER_BUFFER_ARB
        size - the size of the data store in basic machine units
        flags - the bitwise OR of flags describing the intended usage of the buffer object's data store by the application. Valid flags and their meanings are as follows:
        • DYNAMIC_STORAGE_BIT – The contents of the data store may be updated after creation through calls to BufferSubData. If this bit is not set, the buffer content may not be directly updated by the client. The data argument may be used to specify the initial content of the buffer's data store regardless of the presence of the DYNAMIC_STORAGE_BIT. Regardless of the presence of this bit, buffers may always be updated with server-side calls such as CopyBufferSubData and ClearBufferSubData.
        • MAP_READ_BIT – The buffer's data store may be mapped by the client for read access and a pointer in the client's address space obtained that may be read from.
        • MAP_WRITE_BIT – The buffer's data store may be mapped by the client for write access and a pointer in the client's address space obtained that may be written to.
        • MAP_PERSISTENT_BIT – The client may request that the server read from or write to the buffer while it is mapped. The client's pointer to the data store remains valid so long as the data store is mapped, even during execution of drawing or dispatch commands.
        • MAP_COHERENT_BIT – Shared access to buffers that are simultaneously mapped for client access and are used by the server will be coherent, so long as that mapping is performed using MapBufferRange. That is, data written to the store by either the client or server will be immediately visible to the other with no further action taken by the application. In particular:
        • CLIENT_STORAGE_BIT – When all other criteria for the buffer storage allocation are met, this bit may be used by an implementation to determine whether to use storage that is local to the server or to the client to serve as the backing store for the buffer.

        If flags contains MAP_PERSISTENT_BIT, it must also contain at least one of MAP_READ_BIT or MAP_WRITE_BIT.

        It is an error to specify MAP_COHERENT_BIT without also specifying MAP_PERSISTENT_BIT.

        See Also:
        Reference Page
      • glBufferStorage

        public static void glBufferStorage​(int target,
                                           java.nio.ByteBuffer data,
                                           int flags)
        
        public static void glBufferStorage​(int target,
                                           java.nio.ShortBuffer data,
                                           int flags)
        
        public static void glBufferStorage​(int target,
                                           java.nio.IntBuffer data,
                                           int flags)
        
        public static void glBufferStorage​(int target,
                                           java.nio.FloatBuffer data,
                                           int flags)
        
        public static void glBufferStorage​(int target,
                                           java.nio.DoubleBuffer data,
                                           int flags)
        
        Creates the data store of a buffer object.

        The data store of the buffer object bound to target is allocated as a result of a call to this function and cannot be de-allocated until the buffer is deleted with a call to DeleteBuffers. Such a store may not be re-allocated through further calls to BufferStorage or BufferData.

        BufferStorage deletes any existing data store. If any portion of the buffer object is mapped in the current context or any context current to another thread, it is as though UnmapBuffer is executed in each such context prior to deleting the existing data store.

        Parameters:
        target - the buffer object target. One of:
        ARRAY_BUFFERELEMENT_ARRAY_BUFFERPIXEL_PACK_BUFFERPIXEL_UNPACK_BUFFER
        TRANSFORM_FEEDBACK_BUFFERUNIFORM_BUFFERTEXTURE_BUFFERCOPY_READ_BUFFER
        COPY_WRITE_BUFFERDRAW_INDIRECT_BUFFERATOMIC_COUNTER_BUFFERDISPATCH_INDIRECT_BUFFER
        SHADER_STORAGE_BUFFERPARAMETER_BUFFER_ARB
        data - the address in client memory of the data that should be used to initialize the buffer's data store. If data is NULL, the data store of the buffer is created, but contains undefined data. Otherwise, data should point to an array of at least size basic machine units.
        flags - the bitwise OR of flags describing the intended usage of the buffer object's data store by the application. Valid flags and their meanings are as follows:
        • DYNAMIC_STORAGE_BIT – The contents of the data store may be updated after creation through calls to BufferSubData. If this bit is not set, the buffer content may not be directly updated by the client. The data argument may be used to specify the initial content of the buffer's data store regardless of the presence of the DYNAMIC_STORAGE_BIT. Regardless of the presence of this bit, buffers may always be updated with server-side calls such as CopyBufferSubData and ClearBufferSubData.
        • MAP_READ_BIT – The buffer's data store may be mapped by the client for read access and a pointer in the client's address space obtained that may be read from.
        • MAP_WRITE_BIT – The buffer's data store may be mapped by the client for write access and a pointer in the client's address space obtained that may be written to.
        • MAP_PERSISTENT_BIT – The client may request that the server read from or write to the buffer while it is mapped. The client's pointer to the data store remains valid so long as the data store is mapped, even during execution of drawing or dispatch commands.
        • MAP_COHERENT_BIT – Shared access to buffers that are simultaneously mapped for client access and are used by the server will be coherent, so long as that mapping is performed using MapBufferRange. That is, data written to the store by either the client or server will be immediately visible to the other with no further action taken by the application. In particular:
        • CLIENT_STORAGE_BIT – When all other criteria for the buffer storage allocation are met, this bit may be used by an implementation to determine whether to use storage that is local to the server or to the client to serve as the backing store for the buffer.

        If flags contains MAP_PERSISTENT_BIT, it must also contain at least one of MAP_READ_BIT or MAP_WRITE_BIT.

        It is an error to specify MAP_COHERENT_BIT without also specifying MAP_PERSISTENT_BIT.

        See Also:
        Reference Page
      • nglClearTexSubImage

        public static void nglClearTexSubImage​(int texture,
                                               int level,
                                               int xoffset,
                                               int yoffset,
                                               int zoffset,
                                               int width,
                                               int height,
                                               int depth,
                                               int format,
                                               int type,
                                               long data)
        Unsafe version of: ClearTexSubImage
      • glClearTexSubImage

        public static void glClearTexSubImage​(int texture,
                                              int level,
                                              int xoffset,
                                              int yoffset,
                                              int zoffset,
                                              int width,
                                              int height,
                                              int depth,
                                              int format,
                                              int type,
                                              @Nullable
                                              java.nio.ByteBuffer data)
        
        public static void glClearTexSubImage​(int texture,
                                              int level,
                                              int xoffset,
                                              int yoffset,
                                              int zoffset,
                                              int width,
                                              int height,
                                              int depth,
                                              int format,
                                              int type,
                                              @Nullable
                                              java.nio.ShortBuffer data)
        
        public static void glClearTexSubImage​(int texture,
                                              int level,
                                              int xoffset,
                                              int yoffset,
                                              int zoffset,
                                              int width,
                                              int height,
                                              int depth,
                                              int format,
                                              int type,
                                              @Nullable
                                              java.nio.IntBuffer data)
        
        public static void glClearTexSubImage​(int texture,
                                              int level,
                                              int xoffset,
                                              int yoffset,
                                              int zoffset,
                                              int width,
                                              int height,
                                              int depth,
                                              int format,
                                              int type,
                                              @Nullable
                                              java.nio.FloatBuffer data)
        
        public static void glClearTexSubImage​(int texture,
                                              int level,
                                              int xoffset,
                                              int yoffset,
                                              int zoffset,
                                              int width,
                                              int height,
                                              int depth,
                                              int format,
                                              int type,
                                              @Nullable
                                              java.nio.DoubleBuffer data)
        
        Fills all or part of a texture image with a constant value.

        Arguments xoffset, yoffset, and zoffset specify the lower left texel coordinates of a width-wide by height-high by depth-deep rectangular subregion of the texel array and are interpreted as they are in TexSubImage3D.

        For 1D array textures, yoffset is interpreted as the first layer to be cleared and height is the number of layers to clear. For 2D array textures, zoffset is interpreted as the first layer to be cleared and depth is the number of layers to clear. Cube map textures are treated as an array of six slices in the z-dimension, where the value of zoffset is interpreted as specifying the cube map face for the corresponding layer and depth is the number of faces to clear. For cube map array textures, zoffset is the first layer-face to clear, and depth is the number of layer-faces to clear. Each layer-face is translated into an array layer and a cube map face.

        Negative values of xoffset, yoffset, and zoffset correspond to the coordinates of border texels.

        Parameters:
        texture - the texture to clear. It is an error if texture is zero or not the name of a texture object, if texture is a buffer texture, or if the texture image has a compressed internal format
        level - the texture level to clear
        xoffset - the x coordinate of the texel subregion
        yoffset - the y coordinate of the texel subregion
        zoffset - the z coordinate of the texel subregion
        width - the subregion width
        height - the subregion height
        depth - the subregion depth
        format - the format of the source data. One of:
        REDGREENBLUEALPHARGRGBRGBABGR
        BGRARED_INTEGERGREEN_INTEGERBLUE_INTEGERALPHA_INTEGERRG_INTEGERRGB_INTEGERRGBA_INTEGER
        BGR_INTEGERBGRA_INTEGERSTENCIL_INDEXDEPTH_COMPONENTDEPTH_STENCILLUMINANCELUMINANCE_ALPHA
        type - the type of the source data. One of:
        UNSIGNED_BYTEBYTEUNSIGNED_SHORTSHORT
        UNSIGNED_INTINTHALF_FLOATFLOAT
        UNSIGNED_BYTE_3_3_2UNSIGNED_BYTE_2_3_3_REVUNSIGNED_SHORT_5_6_5UNSIGNED_SHORT_5_6_5_REV
        UNSIGNED_SHORT_4_4_4_4UNSIGNED_SHORT_4_4_4_4_REVUNSIGNED_SHORT_5_5_5_1UNSIGNED_SHORT_1_5_5_5_REV
        UNSIGNED_INT_8_8_8_8UNSIGNED_INT_8_8_8_8_REVUNSIGNED_INT_10_10_10_2UNSIGNED_INT_2_10_10_10_REV
        UNSIGNED_INT_24_8UNSIGNED_INT_10F_11F_11F_REVUNSIGNED_INT_5_9_9_9_REVFLOAT_32_UNSIGNED_INT_24_8_REV
        BITMAP
        data - an array of between one and four components of texel data that will be used as the source for the constant fill value. If data is NULL, then the pointer is ignored and the sub-range of the texture image is filled with zeros.
        See Also:
        Reference Page
      • nglClearTexImage

        public static void nglClearTexImage​(int texture,
                                            int level,
                                            int format,
                                            int type,
                                            long data)
        Unsafe version of: ClearTexImage
      • nglBindBuffersBase

        public static void nglBindBuffersBase​(int target,
                                              int first,
                                              int count,
                                              long buffers)
        Unsafe version of: BindBuffersBase
        Parameters:
        count - the number of bindings
      • nglBindBuffersRange

        public static void nglBindBuffersRange​(int target,
                                               int first,
                                               int count,
                                               long buffers,
                                               long offsets,
                                               long sizes)
        Unsafe version of: BindBuffersRange
        Parameters:
        count - the number of bindings
      • glBindBuffersRange

        public static void glBindBuffersRange​(int target,
                                              int first,
                                              @Nullable
                                              java.nio.IntBuffer buffers,
                                              @Nullable
                                              PointerBuffer offsets,
                                              @Nullable
                                              PointerBuffer sizes)
        Binds count existing buffer objects to bindings numbered first through first+count-1 in the array of buffer binding points corresponding to target. offsets and sizes specify arrays of count values indicating the range of each buffer to bind. If buffers is NULL, all bindings from first through first+count-1 are reset to their unbound (zero) state. In this case, the offsets and sizes associated with the binding points are set to default values, ignoring offsets and sizes. It is equivalent to:
        
         for ( i = 0; i < count; i++ ) {
             if ( buffers == NULL ) {
                 glBindBufferRange(target, first + i, 0, 0, 0);
             } else {
                 glBindBufferRange(target, first + i, buffers[i], offsets[i], sizes[i]);
             }
         }

        except that the single general buffer binding corresponding to target is unmodified, and that buffers will not be created if they do not exist.

        The values specified in buffers, offsets, and sizes will be checked separately for each binding point. When values for a specific binding point are invalid, the state for that binding point will be unchanged and an error will be generated. However, state for other binding points will still be changed if their corresponding values are valid.

        Parameters:
        target - the buffer object target. One of:
        ARRAY_BUFFERELEMENT_ARRAY_BUFFERPIXEL_PACK_BUFFERPIXEL_UNPACK_BUFFER
        TRANSFORM_FEEDBACK_BUFFERUNIFORM_BUFFERTEXTURE_BUFFERCOPY_READ_BUFFER
        COPY_WRITE_BUFFERDRAW_INDIRECT_BUFFERATOMIC_COUNTER_BUFFERDISPATCH_INDIRECT_BUFFER
        SHADER_STORAGE_BUFFERPARAMETER_BUFFER_ARB
        first - the first binding
        buffers - an array of names of existing buffers objects
        offsets - an array of offsets
        sizes - an array of sizes
        See Also:
        Reference Page
      • nglBindTextures

        public static void nglBindTextures​(int first,
                                           int count,
                                           long textures)
        Unsafe version of: BindTextures
        Parameters:
        count - the number of texture objects
      • glBindTextures

        public static void glBindTextures​(int first,
                                          @Nullable
                                          java.nio.IntBuffer textures)
        Binds count existing texture objects to texture image units numbered first through first+count-1. If textures is not NULL, it specifies an array of count values, each of which must be zero or the name of an existing texture object. When an entry in textures is the name of an existing texture object, that object is bound to corresponding texture unit for the target specified when the texture object was created. When an entry in textures is zero, each of the targets enumerated at the beginning of this section is reset to its default texture for the corresponding texture image unit. If textures is NULL, each target of each affected texture image unit from first through first+count-1 is reset to its default texture.

        BindTextures is equivalent to:

        
         for ( i = 0; i < count; i++ ) {
             uint texture;
             if ( textures == NULL ) {
                 texture = 0;
             } else {
                 texture = textures[i];
             }
             ActiveTexture(TEXTURE0 + first + i);
             if ( texture != 0 ) {
                 enum target; // target of texture object textures[i]
                 BindTexture(target, textures[i]);
             } else {
                 for ( target in all supported targets ) {
                     BindTexture(target, 0);
                 }
             }
         }

        except that the active texture selector retains its original value upon completion of the command, and that textures will not be created if they do not exist.

        The values specified in textures will be checked separately for each texture image unit. When a value for a specific texture image unit is invalid, the state for that texture image unit will be unchanged and an error will be generated. However, state for other texture image units will still be changed if their corresponding values are valid.

        Parameters:
        first - the first texture objects
        textures - an array of zeros or names of existing texture objects
        See Also:
        Reference Page
      • nglBindSamplers

        public static void nglBindSamplers​(int first,
                                           int count,
                                           long samplers)
        Unsafe version of: BindSamplers
        Parameters:
        count - the number of sampler objects
      • glBindSamplers

        public static void glBindSamplers​(int first,
                                          @Nullable
                                          java.nio.IntBuffer samplers)
        Binds count existing sampler objects to texture image units numbered first through first+count-1. If samplers is not NULL, it specifies an array of count values, each of which must be zero or the name of an existing sampler object. If samplers is NULL, each affected texture image unit from first through first+count-1 will be reset to have no bound sampler object.

        BindSamplers is equivalent to:

        
         for ( i = 0; i < count; i++ ) {
             if ( samplers == NULL ) {
                 glBindSampler(first + i, 0);
             } else {
                 glBindSampler(first + i, samplers[i]);
             }
         }

        The values specified in samplers will be checked separately for each texture image unit. When a value for a specific texture image unit is invalid, the state for that texture image unit will be unchanged and an error will be generated. However, state for other texture image units will still be changed if their corresponding values are valid.

        Parameters:
        first - the first sampler object
        samplers - an array of zeros or names of existing sampler objects
        See Also:
        Reference Page
      • nglBindImageTextures

        public static void nglBindImageTextures​(int first,
                                                int count,
                                                long textures)
        Unsafe version of: BindImageTextures
        Parameters:
        count - the number of image units
      • glBindImageTextures

        public static void glBindImageTextures​(int first,
                                               @Nullable
                                               java.nio.IntBuffer textures)
        Binds count existing texture objects to image units numbered first through first+count-1. If textures is not NULL, it specifies an array of count values, each of which must be zero or the name of an existing texture object. If textures is NULL, each affected image unit from first through first+count-1 will be reset to have no bound texture object.

        When binding a non-zero texture object to an image unit, the image unit level, layered, layer, and access parameters are set to zero, TRUE, zero, and READ_WRITE, respectively. The image unit format parameter is taken from the internal format of the texture image at level zero of the texture object identified by textures. For cube map textures, the internal format of the TEXTURE_CUBE_MAP_POSITIVE_X image of level zero is used. For multisample, multisample array, buffer, and rectangle textures, the internal format of the single texture level is used.

        When unbinding a texture object from an image unit, the image unit parameters level, layered, layer, and format will be reset to their default values of zero, FALSE, 0, and R8, respectively.

        BindImageTextures is equivalent to:

        
         for ( i = 0; i < count; i++ ) {
             if ( textures == NULL || textures[i] = 0 ) {
                 glBindImageTexture(first + i, 0, 0, FALSE, 0, READ_ONLY, R8);
             } else {
                 glBindImageTexture(first + i, textures[i], 0, TRUE, 0, READ_WRITE, lookupInternalFormat(textures[i]));
             }
         }

        where lookupInternalFormat returns the internal format of the specified texture object.

        The values specified in textures will be checked separately for each image unit. When a value for a specific image unit is invalid, the state for that image unit will be unchanged and an error will be generated. However, state for other image units will still be changed if their corresponding values are valid.

        Parameters:
        first - the first image unit
        textures - an array of zeros or names of existing texture objects
        See Also:
        Reference Page
      • nglBindVertexBuffers

        public static void nglBindVertexBuffers​(int first,
                                                int count,
                                                long buffers,
                                                long offsets,
                                                long strides)
        Unsafe version of: BindVertexBuffers
        Parameters:
        count - the number of vertex buffer binding points
      • glBindVertexBuffers

        public static void glBindVertexBuffers​(int first,
                                               @Nullable
                                               java.nio.IntBuffer buffers,
                                               @Nullable
                                               PointerBuffer offsets,
                                               @Nullable
                                               java.nio.IntBuffer strides)
        Binds count existing buffer objects to vertex buffer binding points numbered first through first+count-1. If buffers is not NULL, it specifies an array of count values, each of which must be zero or the name of an existing buffer object. offsets and strides specify arrays of count values indicating the offset of the first element and stride between elements in each buffer, respectively. If buffers is NULL, each affected vertex buffer binding point from first through first+count-1 will be reset to have no bound buffer object. In this case, the offsets and strides associated with the binding points are set to default values, ignoring offsets and strides.

        BindVertexBuffers is equivalent to:

        
         for ( i = 0; i < count; i++ ) {
             if ( buffers == NULL ) {
                 glBindVertexBuffer(first + i, 0, 0, 16);
             } else {
                 glBindVertexBuffer(first + i, buffers[i], offsets[i], strides[i]);
             }
         }

        except that buffers will not be created if they do not exist.

        The values specified in buffers, offsets, and strides will be checked separately for each vertex buffer binding point. When a value for a specific binding point is invalid, the state for that binding point will be unchanged and an error will be generated. However, state for other binding points will still be changed if their corresponding values are valid.

        Parameters:
        first - the first vertex buffer binding point
        buffers - an array of zeros or names of existing buffers objects
        offsets - an array of offses
        strides - an array of stride values
        See Also:
        Reference Page
      • glBufferStorage

        public static void glBufferStorage​(int target,
                                           short[] data,
                                           int flags)
        
        public static void glBufferStorage​(int target,
                                           int[] data,
                                           int flags)
        
        public static void glBufferStorage​(int target,
                                           float[] data,
                                           int flags)
        
        public static void glBufferStorage​(int target,
                                           double[] data,
                                           int flags)
        
        Array version of: BufferStorage
        See Also:
        Reference Page
      • glClearTexSubImage

        public static void glClearTexSubImage​(int texture,
                                              int level,
                                              int xoffset,
                                              int yoffset,
                                              int zoffset,
                                              int width,
                                              int height,
                                              int depth,
                                              int format,
                                              int type,
                                              @Nullable
                                              short[] data)
        
        public static void glClearTexSubImage​(int texture,
                                              int level,
                                              int xoffset,
                                              int yoffset,
                                              int zoffset,
                                              int width,
                                              int height,
                                              int depth,
                                              int format,
                                              int type,
                                              @Nullable
                                              int[] data)
        
        public static void glClearTexSubImage​(int texture,
                                              int level,
                                              int xoffset,
                                              int yoffset,
                                              int zoffset,
                                              int width,
                                              int height,
                                              int depth,
                                              int format,
                                              int type,
                                              @Nullable
                                              float[] data)
        
        public static void glClearTexSubImage​(int texture,
                                              int level,
                                              int xoffset,
                                              int yoffset,
                                              int zoffset,
                                              int width,
                                              int height,
                                              int depth,
                                              int format,
                                              int type,
                                              @Nullable
                                              double[] data)
        
        Array version of: ClearTexSubImage
        See Also:
        Reference Page
      • glClearTexImage

        public static void glClearTexImage​(int texture,
                                           int level,
                                           int format,
                                           int type,
                                           @Nullable
                                           short[] data)
        
        public static void glClearTexImage​(int texture,
                                           int level,
                                           int format,
                                           int type,
                                           @Nullable
                                           int[] data)
        
        public static void glClearTexImage​(int texture,
                                           int level,
                                           int format,
                                           int type,
                                           @Nullable
                                           float[] data)
        
        public static void glClearTexImage​(int texture,
                                           int level,
                                           int format,
                                           int type,
                                           @Nullable
                                           double[] data)
        
        Array version of: ClearTexImage
        See Also:
        Reference Page
      • glBindBuffersBase

        public static void glBindBuffersBase​(int target,
                                             int first,
                                             @Nullable
                                             int[] buffers)
        Array version of: BindBuffersBase
        See Also:
        Reference Page
      • glBindTextures

        public static void glBindTextures​(int first,
                                          @Nullable
                                          int[] textures)
        Array version of: BindTextures
        See Also:
        Reference Page
      • glBindSamplers

        public static void glBindSamplers​(int first,
                                          @Nullable
                                          int[] samplers)
        Array version of: BindSamplers
        See Also:
        Reference Page
      • glBindImageTextures

        public static void glBindImageTextures​(int first,
                                               @Nullable
                                               int[] textures)
        Array version of: BindImageTextures
        See Also:
        Reference Page
      • glBindVertexBuffers

        public static void glBindVertexBuffers​(int first,
                                               @Nullable
                                               int[] buffers,
                                               @Nullable
                                               PointerBuffer offsets,
                                               @Nullable
                                               int[] strides)
        Array version of: BindVertexBuffers
        See Also:
        Reference Page