stgsharp/StgSharp.Graphics/OpenGL/glFunction.v4_3.cs

// -----------------------------------------------------------------------------
// file="glFunction.v4_3"
// Project: StgSharp
// Copyright (c) Nitload.
// SPDX-License-Identifier: MIT
// -----------------------------------------------------------------------------

using StgSharp.Graphics.OpenGL;
using System;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;

namespace StgSharp.Graphics.OpenGL
{
    public unsafe partial class OpenGLFunction
    {

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void BindVertexBuffer(
                    uint bindingindex,
                    GlHandle buffer,
                    nint offset,
                    int stride
        )
        {
            _context->glBindVertexBuffer(bindingindex, buffer.Value, offset, stride);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void ClearBufferData(
                    uint target,
                    uint internalformat,
                    uint format,
                    ShaderType type,
                    ReadOnlySpan<IntPtr> data
        )
        {
            fixed (IntPtr* dataPtr = data) {
                _context->glClearBufferData(target, internalformat, format, (uint)type, dataPtr);
            }
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void ClearBufferSubData(
                    uint target,
                    uint internalformat,
                    nint offset,
                    nuint size,
                    uint format,
                    ShaderType type,
                    ReadOnlySpan<IntPtr> data
        )
        {
            fixed (IntPtr* dataPtr = data) {
                _context->glClearBufferSubData(target, internalformat, offset, size, format,
                                               (uint)type, dataPtr);
            }
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void CopyImageSubData(
                    uint srcName,
                    uint srcTarget,
                    int srcLevel,
                    int srcX,
                    int srcY,
                    int srcZ,
                    uint dstName,
                    uint dstTarget,
                    int dstLevel,
                    int dstX,
                    int dstY,
                    int dstZ,
                    int srcWidth,
                    int srcHeight,
                    int srcDepth
        )
        {
            _context->glCopyImageSubData(srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName,
                                         dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight,
                                         srcDepth);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void DebugMessageCallback(
                    IntPtr callback,
                    ReadOnlySpan<IntPtr> userParam
        )
        {
            fixed (IntPtr* userParamPtr = userParam) {
                _context->glDebugMessageCallback(callback, userParamPtr);
            }
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void DebugMessageControl(
                    uint source,
                    ShaderType type,
                    uint severity,
                    int count,
                    ReadOnlySpan<uint> ids,
                    byte enabled
        )
        {
            fixed (uint* idsPtr = ids) {
                _context->glDebugMessageControl(source, (uint)type, severity, count, idsPtr,
                                                enabled);
            }
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void DebugMessageInsert(
                    uint source,
                    ShaderType type,
                    uint id,
                    uint severity,
                    int length,
                    ReadOnlySpan<byte> buf
        )
        {
            fixed (byte* bufPtr = buf) {
                _context->glDebugMessageInsert(source, (uint)type, id, severity, length, bufPtr);
            }
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void DispatchCompute(
                    uint num_groups_x,
                    uint num_groups_y,
                    uint num_groups_z
        )
        {
            _context->glDispatchCompute(num_groups_x, num_groups_y, num_groups_z);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void DispatchComputeIndirect(
                    nint indirect
        )
        {
            _context->glDispatchComputeIndirect(indirect);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void FramebufferParameteri(
                    uint target,
                    uint pname,
                    int param
        )
        {
            _context->glFramebufferParameteri(target, pname, param);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public uint GetDebugMessageLog(
                    uint count,
                    int bufSize,
                    uint* sources,
                    uint* types,
                    uint* ids,
                    uint* severities,
                    int* lengths,
                    byte* messageLog
        )
        {
            return _context->glGetDebugMessageLog(count, bufSize, sources, types, ids, severities,
                                                  lengths, messageLog);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void GetFramebufferParameteriv(
                    uint target,
                    uint pname,
                    int* @params
        )
        {
            _context->glGetFramebufferParameteriv(target, pname, @params);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void GetInternalformati64v(
                    uint target,
                    uint internalformat,
                    uint pname,
                    int count,
                    IntPtr* @params
        )
        {
            _context->glGetInternalformati64v(target, internalformat, pname, count, @params);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void GetObjectLabel(
                    uint identifier,
                    uint name,
                    int bufSize,
                    int* length,
                    byte* label
        )
        {
            _context->glGetObjectLabel(identifier, name, bufSize, length, label);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void GetObjectPtrLabel(
                    ReadOnlySpan<IntPtr> ptr,
                    int bufSize,
                    int* length,
                    byte* label
        )
        {
            fixed (IntPtr* ptrPtr = ptr) {
                _context->glGetObjectPtrLabel(ptrPtr, bufSize, length, label);
            }
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void GetProgramInterfaceiv(
                    GlHandle program,
                    uint programInterface,
                    uint pname,
                    int* @params
        )
        {
            _context->glGetProgramInterfaceiv(program.Value, programInterface, pname, @params);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public uint GetProgramResourceIndex(
                    GlHandle program,
                    uint programInterface,
                    ReadOnlySpan<byte> name
        )
        {
            fixed (byte* namePtr = name) {
                return _context->glGetProgramResourceIndex(program.Value, programInterface, namePtr);
            }
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void GetProgramResourceiv(
                    GlHandle program,
                    uint programInterface,
                    uint index,
                    int propCount,
                    ReadOnlySpan<uint> props,
                    int count,
                    int* length,
                    int* @params
        )
        {
            fixed (uint* propsPtr = props) {
                _context->glGetProgramResourceiv(program.Value, programInterface, index, propCount,
                                                 propsPtr, count, length, @params);
            }
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public int GetProgramResourceLocation(
                   GlHandle program,
                   uint programInterface,
                   ReadOnlySpan<byte> name
        )
        {
            fixed (byte* namePtr = name) {
                return _context->glGetProgramResourceLocation(program.Value, programInterface, namePtr);
            }
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public int GetProgramResourceLocationIndex(
                   GlHandle program,
                   uint programInterface,
                   ReadOnlySpan<byte> name
        )
        {
            fixed (byte* namePtr = name) {
                return _context->glGetProgramResourceLocationIndex(program.Value, programInterface, namePtr);
            }
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void GetProgramResourceName(
                    GlHandle program,
                    uint programInterface,
                    uint index,
                    int bufSize,
                    int* length,
                    byte* name
        )
        {
            _context->glGetProgramResourceName(program.Value, programInterface, index, bufSize,
                                               length, name);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void InvalidateBufferData(
                    GlHandle buffer
        )
        {
            _context->glInvalidateBufferData(buffer.Value);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void InvalidateBufferSubData(
                    GlHandle buffer,
                    nint offset,
                    nuint length
        )
        {
            _context->glInvalidateBufferSubData(buffer.Value, offset, length);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void InvalidateFramebuffer(
                    uint target,
                    int numAttachments,
                    ReadOnlySpan<uint> attachments
        )
        {
            fixed (uint* attachmentsPtr = attachments) {
                _context->glInvalidateFramebuffer(target, numAttachments, attachmentsPtr);
            }
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void InvalidateSubFramebuffer(
                    uint target,
                    int numAttachments,
                    ReadOnlySpan<uint> attachments,
                    int x,
                    int y,
                    int width,
                    int height
        )
        {
            fixed (uint* attachmentsPtr = attachments) {
                _context->glInvalidateSubFramebuffer(target, numAttachments, attachmentsPtr, x, y,
                                                     width, height);
            }
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void InvalidateTexImage(
                    GlHandle texture,
                    int level
        )
        {
            _context->glInvalidateTexImage(texture.Value, level);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void InvalidateTexSubImage(
                    GlHandle texture,
                    int level,
                    int xoffset,
                    int yoffset,
                    int zoffset,
                    int width,
                    int height,
                    int depth
        )
        {
            _context->glInvalidateTexSubImage(texture.Value, level, xoffset, yoffset, zoffset,
                                              width, height, depth);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void MultiDrawArraysIndirect(
                    uint mode,
                    ReadOnlySpan<IntPtr> indirect,
                    int drawcount,
                    int stride
        )
        {
            fixed (IntPtr* indirectPtr = indirect) {
                _context->glMultiDrawArraysIndirect(mode, indirectPtr, drawcount, stride);
            }
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void MultiDrawElementsIndirect(
                    uint mode,
                    ShaderType type,
                    ReadOnlySpan<IntPtr> indirect,
                    int drawcount,
                    int stride
        )
        {
            fixed (IntPtr* indirectPtr = indirect) {
                _context->glMultiDrawElementsIndirect(mode, (uint)type, indirectPtr, drawcount,
                                                      stride);
            }
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void ObjectLabel(
                    uint identifier,
                    uint name,
                    int length,
                    ReadOnlySpan<byte> label
        )
        {
            fixed (byte* labelPtr = label) {
                _context->glObjectLabel(identifier, name, length, labelPtr);
            }
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void ObjectPtrLabel(
                    ReadOnlySpan<IntPtr> ptr,
                    int length,
                    ReadOnlySpan<byte> label
        )
        {
            fixed (IntPtr* ptrPtr = ptr)
            {
                fixed (byte* labelPtr = label) {
                    _context->glObjectPtrLabel(ptrPtr, length, labelPtr);
                }
            }
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void PopDebugGroup()
        {
            _context->glPopDebugGroup();
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void PushDebugGroup(
                    uint source,
                    uint id,
                    int length,
                    ReadOnlySpan<byte> message
        )
        {
            fixed (byte* messagePtr = message) {
                _context->glPushDebugGroup(source, id, length, messagePtr);
            }
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void ShaderStorageBlockBinding(
                    GlHandle program,
                    uint storageBlockIndex,
                    uint storageBlockBinding
        )
        {
            _context->glShaderStorageBlockBinding(program.Value, storageBlockIndex, storageBlockBinding);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void TexBufferRange(
                    uint target,
                    uint internalformat,
                    GlHandle buffer,
                    nint offset,
                    nuint size
        )
        {
            _context->glTexBufferRange(target, internalformat, buffer.Value, offset, size);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void TexStorage2DMultisample(
                    uint target,
                    int samples,
                    uint internalformat,
                    int width,
                    int height,
                    byte fixedsamplelocations
        )
        {
            _context->glTexStorage2DMultisample(target, samples, internalformat, width, height,
                                                fixedsamplelocations);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void TexStorage3DMultisample(
                    uint target,
                    int samples,
                    uint internalformat,
                    int width,
                    int height,
                    int depth,
                    byte fixedsamplelocations
        )
        {
            _context->glTexStorage3DMultisample(target, samples, internalformat, width, height,
                                                depth, fixedsamplelocations);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void TextureView(
                    GlHandle texture,
                    uint target,
                    GlHandle origtexture,
                    uint internalformat,
                    uint minlevel,
                    uint numlevels,
                    uint minlayer,
                    uint numlayers
        )
        {
            _context->glTextureView(texture.Value, target, origtexture.Value, internalformat,
                                    minlevel, numlevels, minlayer, numlayers);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void VertexAttribBinding(
                    uint attribindex,
                    uint bindingindex
        )
        {
            _context->glVertexAttribBinding(attribindex, bindingindex);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void VertexAttribFormat(
                    uint attribindex,
                    int size,
                    ShaderType type,
                    byte normalized,
                    uint relativeoffset
        )
        {
            _context->glVertexAttribFormat(attribindex, size, (uint)type, normalized,
                                           relativeoffset);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void VertexAttribIFormat(
                    uint attribindex,
                    int size,
                    ShaderType type,
                    uint relativeoffset
        )
        {
            _context->glVertexAttribIFormat(attribindex, size, (uint)type, relativeoffset);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void VertexAttribLFormat(
                    uint attribindex,
                    int size,
                    ShaderType type,
                    uint relativeoffset
        )
        {
            _context->glVertexAttribLFormat(attribindex, size, (uint)type, relativeoffset);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void VertexBindingDivisor(
                    uint bindingindex,
                    uint divisor
        )
        {
            _context->glVertexBindingDivisor(bindingindex, divisor);
        }

    }
}