• Home
• org.jogamp.jogl
• jogl-all
• 2.3.2
• source code
• EGLExtImpl.java

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

jogamp.opengl.egl.EGLExtImpl Maven / Gradle / Ivy

/* !---- DO NOT EDIT: This file autogenerated by com/jogamp/gluegen/opengl/GLEmitter.java on Sat Oct 10 03:19:32 CEST 2015 ----! */

package jogamp.opengl.egl;

import java.util.*;
import com.jogamp.opengl.*;
import com.jogamp.opengl.fixedfunc.*;
import jogamp.opengl.*;
import com.jogamp.opengl.egl.EGLExt;
import com.jogamp.opengl.egl.EGLClientPixmapHI;
import com.jogamp.gluegen.runtime.*;
import com.jogamp.common.os.*;
import com.jogamp.common.nio.*;
import java.nio.*;

public class EGLExtImpl implements EGLExt{
  /** Entry point to C language function:  EGLBoolean eglChooseConfig(EGLDisplay dpy, const EGLint *  attrib_list, EGLConfig *  configs, EGLint config_size, EGLint *  num_config)  
Part of EGL_VERSION_1_0

      @param attrib_list a direct only {@link java.nio.IntBuffer}
      @param configs a direct only {@link com.jogamp.common.nio.PointerBuffer}
      @param num_config a direct only {@link java.nio.IntBuffer}   */
  public boolean eglChooseConfig(long dpy, IntBuffer attrib_list, PointerBuffer configs, int config_size, IntBuffer num_config)  {

    if (!Buffers.isDirect(attrib_list))
      throw new RuntimeException("Argument \"attrib_list\" is not a direct buffer");
    if (!Buffers.isDirect(configs))
      throw new RuntimeException("Argument \"configs\" is not a direct buffer");
    if (!Buffers.isDirect(num_config))
      throw new RuntimeException("Argument \"num_config\" is not a direct buffer");
    final long __addr_ = _table._addressof_eglChooseConfig;
    if (__addr_ == 0) {
      throw new UnsupportedOperationException(String.format("Method \"%s\" not available", "eglChooseConfig"));
    }
        return dispatch_eglChooseConfig0(dpy, attrib_list, Buffers.getDirectBufferByteOffset(attrib_list), configs != null ? configs.getBuffer() : null, Buffers.getDirectBufferByteOffset(configs), config_size, num_config, Buffers.getDirectBufferByteOffset(num_config), __addr_);
  }

  /** Entry point to C language function:  EGLBoolean eglChooseConfig(EGLDisplay dpy, const EGLint *  attrib_list, EGLConfig *  configs, EGLint config_size, EGLint *  num_config)  
Part of EGL_VERSION_1_0

      @param attrib_list a direct only {@link java.nio.IntBuffer}
      @param configs a direct only {@link com.jogamp.common.nio.PointerBuffer}
      @param num_config a direct only {@link java.nio.IntBuffer}   */
  private native boolean dispatch_eglChooseConfig0(long dpy, Object attrib_list, int attrib_list_byte_offset, Object configs, int configs_byte_offset, int config_size, Object num_config, int num_config_byte_offset, long procAddress);

  /** Entry point to C language function:  EGLBoolean eglCopyBuffers(EGLDisplay dpy, EGLSurface surface, EGLNativePixmapType target)  
Part of EGL_VERSION_1_0
   */
  public boolean eglCopyBuffers(long dpy, long surface, long target)  {

    final long __addr_ = _table._addressof_eglCopyBuffers;
    if (__addr_ == 0) {
      throw new UnsupportedOperationException(String.format("Method \"%s\" not available", "eglCopyBuffers"));
    }
        return dispatch_eglCopyBuffers0(dpy, surface, target, __addr_);
  }

  /** Entry point to C language function:  EGLBoolean eglCopyBuffers(EGLDisplay dpy, EGLSurface surface, EGLNativePixmapType target)  
Part of EGL_VERSION_1_0
   */
  private native boolean dispatch_eglCopyBuffers0(long dpy, long surface, long target, long procAddress);

  /** Entry point to C language function:  EGLContext eglCreateContext(EGLDisplay dpy, EGLConfig config, EGLContext share_context, const EGLint *  attrib_list)  
Part of EGL_VERSION_1_0

      @param attrib_list a direct only {@link java.nio.IntBuffer}   */
  public long eglCreateContext(long dpy, long config, long share_context, IntBuffer attrib_list)  {

    if (!Buffers.isDirect(attrib_list))
      throw new RuntimeException("Argument \"attrib_list\" is not a direct buffer");
    final long __addr_ = _table._addressof_eglCreateContext;
    if (__addr_ == 0) {
      throw new UnsupportedOperationException(String.format("Method \"%s\" not available", "eglCreateContext"));
    }
        return dispatch_eglCreateContext0(dpy, config, share_context, attrib_list, Buffers.getDirectBufferByteOffset(attrib_list), __addr_);
  }

  /** Entry point to C language function:  EGLContext eglCreateContext(EGLDisplay dpy, EGLConfig config, EGLContext share_context, const EGLint *  attrib_list)  
Part of EGL_VERSION_1_0

      @param attrib_list a direct only {@link java.nio.IntBuffer}   */
  private native long dispatch_eglCreateContext0(long dpy, long config, long share_context, Object attrib_list, int attrib_list_byte_offset, long procAddress);

  /** Entry point to C language function:  EGLSurface eglCreatePbufferSurface(EGLDisplay dpy, EGLConfig config, const EGLint *  attrib_list)  
Part of EGL_VERSION_1_0

      @param attrib_list a direct only {@link java.nio.IntBuffer}   */
  public long eglCreatePbufferSurface(long dpy, long config, IntBuffer attrib_list)  {

    if (!Buffers.isDirect(attrib_list))
      throw new RuntimeException("Argument \"attrib_list\" is not a direct buffer");
    final long __addr_ = _table._addressof_eglCreatePbufferSurface;
    if (__addr_ == 0) {
      throw new UnsupportedOperationException(String.format("Method \"%s\" not available", "eglCreatePbufferSurface"));
    }
        return dispatch_eglCreatePbufferSurface0(dpy, config, attrib_list, Buffers.getDirectBufferByteOffset(attrib_list), __addr_);
  }

  /** Entry point to C language function:  EGLSurface eglCreatePbufferSurface(EGLDisplay dpy, EGLConfig config, const EGLint *  attrib_list)  
Part of EGL_VERSION_1_0

      @param attrib_list a direct only {@link java.nio.IntBuffer}   */
  private native long dispatch_eglCreatePbufferSurface0(long dpy, long config, Object attrib_list, int attrib_list_byte_offset, long procAddress);

  /** Entry point to C language function:  EGLSurface eglCreatePixmapSurface(EGLDisplay dpy, EGLConfig config, EGLNativePixmapType pixmap, const EGLint *  attrib_list)  
Part of EGL_VERSION_1_0, EGL_HI_clientpixmap
Alias for: eglCreatePixmapSurfaceHI
      @param attrib_list a direct only {@link java.nio.IntBuffer}   */
  public long eglCreatePixmapSurface(long dpy, long config, long pixmap, IntBuffer attrib_list)  {

    if (!Buffers.isDirect(attrib_list))
      throw new RuntimeException("Argument \"attrib_list\" is not a direct buffer");
    final long __addr_ = _table._addressof_eglCreatePixmapSurface;
    if (__addr_ == 0) {
      throw new UnsupportedOperationException(String.format("Method \"%s\" not available", "eglCreatePixmapSurface"));
    }
        return dispatch_eglCreatePixmapSurface0(dpy, config, pixmap, attrib_list, Buffers.getDirectBufferByteOffset(attrib_list), __addr_);
  }

  /** Entry point to C language function:  EGLSurface eglCreatePixmapSurface(EGLDisplay dpy, EGLConfig config, EGLNativePixmapType pixmap, const EGLint *  attrib_list)  
Part of EGL_VERSION_1_0, EGL_HI_clientpixmap
Alias for: eglCreatePixmapSurfaceHI
      @param attrib_list a direct only {@link java.nio.IntBuffer}   */
  private native long dispatch_eglCreatePixmapSurface0(long dpy, long config, long pixmap, Object attrib_list, int attrib_list_byte_offset, long procAddress);

  /** Entry point to C language function:  EGLSurface eglCreateWindowSurface(EGLDisplay dpy, EGLConfig config, EGLNativeWindowType win, const EGLint *  attrib_list)  
Part of EGL_VERSION_1_0

      @param attrib_list a direct only {@link java.nio.IntBuffer}   */
  public long eglCreateWindowSurface(long dpy, long config, long win, IntBuffer attrib_list)  {

    if (!Buffers.isDirect(attrib_list))
      throw new RuntimeException("Argument \"attrib_list\" is not a direct buffer");
    final long __addr_ = _table._addressof_eglCreateWindowSurface;
    if (__addr_ == 0) {
      throw new UnsupportedOperationException(String.format("Method \"%s\" not available", "eglCreateWindowSurface"));
    }
        return dispatch_eglCreateWindowSurface0(dpy, config, win, attrib_list, Buffers.getDirectBufferByteOffset(attrib_list), __addr_);
  }

  /** Entry point to C language function:  EGLSurface eglCreateWindowSurface(EGLDisplay dpy, EGLConfig config, EGLNativeWindowType win, const EGLint *  attrib_list)  
Part of EGL_VERSION_1_0

      @param attrib_list a direct only {@link java.nio.IntBuffer}   */
  private native long dispatch_eglCreateWindowSurface0(long dpy, long config, long win, Object attrib_list, int attrib_list_byte_offset, long procAddress);

  /** Entry point to C language function:  EGLBoolean eglDestroyContext(EGLDisplay dpy, EGLContext ctx)  
Part of EGL_VERSION_1_0
   */
  public boolean eglDestroyContext(long dpy, long ctx)  {

    final long __addr_ = _table._addressof_eglDestroyContext;
    if (__addr_ == 0) {
      throw new UnsupportedOperationException(String.format("Method \"%s\" not available", "eglDestroyContext"));
    }
        return dispatch_eglDestroyContext0(dpy, ctx, __addr_);
  }

  /** Entry point to C language function:  EGLBoolean eglDestroyContext(EGLDisplay dpy, EGLContext ctx)  
Part of EGL_VERSION_1_0
   */
  private native boolean dispatch_eglDestroyContext0(long dpy, long ctx, long procAddress);

  /** Entry point to C language function:  EGLBoolean eglDestroySurface(EGLDisplay dpy, EGLSurface surface)  
Part of EGL_VERSION_1_0
   */
  public boolean eglDestroySurface(long dpy, long surface)  {

    final long __addr_ = _table._addressof_eglDestroySurface;
    if (__addr_ == 0) {
      throw new UnsupportedOperationException(String.format("Method \"%s\" not available", "eglDestroySurface"));
    }
        return dispatch_eglDestroySurface0(dpy, surface, __addr_);
  }

  /** Entry point to C language function:  EGLBoolean eglDestroySurface(EGLDisplay dpy, EGLSurface surface)  
Part of EGL_VERSION_1_0
   */
  private native boolean dispatch_eglDestroySurface0(long dpy, long surface, long procAddress);

  /** Entry point to C language function:  EGLBoolean eglGetConfigAttrib(EGLDisplay dpy, EGLConfig config, EGLint attribute, EGLint *  value)  
Part of EGL_VERSION_1_0

      @param value a direct only {@link java.nio.IntBuffer}   */
  public boolean eglGetConfigAttrib(long dpy, long config, int attribute, IntBuffer value)  {

    if (!Buffers.isDirect(value))
      throw new RuntimeException("Argument \"value\" is not a direct buffer");
    final long __addr_ = _table._addressof_eglGetConfigAttrib;
    if (__addr_ == 0) {
      throw new UnsupportedOperationException(String.format("Method \"%s\" not available", "eglGetConfigAttrib"));
    }
        return dispatch_eglGetConfigAttrib0(dpy, config, attribute, value, Buffers.getDirectBufferByteOffset(value), __addr_);
  }

  /** Entry point to C language function:  EGLBoolean eglGetConfigAttrib(EGLDisplay dpy, EGLConfig config, EGLint attribute, EGLint *  value)  
Part of EGL_VERSION_1_0

      @param value a direct only {@link java.nio.IntBuffer}   */
  private native boolean dispatch_eglGetConfigAttrib0(long dpy, long config, int attribute, Object value, int value_byte_offset, long procAddress);

  /** Entry point to C language function:  EGLBoolean eglGetConfigs(EGLDisplay dpy, EGLConfig *  configs, EGLint config_size, EGLint *  num_config)  
Part of EGL_VERSION_1_0

      @param configs a direct only {@link com.jogamp.common.nio.PointerBuffer}
      @param num_config a direct only {@link java.nio.IntBuffer}   */
  public boolean eglGetConfigs(long dpy, PointerBuffer configs, int config_size, IntBuffer num_config)  {

    if (!Buffers.isDirect(configs))
      throw new RuntimeException("Argument \"configs\" is not a direct buffer");
    if (!Buffers.isDirect(num_config))
      throw new RuntimeException("Argument \"num_config\" is not a direct buffer");
    final long __addr_ = _table._addressof_eglGetConfigs;
    if (__addr_ == 0) {
      throw new UnsupportedOperationException(String.format("Method \"%s\" not available", "eglGetConfigs"));
    }
        return dispatch_eglGetConfigs0(dpy, configs != null ? configs.getBuffer() : null, Buffers.getDirectBufferByteOffset(configs), config_size, num_config, Buffers.getDirectBufferByteOffset(num_config), __addr_);
  }

  /** Entry point to C language function:  EGLBoolean eglGetConfigs(EGLDisplay dpy, EGLConfig *  configs, EGLint config_size, EGLint *  num_config)  
Part of EGL_VERSION_1_0

      @param configs a direct only {@link com.jogamp.common.nio.PointerBuffer}
      @param num_config a direct only {@link java.nio.IntBuffer}   */
  private native boolean dispatch_eglGetConfigs0(long dpy, Object configs, int configs_byte_offset, int config_size, Object num_config, int num_config_byte_offset, long procAddress);

  /** Entry point to C language function:  EGLDisplay eglGetCurrentDisplay(void)  
Part of EGL_VERSION_1_0
   */
  public long eglGetCurrentDisplay()  {

    final long __addr_ = _table._addressof_eglGetCurrentDisplay;
    if (__addr_ == 0) {
      throw new UnsupportedOperationException(String.format("Method \"%s\" not available", "eglGetCurrentDisplay"));
    }
        return dispatch_eglGetCurrentDisplay0(__addr_);
  }

  /** Entry point to C language function:  EGLDisplay eglGetCurrentDisplay(void)  
Part of EGL_VERSION_1_0
   */
  private native long dispatch_eglGetCurrentDisplay0(long procAddress);

  /** Entry point to C language function:  EGLSurface eglGetCurrentSurface(EGLint readdraw)  
Part of EGL_VERSION_1_0
   */
  public long eglGetCurrentSurface(int readdraw)  {

    final long __addr_ = _table._addressof_eglGetCurrentSurface;
    if (__addr_ == 0) {
      throw new UnsupportedOperationException(String.format("Method \"%s\" not available", "eglGetCurrentSurface"));
    }
        return dispatch_eglGetCurrentSurface0(readdraw, __addr_);
  }

  /** Entry point to C language function:  EGLSurface eglGetCurrentSurface(EGLint readdraw)  
Part of EGL_VERSION_1_0
   */
  private native long dispatch_eglGetCurrentSurface0(int readdraw, long procAddress);

  /** Entry point to C language function:  EGLDisplay eglGetDisplay(EGLNativeDisplayType display_id)  
Part of EGL_VERSION_1_0
   */
  public long eglGetDisplay(long display_id)  {

    final long __addr_ = _table._addressof_eglGetDisplay;
    if (__addr_ == 0) {
      throw new UnsupportedOperationException(String.format("Method \"%s\" not available", "eglGetDisplay"));
    }
        return dispatch_eglGetDisplay0(display_id, __addr_);
  }

  /** Entry point to C language function:  EGLDisplay eglGetDisplay(EGLNativeDisplayType display_id)  
Part of EGL_VERSION_1_0
   */
  private native long dispatch_eglGetDisplay0(long display_id, long procAddress);

  /** Entry point to C language function:  EGLint eglGetError(void)  
Part of EGL_VERSION_1_0
   */
  public int eglGetError()  {

    final long __addr_ = _table._addressof_eglGetError;
    if (__addr_ == 0) {
      throw new UnsupportedOperationException(String.format("Method \"%s\" not available", "eglGetError"));
    }
        return dispatch_eglGetError0(__addr_);
  }

  /** Entry point to C language function:  EGLint eglGetError(void)  
Part of EGL_VERSION_1_0
   */
  private native int dispatch_eglGetError0(long procAddress);

  /** Entry point to C language function:  EGLBoolean eglInitialize(EGLDisplay dpy, EGLint *  major, EGLint *  minor)  
Part of EGL_VERSION_1_0

      @param major a direct only {@link java.nio.IntBuffer}
      @param minor a direct only {@link java.nio.IntBuffer}   */
  public boolean eglInitialize(long dpy, IntBuffer major, IntBuffer minor)  {

    if (!Buffers.isDirect(major))
      throw new RuntimeException("Argument \"major\" is not a direct buffer");
    if (!Buffers.isDirect(minor))
      throw new RuntimeException("Argument \"minor\" is not a direct buffer");
    final long __addr_ = _table._addressof_eglInitialize;
    if (__addr_ == 0) {
      throw new UnsupportedOperationException(String.format("Method \"%s\" not available", "eglInitialize"));
    }
        return dispatch_eglInitialize0(dpy, major, Buffers.getDirectBufferByteOffset(major), minor, Buffers.getDirectBufferByteOffset(minor), __addr_);
  }

  /** Entry point to C language function:  EGLBoolean eglInitialize(EGLDisplay dpy, EGLint *  major, EGLint *  minor)  
Part of EGL_VERSION_1_0

      @param major a direct only {@link java.nio.IntBuffer}
      @param minor a direct only {@link java.nio.IntBuffer}   */
  private native boolean dispatch_eglInitialize0(long dpy, Object major, int major_byte_offset, Object minor, int minor_byte_offset, long procAddress);

  /** Entry point to C language function:  EGLBoolean eglMakeCurrent(EGLDisplay dpy, EGLSurface draw, EGLSurface read, EGLContext ctx)  
Part of EGL_VERSION_1_0
   */
  public boolean eglMakeCurrent(long dpy, long draw, long read, long ctx)  {

    final long __addr_ = _table._addressof_eglMakeCurrent;
    if (__addr_ == 0) {
      throw new UnsupportedOperationException(String.format("Method \"%s\" not available", "eglMakeCurrent"));
    }
        return dispatch_eglMakeCurrent0(dpy, draw, read, ctx, __addr_);
  }

  /** Entry point to C language function:  EGLBoolean eglMakeCurrent(EGLDisplay dpy, EGLSurface draw, EGLSurface read, EGLContext ctx)  
Part of EGL_VERSION_1_0
   */
  private native boolean dispatch_eglMakeCurrent0(long dpy, long draw, long read, long ctx, long procAddress);

  /** Entry point to C language function:  EGLBoolean eglQueryContext(EGLDisplay dpy, EGLContext ctx, EGLint attribute, EGLint *  value)  
Part of EGL_VERSION_1_0

      @param value a direct only {@link java.nio.IntBuffer}   */
  public boolean eglQueryContext(long dpy, long ctx, int attribute, IntBuffer value)  {

    if (!Buffers.isDirect(value))
      throw new RuntimeException("Argument \"value\" is not a direct buffer");
    final long __addr_ = _table._addressof_eglQueryContext;
    if (__addr_ == 0) {
      throw new UnsupportedOperationException(String.format("Method \"%s\" not available", "eglQueryContext"));
    }
        return dispatch_eglQueryContext0(dpy, ctx, attribute, value, Buffers.getDirectBufferByteOffset(value), __addr_);
  }

  /** Entry point to C language function:  EGLBoolean eglQueryContext(EGLDisplay dpy, EGLContext ctx, EGLint attribute, EGLint *  value)  
Part of EGL_VERSION_1_0

      @param value a direct only {@link java.nio.IntBuffer}   */
  private native boolean dispatch_eglQueryContext0(long dpy, long ctx, int attribute, Object value, int value_byte_offset, long procAddress);

  /** Entry point to C language function:  const char *  eglQueryString(EGLDisplay dpy, EGLint name)  
Part of EGL_VERSION_1_0
   */
  public String eglQueryString(long dpy, int name)  {

    final long __addr_ = _table._addressof_eglQueryString;
    if (__addr_ == 0) {
      throw new UnsupportedOperationException(String.format("Method \"%s\" not available", "eglQueryString"));
    }
        return dispatch_eglQueryString0(dpy, name, __addr_);
  }

  /** Entry point to C language function:  const char *  eglQueryString(EGLDisplay dpy, EGLint name)  
Part of EGL_VERSION_1_0
   */
  private native String dispatch_eglQueryString0(long dpy, int name, long procAddress);

  /** Entry point to C language function:  EGLBoolean eglQuerySurface(EGLDisplay dpy, EGLSurface surface, EGLint attribute, EGLint *  value)  
Part of EGL_VERSION_1_0

      @param value a direct only {@link java.nio.IntBuffer}   */
  public boolean eglQuerySurface(long dpy, long surface, int attribute, IntBuffer value)  {

    if (!Buffers.isDirect(value))
      throw new RuntimeException("Argument \"value\" is not a direct buffer");
    final long __addr_ = _table._addressof_eglQuerySurface;
    if (__addr_ == 0) {
      throw new UnsupportedOperationException(String.format("Method \"%s\" not available", "eglQuerySurface"));
    }
        return dispatch_eglQuerySurface0(dpy, surface, attribute, value, Buffers.getDirectBufferByteOffset(value), __addr_);
  }

  /** Entry point to C language function:  EGLBoolean eglQuerySurface(EGLDisplay dpy, EGLSurface surface, EGLint attribute, EGLint *  value)  
Part of EGL_VERSION_1_0

      @param value a direct only {@link java.nio.IntBuffer}   */
  private native boolean dispatch_eglQuerySurface0(long dpy, long surface, int attribute, Object value, int value_byte_offset, long procAddress);

  /** Entry point to C language function:  EGLBoolean eglSwapBuffers(EGLDisplay dpy, EGLSurface surface)  
Part of EGL_VERSION_1_0
   */
  public boolean eglSwapBuffers(long dpy, long surface)  {

    final long __addr_ = _table._addressof_eglSwapBuffers;
    if (__addr_ == 0) {
      throw new UnsupportedOperationException(String.format("Method \"%s\" not available", "eglSwapBuffers"));
    }
        return dispatch_eglSwapBuffers0(dpy, surface, __addr_);
  }

  /** Entry point to C language function:  EGLBoolean eglSwapBuffers(EGLDisplay dpy, EGLSurface surface)  
Part of EGL_VERSION_1_0
   */
  private native boolean dispatch_eglSwapBuffers0(long dpy, long surface, long procAddress);

  /** Entry point to C language function:  EGLBoolean eglTerminate(EGLDisplay dpy)  
Part of EGL_VERSION_1_0
   */
  public boolean eglTerminate(long dpy)  {

    final long __addr_ = _table._addressof_eglTerminate;
    if (__addr_ == 0) {
      throw new UnsupportedOperationException(String.format("Method \"%s\" not available", "eglTerminate"));
    }
        return dispatch_eglTerminate0(dpy, __addr_);
  }

  /** Entry point to C language function:  EGLBoolean eglTerminate(EGLDisplay dpy)  
Part of EGL_VERSION_1_0
   */
  private native boolean dispatch_eglTerminate0(long dpy, long procAddress);

  /** Entry point to C language function:  EGLBoolean eglWaitGL(void)  
Part of EGL_VERSION_1_0
   */
  public boolean eglWaitGL()  {

    final long __addr_ = _table._addressof_eglWaitGL;
    if (__addr_ == 0) {
      throw new UnsupportedOperationException(String.format("Method \"%s\" not available", "eglWaitGL"));
    }
        return dispatch_eglWaitGL0(__addr_);
  }

  /** Entry point to C language function:  EGLBoolean eglWaitGL(void)  
Part of EGL_VERSION_1_0
   */
  private native boolean dispatch_eglWaitGL0(long procAddress);

  /** Entry point to C language function:  EGLBoolean eglWaitNative(EGLint engine)  
Part of EGL_VERSION_1_0
   */
  public boolean eglWaitNative(int engine)  {

    final long __addr_ = _table._addressof_eglWaitNative;
    if (__addr_ == 0) {
      throw new UnsupportedOperationException(String.format("Method \"%s\" not available", "eglWaitNative"));
    }
        return dispatch_eglWaitNative0(engine, __addr_);
  }

  /** Entry point to C language function:  EGLBoolean eglWaitNative(EGLint engine)  
Part of EGL_VERSION_1_0
   */
  private native boolean dispatch_eglWaitNative0(int engine, long procAddress);

  /** Entry point to C language function:  EGLBoolean eglBindTexImage(EGLDisplay dpy, EGLSurface surface, EGLint buffer)  
Part of EGL_VERSION_1_1
   */
  public boolean eglBindTexImage(long dpy, long surface, int buffer)  {

    final long __addr_ = _table._addressof_eglBindTexImage;
    if (__addr_ == 0) {
      throw new UnsupportedOperationException(String.format("Method \"%s\" not available", "eglBindTexImage"));
    }
        return dispatch_eglBindTexImage0(dpy, surface, buffer, __addr_);
  }

  /** Entry point to C language function:  EGLBoolean eglBindTexImage(EGLDisplay dpy, EGLSurface surface, EGLint buffer)  
Part of EGL_VERSION_1_1
   */
  private native boolean dispatch_eglBindTexImage0(long dpy, long surface, int buffer, long procAddress);

  /** Entry point to C language function:  EGLBoolean eglReleaseTexImage(EGLDisplay dpy, EGLSurface surface, EGLint buffer)  
Part of EGL_VERSION_1_1
   */
  public boolean eglReleaseTexImage(long dpy, long surface, int buffer)  {

    final long __addr_ = _table._addressof_eglReleaseTexImage;
    if (__addr_ == 0) {
      throw new UnsupportedOperationException(String.format("Method \"%s\" not available", "eglReleaseTexImage"));
    }
        return dispatch_eglReleaseTexImage0(dpy, surface, buffer, __addr_);
  }

  /** Entry point to C language function:  EGLBoolean eglReleaseTexImage(EGLDisplay dpy, EGLSurface surface, EGLint buffer)  
Part of EGL_VERSION_1_1
   */
  private native boolean dispatch_eglReleaseTexImage0(long dpy, long surface, int buffer, long procAddress);

  /** Entry point to C language function:  EGLBoolean eglSurfaceAttrib(EGLDisplay dpy, EGLSurface surface, EGLint attribute, EGLint value)  
Part of EGL_VERSION_1_1
   */
  public boolean eglSurfaceAttrib(long dpy, long surface, int attribute, int value)  {

    final long __addr_ = _table._addressof_eglSurfaceAttrib;
    if (__addr_ == 0) {
      throw new UnsupportedOperationException(String.format("Method \"%s\" not available", "eglSurfaceAttrib"));
    }
        return dispatch_eglSurfaceAttrib0(dpy, surface, attribute, value, __addr_);
  }

  /** Entry point to C language function:  EGLBoolean eglSurfaceAttrib(EGLDisplay dpy, EGLSurface surface, EGLint attribute, EGLint value)  
Part of EGL_VERSION_1_1
   */
  private native boolean dispatch_eglSurfaceAttrib0(long dpy, long surface, int attribute, int value, long procAddress);

  /** Entry point to C language function:  EGLBoolean eglSwapInterval(EGLDisplay dpy, EGLint interval)  
Part of EGL_VERSION_1_1
   */
  public boolean eglSwapInterval(long dpy, int interval)  {

    final long __addr_ = _table._addressof_eglSwapInterval;
    if (__addr_ == 0) {
      throw new UnsupportedOperationException(String.format("Method \"%s\" not available", "eglSwapInterval"));
    }
        return dispatch_eglSwapInterval0(dpy, interval, __addr_);
  }

  /** Entry point to C language function:  EGLBoolean eglSwapInterval(EGLDisplay dpy, EGLint interval)  
Part of EGL_VERSION_1_1
   */
  private native boolean dispatch_eglSwapInterval0(long dpy, int interval, long procAddress);

  /** Entry point to C language function:  EGLBoolean eglBindAPI(EGLenum api)  
Part of EGL_VERSION_1_2
   */
  public boolean eglBindAPI(int api)  {

    final long __addr_ = _table._addressof_eglBindAPI;
    if (__addr_ == 0) {
      throw new UnsupportedOperationException(String.format("Method \"%s\" not available", "eglBindAPI"));
    }
        return dispatch_eglBindAPI0(api, __addr_);
  }

  /** Entry point to C language function:  EGLBoolean eglBindAPI(EGLenum api)  
Part of EGL_VERSION_1_2
   */
  private native boolean dispatch_eglBindAPI0(int api, long procAddress);

  /** Entry point to C language function:  EGLenum eglQueryAPI(void)  
Part of EGL_VERSION_1_2
   */
  public int eglQueryAPI()  {

    final long __addr_ = _table._addressof_eglQueryAPI;
    if (__addr_ == 0) {
      throw new UnsupportedOperationException(String.format("Method \"%s\" not available", "eglQueryAPI"));
    }
        return dispatch_eglQueryAPI0(__addr_);
  }

  /** Entry point to C language function:  EGLenum eglQueryAPI(void)  
Part of EGL_VERSION_1_2
   */
  private native int dispatch_eglQueryAPI0(long procAddress);

  /** Entry point to C language function:  EGLSurface eglCreatePbufferFromClientBuffer(EGLDisplay dpy, EGLenum buftype, EGLClientBuffer buffer, EGLConfig config, const EGLint *  attrib_list)  
Part of EGL_VERSION_1_2

      @param buffer a direct only {@link java.nio.Buffer}
      @param attrib_list a direct only {@link java.nio.IntBuffer}   */
  public long eglCreatePbufferFromClientBuffer(long dpy, int buftype, Buffer buffer, long config, IntBuffer attrib_list)  {

    if (!Buffers.isDirect(buffer))
      throw new RuntimeException("Argument \"buffer\" is not a direct buffer");
    if (!Buffers.isDirect(attrib_list))
      throw new RuntimeException("Argument \"attrib_list\" is not a direct buffer");
    final long __addr_ = _table._addressof_eglCreatePbufferFromClientBuffer;
    if (__addr_ == 0) {
      throw new UnsupportedOperationException(String.format("Method \"%s\" not available", "eglCreatePbufferFromClientBuffer"));
    }
        return dispatch_eglCreatePbufferFromClientBuffer0(dpy, buftype, buffer, Buffers.getDirectBufferByteOffset(buffer), config, attrib_list, Buffers.getDirectBufferByteOffset(attrib_list), __addr_);
  }

  /** Entry point to C language function:  EGLSurface eglCreatePbufferFromClientBuffer(EGLDisplay dpy, EGLenum buftype, EGLClientBuffer buffer, EGLConfig config, const EGLint *  attrib_list)  
Part of EGL_VERSION_1_2

      @param buffer a direct only {@link java.nio.Buffer}
      @param attrib_list a direct only {@link java.nio.IntBuffer}   */
  private native long dispatch_eglCreatePbufferFromClientBuffer0(long dpy, int buftype, Object buffer, int buffer_byte_offset, long config, Object attrib_list, int attrib_list_byte_offset, long procAddress);

  /** Entry point to C language function:  EGLBoolean eglReleaseThread(void)  
Part of EGL_VERSION_1_2
   */
  public boolean eglReleaseThread()  {

    final long __addr_ = _table._addressof_eglReleaseThread;
    if (__addr_ == 0) {
      throw new UnsupportedOperationException(String.format("Method \"%s\" not available", "eglReleaseThread"));
    }
        return dispatch_eglReleaseThread0(__addr_);
  }

  /** Entry point to C language function:  EGLBoolean eglReleaseThread(void)  
Part of EGL_VERSION_1_2
   */
  private native boolean dispatch_eglReleaseThread0(long procAddress);

  /** Entry point to C language function:  EGLBoolean eglWaitClient(void)  
Part of EGL_VERSION_1_2
   */
  public boolean eglWaitClient()  {

    final long __addr_ = _table._addressof_eglWaitClient;
    if (__addr_ == 0) {
      throw new UnsupportedOperationException(String.format("Method \"%s\" not available", "eglWaitClient"));
    }
        return dispatch_eglWaitClient0(__addr_);
  }

  /** Entry point to C language function:  EGLBoolean eglWaitClient(void)  
Part of EGL_VERSION_1_2
   */
  private native boolean dispatch_eglWaitClient0(long procAddress);

  /** Entry point to C language function:  EGLContext eglGetCurrentContext(void)  
Part of EGL_VERSION_1_4
   */
  public long eglGetCurrentContext()  {

    final long __addr_ = _table._addressof_eglGetCurrentContext;
    if (__addr_ == 0) {
      throw new UnsupportedOperationException(String.format("Method \"%s\" not available", "eglGetCurrentContext"));
    }
        return dispatch_eglGetCurrentContext0(__addr_);
  }

  /** Entry point to C language function:  EGLContext eglGetCurrentContext(void)  
Part of EGL_VERSION_1_4
   */
  private native long dispatch_eglGetCurrentContext0(long procAddress);

  /** Entry point to C language function:  EGLSync eglCreateSync(EGLDisplay dpy, EGLenum type, const EGLAttrib *  attrib_list)  
Part of EGL_VERSION_1_5, EGL_KHR_fence_sync
Alias for: eglCreateSyncKHR
      @param attrib_list a direct only {@link com.jogamp.common.nio.PointerBuffer}   */
  public ByteBuffer eglCreateSync(long dpy, int type, PointerBuffer attrib_list)  {

    if (!Buffers.isDirect(attrib_list))
      throw new RuntimeException("Argument \"attrib_list\" is not a direct buffer");
    final long __addr_ = _table._addressof_eglCreateSync;
    if (__addr_ == 0) {
      throw new UnsupportedOperationException(String.format("Method \"%s\" not available", "eglCreateSync"));
    }
    final ByteBuffer _res;
    _res = dispatch_eglCreateSync0(dpy, type, attrib_list != null ? attrib_list.getBuffer() : null, Buffers.getDirectBufferByteOffset(attrib_list), __addr_);
    if (_res == null) return null;
    Buffers.nativeOrder(_res);
    return _res;
  }

  /** Entry point to C language function:  EGLSync eglCreateSync(EGLDisplay dpy, EGLenum type, const EGLAttrib *  attrib_list)  
Part of EGL_VERSION_1_5, EGL_KHR_fence_sync
Alias for: eglCreateSyncKHR
      @param attrib_list a direct only {@link com.jogamp.common.nio.PointerBuffer}   */
  private native ByteBuffer dispatch_eglCreateSync0(long dpy, int type, Object attrib_list, int attrib_list_byte_offset, long procAddress);

  /** Entry point to C language function:  EGLBoolean eglDestroySync(EGLDisplay dpy, EGLSync sync)  
Part of EGL_VERSION_1_5, EGL_KHR_fence_sync, EGL_NV_sync
Alias for: eglDestroySyncKHR, eglDestroySyncNV
      @param sync a direct only {@link java.nio.Buffer}   */
  public boolean eglDestroySync(long dpy, Buffer sync)  {

    if (!Buffers.isDirect(sync))
      throw new RuntimeException("Argument \"sync\" is not a direct buffer");
    final long __addr_ = _table._addressof_eglDestroySync;
    if (__addr_ == 0) {
      throw new UnsupportedOperationException(String.format("Method \"%s\" not available", "eglDestroySync"));
    }
        return dispatch_eglDestroySync0(dpy, sync, Buffers.getDirectBufferByteOffset(sync), __addr_);
  }

  /** Entry point to C language function:  EGLBoolean eglDestroySync(EGLDisplay dpy, EGLSync sync)  
Part of EGL_VERSION_1_5, EGL_KHR_fence_sync, EGL_NV_sync
Alias for: eglDestroySyncKHR, eglDestroySyncNV
      @param sync a direct only {@link java.nio.Buffer}   */
  private native boolean dispatch_eglDestroySync0(long dpy, Object sync, int sync_byte_offset, long procAddress);

  /** Entry point to C language function:  EGLint eglClientWaitSync(EGLDisplay dpy, EGLSync sync, EGLint flags, EGLTime timeout)  
Part of EGL_VERSION_1_5, EGL_KHR_fence_sync, EGL_NV_sync
Alias for: eglClientWaitSyncKHR, eglClientWaitSyncNV
      @param sync a direct only {@link java.nio.Buffer}   */
  public int eglClientWaitSync(long dpy, Buffer sync, int flags, long timeout)  {

    if (!Buffers.isDirect(sync))
      throw new RuntimeException("Argument \"sync\" is not a direct buffer");
    final long __addr_ = _table._addressof_eglClientWaitSync;
    if (__addr_ == 0) {
      throw new UnsupportedOperationException(String.format("Method \"%s\" not available", "eglClientWaitSync"));
    }
        return dispatch_eglClientWaitSync0(dpy, sync, Buffers.getDirectBufferByteOffset(sync), flags, timeout, __addr_);
  }

  /** Entry point to C language function:  EGLint eglClientWaitSync(EGLDisplay dpy, EGLSync sync, EGLint flags, EGLTime timeout)  
Part of EGL_VERSION_1_5, EGL_KHR_fence_sync, EGL_NV_sync
Alias for: eglClientWaitSyncKHR, eglClientWaitSyncNV
      @param sync a direct only {@link java.nio.Buffer}   */
  private native int dispatch_eglClientWaitSync0(long dpy, Object sync, int sync_byte_offset, int flags, long timeout, long procAddress);

  /** Entry point to C language function:  EGLBoolean eglGetSyncAttrib(EGLDisplay dpy, EGLSync sync, EGLint attribute, EGLAttrib *  value)  
Part of EGL_VERSION_1_5, EGL_NV_sync, EGL_KHR_fence_sync
Alias for: eglGetSyncAttribNV, eglGetSyncAttribKHR
      @param sync a direct only {@link java.nio.Buffer}
      @param value a direct only {@link com.jogamp.common.nio.PointerBuffer}   */
  public boolean eglGetSyncAttrib(long dpy, Buffer sync, int attribute, PointerBuffer value)  {

    if (!Buffers.isDirect(sync))
      throw new RuntimeException("Argument \"sync\" is not a direct buffer");
    if (!Buffers.isDirect(value))
      throw new RuntimeException("Argument \"value\" is not a direct buffer");
    final long __addr_ = _table._addressof_eglGetSyncAttrib;
    if (__addr_ == 0) {
      throw new UnsupportedOperationException(String.format("Method \"%s\" not available", "eglGetSyncAttrib"));
    }
        return dispatch_eglGetSyncAttrib0(dpy, sync, Buffers.getDirectBufferByteOffset(sync), attribute, value != null ? value.getBuffer() : null, Buffers.getDirectBufferByteOffset(value), __addr_);
  }

  /** Entry point to C language function:  EGLBoolean eglGetSyncAttrib(EGLDisplay dpy, EGLSync sync, EGLint attribute, EGLAttrib *  value)  
Part of EGL_VERSION_1_5, EGL_NV_sync, EGL_KHR_fence_sync
Alias for: eglGetSyncAttribNV, eglGetSyncAttribKHR
      @param sync a direct only {@link java.nio.Buffer}
      @param value a direct only {@link com.jogamp.common.nio.PointerBuffer}   */
  private native boolean dispatch_eglGetSyncAttrib0(long dpy, Object sync, int sync_byte_offset, int attribute, Object value, int value_byte_offset, long procAddress);

  /** Entry point to C language function:  EGLImage eglCreateImage(EGLDisplay dpy, EGLContext ctx, EGLenum target, EGLClientBuffer buffer, const EGLAttrib *  attrib_list)  
Part of EGL_VERSION_1_5, EGL_KHR_image
Alias for: eglCreateImageKHR
      @param buffer a direct only {@link java.nio.Buffer}
      @param attrib_list a direct only {@link com.jogamp.common.nio.PointerBuffer}   */
  public ByteBuffer eglCreateImage(long dpy, long ctx, int target, Buffer buffer, PointerBuffer attrib_list)  {

    if (!Buffers.isDirect(buffer))
      throw new RuntimeException("Argument \"buffer\" is not a direct buffer");
    if (!Buffers.isDirect(attrib_list))
      throw new RuntimeException("Argument \"attrib_list\" is not a direct buffer");
    final long __addr_ = _table._addressof_eglCreateImage;
    if (__addr_ == 0) {
      throw new UnsupportedOperationException(String.format("Method \"%s\" not available", "eglCreateImage"));
    }
    final ByteBuffer _res;
    _res = dispatch_eglCreateImage0(dpy, ctx, target, buffer, Buffers.getDirectBufferByteOffset(buffer), attrib_list != null ? attrib_list.getBuffer() : null, Buffers.getDirectBufferByteOffset(attrib_list), __addr_);
    if (_res == null) return null;
    Buffers.nativeOrder(_res);
    return _res;
  }

  /** Entry point to C language function:  EGLImage eglCreateImage(EGLDisplay dpy, EGLContext ctx, EGLenum target, EGLClientBuffer buffer, const EGLAttrib *  attrib_list)  
Part of EGL_VERSION_1_5, EGL_KHR_image
Alias for: eglCreateImageKHR
      @param buffer a direct only {@link java.nio.Buffer}
      @param attrib_list a direct only {@link com.jogamp.common.nio.PointerBuffer}   */
  private native ByteBuffer dispatch_eglCreateImage0(long dpy, long ctx, int target, Object buffer, int buffer_byte_offset, Object attrib_list, int attrib_list_byte_offset, long procAddress);

  /** Entry point to C language function:  EGLBoolean eglDestroyImage(EGLDisplay dpy, EGLImage image)  
Part of EGL_VERSION_1_5, EGL_KHR_image
Alias for: eglDestroyImageKHR
      @param image a direct only {@link java.nio.Buffer}   */
  public boolean eglDestroyImage(long dpy, Buffer image)  {

    if (!Buffers.isDirect(image))
      throw new RuntimeException("Argument \"image\" is not a direct buffer");
    final long __addr_ = _table._addressof_eglDestroyImage;
    if (__addr_ == 0) {
      throw new UnsupportedOperationException(String.format("Method \"%s\" not available", "eglDestroyImage"));
    }
        return dispatch_eglDestroyImage0(dpy, image, Buffers.getDirectBufferByteOffset(image), __addr_);
  }

  /** Entry point to C language function:  EGLBoolean eglDestroyImage(EGLDisplay dpy, EGLImage image)  
Part of EGL_VERSION_1_5, EGL_KHR_image
Alias for: eglDestroyImageKHR
      @param image a direct only {@link java.nio.Buffer}   */
  private native boolean dispatch_eglDestroyImage0(long dpy, Object image, int image_byte_offset, long procAddress);

  /** Entry point to C language function:  EGLDisplay eglGetPlatformDisplay(EGLenum platform, void *  native_display, const EGLAttrib *  attrib_list)  
Part of EGL_VERSION_1_5, EGL_EXT_platform_base
Alias for: eglGetPlatformDisplayEXT
      @param native_display a direct only {@link java.nio.Buffer}
      @param attrib_list a direct only {@link com.jogamp.common.nio.PointerBuffer}   */
  public long eglGetPlatformDisplay(int platform, Buffer native_display, PointerBuffer attrib_list)  {

    if (!Buffers.isDirect(native_display))
      throw new RuntimeException("Argument \"native_display\" is not a direct buffer");
    if (!Buffers.isDirect(attrib_list))
      throw new RuntimeException("Argument \"attrib_list\" is not a direct buffer");
    final long __addr_ = _table._addressof_eglGetPlatformDisplay;
    if (__addr_ == 0) {
      throw new UnsupportedOperationException(String.format("Method \"%s\" not available", "eglGetPlatformDisplay"));
    }
        return dispatch_eglGetPlatformDisplay0(platform, native_display, Buffers.getDirectBufferByteOffset(native_display), attrib_list != null ? attrib_list.getBuffer() : null, Buffers.getDirectBufferByteOffset(attrib_list), __addr_);
  }

  /** Entry point to C language function:  EGLDisplay eglGetPlatformDisplay(EGLenum platform, void *  native_display, const EGLAttrib *  attrib_list)  
Part of EGL_VERSION_1_5, EGL_EXT_platform_base
Alias for: eglGetPlatformDisplayEXT
      @param native_display a direct only {@link java.nio.Buffer}
      @param attrib_list a direct only {@link com.jogamp.common.nio.PointerBuffer}   */
  private native long dispatch_eglGetPlatformDisplay0(int platform, Object native_display, int native_display_byte_offset, Object attrib_list, int attrib_list_byte_offset, long procAddress);

  /** Entry point to C language function:  EGLSurface eglCreatePlatformWindowSurface(EGLDisplay dpy, EGLConfig config, void *  native_window, const EGLAttrib *  attrib_list)  
Part of EGL_VERSION_1_5, EGL_EXT_platform_base
Alias for: eglCreatePlatformWindowSurfaceEXT
      @param native_window a direct only {@link java.nio.Buffer}
      @param attrib_list a direct only {@link com.jogamp.common.nio.PointerBuffer}   */
  public long eglCreatePlatformWindowSurface(long dpy, long config, Buffer native_window, PointerBuffer attrib_list)  {

    if (!Buffers.isDirect(native_window))
      throw new RuntimeException("Argument \"native_window\" is not a direct buffer");
    if (!Buffers.isDirect(attrib_list))
      throw new RuntimeException("Argument \"attrib_list\" is not a direct buffer");
    final long __addr_ = _table._addressof_eglCreatePlatformWindowSurface;
    if (__addr_ == 0) {
      throw new UnsupportedOperationException(String.format("Method \"%s\" not available", "eglCreatePlatformWindowSurface"));
    }
        return dispatch_eglCreatePlatformWindowSurface0(dpy, config, native_window, Buffers.getDirectBufferByteOffset(native_window), attrib_list != null ? attrib_list.getBuffer() : null, Buffers.getDirectBufferByteOffset(attrib_list), __addr_);
  }

  /** Entry point to C language function:  EGLSurface eglCreatePlatformWindowSurface(EGLDisplay dpy, EGLConfig config, void *  native_window, const EGLAttrib *  attrib_list)  
Part of EGL_VERSION_1_5, EGL_EXT_platform_base
Alias for: eglCreatePlatformWindowSurfaceEXT
      @param native_window a direct only {@link java.nio.Buffer}
      @param attrib_list a direct only {@link com.jogamp.common.nio.PointerBuffer}   */
  private native long dispatch_eglCreatePlatformWindowSurface0(long dpy, long config, Object native_window, int native_window_byte_offset, Object attrib_list, int attrib_list_byte_offset, long procAddress);

  /** Entry point to C language function:  EGLSurface eglCreatePlatformPixmapSurface(EGLDisplay dpy, EGLConfig config, void *  native_pixmap, const EGLAttrib *  attrib_list)  
Part of EGL_VERSION_1_5, EGL_EXT_platform_base
Alias for: eglCreatePlatformPixmapSurfaceEXT
      @param native_pixmap a direct only {@link java.nio.Buffer}
      @param attrib_list a direct only {@link com.jogamp.common.nio.PointerBuffer}   */
  public long eglCreatePlatformPixmapSurface(long dpy, long config, Buffer native_pixmap, PointerBuffer attrib_list)  {

    if (!Buffers.isDirect(native_pixmap))
      throw new RuntimeException("Argument \"native_pixmap\" is not a direct buffer");
    if (!Buffers.isDirect(attrib_list))
      throw new RuntimeException("Argument \"attrib_list\" is not a direct buffer");
    final long __addr_ = _table._addressof_eglCreatePlatformPixmapSurface;
    if (__addr_ == 0) {
      throw new UnsupportedOperationException(String.format("Method \"%s\" not available", "eglCreatePlatformPixmapSurface"));
    }
        return dispatch_eglCreatePlatformPixmapSurface0(dpy, config, native_pixmap, Buffers.getDirectBufferByteOffset(native_pixmap), attrib_list != null ? attrib_list.getBuffer() : null, Buffers.getDirectBufferByteOffset(attrib_list), __addr_);
  }

  /** Entry point to C language function:  EGLSurface eglCreatePlatformPixmapSurface(EGLDisplay dpy, EGLConfig config, void *  native_pixmap, const EGLAttrib *  attrib_list)  
Part of EGL_VERSION_1_5, EGL_EXT_platform_base
Alias for: eglCreatePlatformPixmapSurfaceEXT
      @param native_pixmap a direct only {@link java.nio.Buffer}
      @param attrib_list a direct only {@link com.jogamp.common.nio.PointerBuffer}   */
  private native long dispatch_eglCreatePlatformPixmapSurface0(long dpy, long config, Object native_pixmap, int native_pixmap_byte_offset, Object attrib_list, int attrib_list_byte_offset, long procAddress);

  /** Entry point to C language function:  EGLBoolean eglWaitSync(EGLDisplay dpy, EGLSync sync, EGLint flags)  
Part of EGL_VERSION_1_5, EGL_KHR_wait_sync
Alias for: eglWaitSyncKHR
      @param sync a direct only {@link java.nio.Buffer}   */
  public boolean eglWaitSync(long dpy, Buffer sync, int flags)  {

    if (!Buffers.isDirect(sync))
      throw new RuntimeException("Argument \"sync\" is not a direct buffer");
    final long __addr_ = _table._addressof_eglWaitSync;
    if (__addr_ == 0) {
      throw new UnsupportedOperationException(String.format("Method \"%s\" not available", "eglWaitSync"));
    }
        return dispatch_eglWaitSync0(dpy, sync, Buffers.getDirectBufferByteOffset(sync), flags, __addr_);
  }

  /** Entry point to C language function:  EGLBoolean eglWaitSync(EGLDisplay dpy, EGLSync sync, EGLint flags)  
Part of EGL_VERSION_1_5, EGL_KHR_wait_sync
Alias for: eglWaitSyncKHR
      @param sync a direct only {@link java.nio.Buffer}   */
  private native boolean dispatch_eglWaitSync0(long dpy, Object sync, int sync_byte_offset, int flags, long procAddress);

  /** Entry point to C language function:  EGLSyncKHR eglCreateSync64KHR(EGLDisplay dpy, EGLenum type, const EGLAttribKHR *  attrib_list)  
Part of EGL_KHR_cl_event2

      @param attrib_list a direct only {@link com.jogamp.common.nio.PointerBuffer}   */
  public long eglCreateSync64KHR(long dpy, int type, PointerBuffer attrib_list)  {

    if (!Buffers.isDirect(attrib_list))
      throw new RuntimeException("Argument \"attrib_list\" is not a direct buffer");
    final long __addr_ = _table._addressof_eglCreateSync64KHR;
    if (__addr_ == 0) {
      throw new UnsupportedOperationException(String.format("Method \"%s\" not available", "eglCreateSync64KHR"));
    }
        return dispatch_eglCreateSync64KHR0(dpy, type, attrib_list != null ? attrib_list.getBuffer() : null, Buffers.getDirectBufferByteOffset(attrib_list), __addr_);
  }

  /** Entry point to C language function:  EGLSyncKHR eglCreateSync64KHR(EGLDisplay dpy, EGLenum type, const EGLAttribKHR *  attrib_list)  
Part of EGL_KHR_cl_event2

      @param attrib_list a direct only {@link com.jogamp.common.nio.PointerBuffer}   */
  private native long dispatch_eglCreateSync64KHR0(long dpy, int type, Object attrib_list, int attrib_list_byte_offset, long procAddress);

  /** Entry point to C language function:  EGLBoolean eglQueryDebugKHR(EGLint attribute, EGLAttrib *  value)  
Part of EGL_KHR_debug

      @param value a direct only {@link com.jogamp.common.nio.PointerBuffer}   */
  public boolean eglQueryDebugKHR(int attribute, PointerBuffer value)  {

    if (!Buffers.isDirect(value))
      throw new RuntimeException("Argument \"value\" is not a direct buffer");
    final long __addr_ = _table._addressof_eglQueryDebugKHR;
    if (__addr_ == 0) {
      throw new UnsupportedOperationException(String.format("Method \"%s\" not available", "eglQueryDebugKHR"));
    }
        return dispatch_eglQueryDebugKHR0(attribute, value != null ? value.getBuffer() : null, Buffers.getDirectBufferByteOffset(value), __addr_);
  }

  /** Entry point to C language function:  EGLBoolean eglQueryDebugKHR(EGLint attribute, EGLAttrib *  value)  
Part of EGL_KHR_debug

      @param value a direct only {@link com.jogamp.common.nio.PointerBuffer}   */
  private native boolean dispatch_eglQueryDebugKHR0(int attribute, Object value, int value_byte_offset, long procAddress);

  /** Entry point to C language function:  EGLint eglLabelObjectKHR(EGLDisplay display, EGLenum objectType, EGLObjectKHR object, EGLLabelKHR label)  
Part of EGL_KHR_debug

      @param object a direct only {@link java.nio.Buffer}
      @param label a direct only {@link java.nio.Buffer}   */
  public int eglLabelObjectKHR(long display, int objectType, Buffer object, Buffer label)  {

    if (!Buffers.isDirect(object))
      throw new RuntimeException("Argument \"object\" is not a direct buffer");
    if (!Buffers.isDirect(label))
      throw new RuntimeException("Argument \"label\" is not a direct buffer");
    final long __addr_ = _table._addressof_eglLabelObjectKHR;
    if (__addr_ == 0) {
      throw new UnsupportedOperationException(String.format("Method \"%s\" not available", "eglLabelObjectKHR"));
    }
        return dispatch_eglLabelObjectKHR0(display, objectType, object, Buffers.getDirectBufferByteOffset(object), label, Buffers.getDirectBufferByteOffset(label), __addr_);
  }

  /** Entry point to C language function:  EGLint eglLabelObjectKHR(EGLDisplay display, EGLenum objectType, EGLObjectKHR object, EGLLabelKHR label)  
Part of EGL_KHR_debug

      @param object a direct only {@link java.nio.Buffer}
      @param label a direct only {@link java.nio.Buffer}   */
  private native int dispatch_eglLabelObjectKHR0(long display, int objectType, Object object, int object_byte_offset, Object label, int label_byte_offset, long procAddress);

  /** Entry point to C language function:  EGLSyncKHR eglCreateSyncKHR(EGLDisplay dpy, EGLenum type, const EGLint *  attrib_list)  
Part of EGL_KHR_fence_sync

      @param attrib_list a direct only {@link java.nio.IntBuffer}   */
  public long eglCreateSyncKHR(long dpy, int type, IntBuffer attrib_list)  {

    if (!Buffers.isDirect(attrib_list))
      throw new RuntimeException("Argument \"attrib_list\" is not a direct buffer");
    final long __addr_ = _table._addressof_eglCreateSyncKHR;
    if (__addr_ == 0) {
      throw new UnsupportedOperationException(String.format("Method \"%s\" not available", "eglCreateSyncKHR"));
    }
        return dispatch_eglCreateSyncKHR0(dpy, type, attrib_list, Buffers.getDirectBufferByteOffset(attrib_list), __addr_);
  }

  /** Entry point to C language function:  EGLSyncKHR eglCreateSyncKHR(EGLDisplay dpy, EGLenum type, const EGLint *  attrib_list)  
Part of EGL_KHR_fence_sync

      @param attrib_list a direct only {@link java.nio.IntBuffer}   */
  private native long dispatch_eglCreateSyncKHR0(long dpy, int type, Object attrib_list, int attrib_list_byte_offset, long procAddress);

  /** Entry point to C language function:  EGLBoolean eglDestroySyncKHR(EGLDisplay dpy, EGLSyncKHR sync)  
Part of EGL_KHR_fence_sync
   */
  public boolean eglDestroySyncKHR(long dpy, long sync)  {

    final long __addr_ = _table._addressof_eglDestroySyncKHR;
    if (__addr_ == 0) {
      throw new UnsupportedOperationException(String.format("Method \"%s\" not available", "eglDestroySyncKHR"));
    }
        return dispatch_eglDestroySyncKHR0(dpy, sync, __addr_);
  }

  /** Entry point to C language function:  EGLBoolean eglDestroySyncKHR(EGLDisplay dpy, EGLSyncKHR sync)  
Part of EGL_KHR_fence_sync
   */
  private native boolean dispatch_eglDestroySyncKHR0(long dpy, long sync, long procAddress);

  /** Entry point to C language function:  EGLint eglClientWaitSyncKHR(EGLDisplay dpy, EGLSyncKHR sync, EGLint flags, EGLTimeKHR timeout)  
Part of EGL_KHR_fence_sync
   */
  public int eglClientWaitSyncKHR(long dpy, long sync, int flags, long timeout)  {

    final long __addr_ = _table._addressof_eglClientWaitSyncKHR;
    if (__addr_ == 0) {
      throw new UnsupportedOperationException(String.format("Method \"%s\" not available", "eglClientWaitSyncKHR"));
    }
        return dispatch_eglClientWaitSyncKHR0(dpy, sync, flags, timeout, __addr_);
  }

  /** Entry point to C language function:  EGLint eglClientWaitSyncKHR(EGLDisplay dpy, EGLSyncKHR sync, EGLint flags, EGLTimeKHR timeout)  
Part of EGL_KHR_fence_sync
   */
  private native int dispatch_eglClientWaitSyncKHR0(long dpy, long sync, int flags, long timeout, long procAddress);

  /** Entry point to C language function:  EGLBoolean eglGetSyncAttribKHR(EGLDisplay dpy, EGLSyncKHR sync, EGLint attribute, EGLint *  value)  
Part of EGL_KHR_fence_sync

      @param value a direct only {@link java.nio.IntBuffer}   */
  public boolean eglGetSyncAttribKHR(long dpy, long sync, int attribute, IntBuffer value)  {

    if (!Buffers.isDirect(value))
      throw new RuntimeException("Argument \"value\" is not a direct buffer");
    final long __addr_ = _table._addressof_eglGetSyncAttribKHR;
    if (__addr_ == 0) {
      throw new UnsupportedOperationException(String.format("Method \"%s\" not available", "eglGetSyncAttribKHR"));
    }
        return dispatch_eglGetSyncAttribKHR0(dpy, sync, attribute, value, Buffers.getDirectBufferByteOffset(value), __addr_);
  }

  /** Entry point to C language function:  EGLBoolean eglGetSyncAttribKHR(EGLDisplay dpy, EGLSyncKHR sync, EGLint attribute, EGLint *  value)  
Part of EGL_KHR_fence_sync

      @param value a direct only {@link java.nio.IntBuffer}   */
  private native boolean dispatch_eglGetSyncAttribKHR0(long dpy, long sync, int attribute, Object value, int value_byte_offset, long procAddress);

  /** Entry point to C language function:  EGLImageKHR eglCreateImageKHR(EGLDisplay dpy, EGLContext ctx, EGLenum target, EGLClientBuffer buffer, const EGLint *  attrib_list)  
Part of EGL_KHR_image

      @param buffer a direct only {@link java.nio.Buffer}
      @param attrib_list a direct only {@link java.nio.IntBuffer}   */
  public long eglCreateImageKHR(long dpy, long ctx, int target, Buffer buffer, IntBuffer attrib_list)  {

    if (!Buffers.isDirect(buffer))
      throw new RuntimeException("Argument \"buffer\" is not a direct buffer");
    if (!Buffers.isDirect(attrib_list))
      throw new RuntimeException("Argument \"attrib_list\" is not a direct buffer");
    final long __addr_ = _table._addressof_eglCreateImageKHR;
    if (__addr_ == 0) {
      throw new UnsupportedOperationException(String.format("Method \"%s\" not available", "eglCreateImageKHR"));
    }
        return dispatch_eglCreateImageKHR0(dpy, ctx, target, buffer, Buffers.getDirectBufferByteOffset(buffer), attrib_list, Buffers.getDirectBufferByteOffset(attrib_list), __addr_);
  }

  /** Entry point to C language function:  EGLImageKHR eglCreateImageKHR(EGLDisplay dpy, EGLContext ctx, EGLenum target, EGLClientBuffer buffer, const EGLint *  attrib_list)  
Part of EGL_KHR_image

      @param buffer a direct only {@link java.nio.Buffer}
      @param attrib_list a direct only {@link java.nio.IntBuffer}   */
  private native long dispatch_eglCreateImageKHR0(long dpy, long ctx, int target, Object buffer, int buffer_byte_offset, Object attrib_list, int attrib_list_byte_offset, long procAddress);

  /** Entry point to C language function:  EGLBoolean eglDestroyImageKHR(EGLDisplay dpy, EGLImageKHR image)  
Part of EGL_KHR_image
   */
  public boolean eglDestroyImageKHR(long dpy, long image)  {

    final long __addr_ = _table._addressof_eglDestroyImageKHR;
    if (__addr_ == 0) {
      throw new UnsupportedOperationException(String.format("Method \"%s\" not available", "eglDestroyImageKHR"));
    }
        return dispatch_eglDestroyImageKHR0(dpy, image, __addr_);
  }

  /** Entry point to C language function:  EGLBoolean eglDestroyImageKHR(EGLDisplay dpy, EGLImageKHR image)  
Part of EGL_KHR_image
   */
  private native boolean dispatch_eglDestroyImageKHR0(long dpy, long image, long procAddress);

  /** Entry point to C language function:  EGLBoolean eglLockSurfaceKHR(EGLDisplay dpy, EGLSurface surface, const EGLint *  attrib_list)  
Part of EGL_KHR_lock_surface

      @param attrib_list a direct only {@link java.nio.IntBuffer}   */
  public boolean eglLockSurfaceKHR(long dpy, long surface, IntBuffer attrib_list)  {

    if (!Buffers.isDirect(attrib_list))
      throw new RuntimeException("Argument \"attrib_list\" is not a direct buffer");
    final long __addr_ = _table._addressof_eglLockSurfaceKHR;
    if (__addr_ == 0) {
      throw new UnsupportedOperationException(String.format("Method \"%s\" not available", "eglLockSurfaceKHR"));
    }
        return dispatch_eglLockSurfaceKHR0(dpy, surface, attrib_list, Buffers.getDirectBufferByteOffset(attrib_list), __addr_);
  }

  /** Entry point to C language function:  EGLBoolean eglLockSurfaceKHR(EGLDisplay dpy, EGLSurface surface, const EGLint *  attrib_list)  
Part of EGL_KHR_lock_surface

      @param attrib_list a direct only {@link java.nio.IntBuffer}   */
  private native boolean dispatch_eglLockSurfaceKHR0(long dpy, long surface, Object attrib_list, int attrib_list_byte_offset, long procAddress);

  /** Entry point to C language function:  EGLBoolean eglUnlockSurfaceKHR(EGLDisplay dpy, EGLSurface surface)  
Part of EGL_KHR_lock_surface
   */
  public boolean eglUnlockSurfaceKHR(long dpy, long surface)  {

    final long __addr_ = _table._addressof_eglUnlockSurfaceKHR;
    if (__addr_ == 0) {
      throw new UnsupportedOperationException(String.format("Method \"%s\" not available", "eglUnlockSurfaceKHR"));
    }
        return dispatch_eglUnlockSurfaceKHR0(dpy, surface, __addr_);
  }

  /** Entry point to C language function:  EGLBoolean eglUnlockSurfaceKHR(EGLDisplay dpy, EGLSurface surface)  
Part of EGL_KHR_lock_surface
   */
  private native boolean dispatch_eglUnlockSurfaceKHR0(long dpy, long surface, long procAddress);

  /** Entry point to C language function:  EGLBoolean eglQuerySurface64KHR(EGLDisplay dpy, EGLSurface surface, EGLint attribute, EGLAttribKHR *  value)  
Part of EGL_KHR_lock_surface3

      @param value a direct only {@link com.jogamp.common.nio.PointerBuffer}   */
  public boolean eglQuerySurface64KHR(long dpy, long surface, int attribute, PointerBuffer value)  {

    if (!Buffers.isDirect(value))
      throw new RuntimeException("Argument \"value\" is not a direct buffer");
    final long __addr_ = _table._addressof_eglQuerySurface64KHR;
    if (__addr_ == 0) {
      throw new UnsupportedOperationException(String.format("Method \"%s\" not available", "eglQuerySurface64KHR"));
    }
        return dispatch_eglQuerySurface64KHR0(dpy, surface, attribute, value != null ? value.getBuffer() : null, Buffers.getDirectBufferByteOffset(value), __addr_);
  }

  /** Entry point to C language function:  EGLBoolean eglQuerySurface64KHR(EGLDisplay dpy, EGLSurface surface, EGLint attribute, EGLAttribKHR *  value)  
Part of EGL_KHR_lock_surface3

      @param value a direct only {@link com.jogamp.common.nio.PointerBuffer}   */
  private native boolean dispatch_eglQuerySurface64KHR0(long dpy, long surface, int attribute, Object value, int value_byte_offset, long procAddress);

  /** Entry point to C language function:  EGLBoolean eglSetDamageRegionKHR(EGLDisplay dpy, EGLSurface surface, EGLint *  rects, EGLint n_rects)  
Part of EGL_KHR_partial_update

      @param rects a direct only {@link java.nio.IntBuffer}   */
  public boolean eglSetDamageRegionKHR(long dpy, long surface, IntBuffer rects, int n_rects)  {

    if (!Buffers.isDirect(rects))
      throw new RuntimeException("Argument \"rects\" is not a direct buffer");
    final long __addr_ = _table._addressof_eglSetDamageRegionKHR;
    if (__addr_ == 0) {
      throw new UnsupportedOperationException(String.format("Method \"%s\" not available", "eglSetDamageRegionKHR"));
    }
        return dispatch_eglSetDamageRegionKHR0(dpy, surface, rects, Buffers.getDirectBufferByteOffset(rects), n_rects, __addr_);
  }

  /** Entry point to C language function:  EGLBoolean eglSetDamageRegionKHR(EGLDisplay dpy, EGLSurface surface, EGLint *  rects, EGLint n_rects)  
Part of EGL_KHR_partial_update

      @param rects a direct only {@link java.nio.IntBuffer}   */
  private native boolean dispatch_eglSetDamageRegionKHR0(long dpy, long surface, Object rects, int rects_byte_offset, int n_rects, long procAddress);

  /** Entry point to C language function:  EGLBoolean eglSignalSyncKHR(EGLDisplay dpy, EGLSyncKHR sync, EGLenum mode)  
Part of EGL_KHR_reusable_sync
   */
  public boolean eglSignalSyncKHR(long dpy, long sync, int mode)  {

    final long __addr_ = _table._addressof_eglSignalSyncKHR;
    if (__addr_ == 0) {
      throw new UnsupportedOperationException(String.format("Method \"%s\" not available", "eglSignalSyncKHR"));
    }
        return dispatch_eglSignalSyncKHR0(dpy, sync, mode, __addr_);
  }

  /** Entry point to C language function:  EGLBoolean eglSignalSyncKHR(EGLDisplay dpy, EGLSyncKHR sync, EGLenum mode)  
Part of EGL_KHR_reusable_sync
   */
  private native boolean dispatch_eglSignalSyncKHR0(long dpy, long sync, int mode, long procAddress);

  /** Entry point to C language function:  EGLStreamKHR eglCreateStreamKHR(EGLDisplay dpy, const EGLint *  attrib_list)  
Part of EGL_KHR_stream

      @param attrib_list a direct only {@link java.nio.IntBuffer}   */
  public ByteBuffer eglCreateStreamKHR(long dpy, IntBuffer attrib_list)  {

    if (!Buffers.isDirect(attrib_list))
      throw new RuntimeException("Argument \"attrib_list\" is not a direct buffer");
    final long __addr_ = _table._addressof_eglCreateStreamKHR;
    if (__addr_ == 0) {
      throw new UnsupportedOperationException(String.format("Method \"%s\" not available", "eglCreateStreamKHR"));
    }
    final ByteBuffer _res;
    _res = dispatch_eglCreateStreamKHR0(dpy, attrib_list, Buffers.getDirectBufferByteOffset(attrib_list), __addr_);
    if (_res == null) return null;
    Buffers.nativeOrder(_res);
    return _res;
  }

  /** Entry point to C language function:  EGLStreamKHR eglCreateStreamKHR(EGLDisplay dpy, const EGLint *  attrib_list)  
Part of EGL_KHR_stream

      @param attrib_list a direct only {@link java.nio.IntBuffer}   */
  private native ByteBuffer dispatch_eglCreateStreamKHR0(long dpy, Object attrib_list, int attrib_list_byte_offset, long procAddress);

  /** Entry point to C language function:  EGLBoolean eglDestroyStreamKHR(EGLDisplay dpy, EGLStreamKHR stream)  
Part of EGL_KHR_stream

      @param stream a direct only {@link java.nio.Buffer}   */
  public boolean eglDestroyStreamKHR(long dpy, Buffer stream)  {

    if (!Buffers.isDirect(stream))
      throw new RuntimeException("Argument \"stream\" is not a direct buffer");
    final long __addr_ = _table._addressof_eglDestroyStreamKHR;
    if (__addr_ == 0) {
      throw new UnsupportedOperationException(String.format("Method \"%s\" not available", "eglDestroyStreamKHR"));
    }
        return dispatch_eglDestroyStreamKHR0(dpy, stream, Buffers.getDirectBufferByteOffset(stream), __addr_);
  }

  /** Entry point to C language function:  EGLBoolean eglDestroyStreamKHR(EGLDisplay dpy, EGLStreamKHR stream)  
Part of EGL_KHR_stream

      @param stream a direct only {@link java.nio.Buffer}   */
  private native boolean dispatch_eglDestroyStreamKHR0(long dpy, Object stream, int stream_byte_offset, long procAddress);

  /** Entry point to C language function:  EGLBoolean eglStreamAttribKHR(EGLDisplay dpy, EGLStreamKHR stream, EGLenum attribute, EGLint value)  
Part of EGL_KHR_stream

      @param stream a direct only {@link java.nio.Buffer}   */
  public boolean eglStreamAttribKHR(long dpy, Buffer stream, int attribute, int value)  {

    if (!Buffers.isDirect(stream))
      throw new RuntimeException("Argument \"stream\" is not a direct buffer");
    final long __addr_ = _table._addressof_eglStreamAttribKHR;
    if (__addr_ == 0) {
      throw new UnsupportedOperationException(String.format("Method \"%s\" not available", "eglStreamAttribKHR"));
    }
        return dispatch_eglStreamAttribKHR0(dpy, stream, Buffers.getDirectBufferByteOffset(stream), attribute, value, __addr_);
  }

  /** Entry point to C language function:  EGLBoolean eglStreamAttribKHR(EGLDisplay dpy, EGLStreamKHR stream, EGLenum attribute, EGLint value)  
Part of EGL_KHR_stream

      @param stream a direct only {@link java.nio.Buffer}   */
  private native boolean dispatch_eglStreamAttribKHR0(long dpy, Object stream, int stream_byte_offset, int attribute, int value, long procAddress);

  /** Entry point to C language function:  EGLBoolean eglQueryStreamKHR(EGLDisplay dpy, EGLStreamKHR stream, EGLenum attribute, EGLint *  value)  
Part of EGL_KHR_stream

      @param stream a direct only {@link java.nio.Buffer}
      @param value a direct only {@link java.nio.IntBuffer}   */
  public boolean eglQueryStreamKHR(long dpy, Buffer stream, int attribute, IntBuffer value)  {

    if (!Buffers.isDirect(stream))
      throw new RuntimeException("Argument \"stream\" is not a direct buffer");
    if (!Buffers.isDirect(value))
      throw new RuntimeException("Argument \"value\" is not a direct buffer");
    final long __addr_ = _table._addressof_eglQueryStreamKHR;
    if (__addr_ == 0) {
      throw new UnsupportedOperationException(String.format("Method \"%s\" not available", "eglQueryStreamKHR"));
    }
        return dispatch_eglQueryStreamKHR0(dpy, stream, Buffers.getDirectBufferByteOffset(stream), attribute, value, Buffers.getDirectBufferByteOffset(value), __addr_);
  }

  /** Entry point to C language function:  EGLBoolean eglQueryStreamKHR(EGLDisplay dpy, EGLStreamKHR stream, EGLenum attribute, EGLint *  value)  
Part of EGL_KHR_stream

      @param stream a direct only {@link java.nio.Buffer}
      @param value a direct only {@link java.nio.IntBuffer}   */
  private native boolean dispatch_eglQueryStreamKHR0(long dpy, Object stream, int stream_byte_offset, int attribute, Object value, int value_byte_offset, long procAddress);

  /** Entry point to C language function:  EGLBoolean eglQueryStreamu64KHR(EGLDisplay dpy, EGLStreamKHR stream, EGLenum attribute, EGLuint64KHR *  value)  
Part of EGL_KHR_stream

      @param stream a direct only {@link java.nio.Buffer}
      @param value a direct only {@link java.nio.LongBuffer}   */
  public boolean eglQueryStreamu64KHR(long dpy, Buffer stream, int attribute, LongBuffer value)  {

    if (!Buffers.isDirect(stream))
      throw new RuntimeException("Argument \"stream\" is not a direct buffer");
    if (!Buffers.isDirect(value))
      throw new RuntimeException("Argument \"value\" is not a direct buffer");
    final long __addr_ = _table._addressof_eglQueryStreamu64KHR;
    if (__addr_ == 0) {
      throw new UnsupportedOperationException(String.format("Method \"%s\" not available", "eglQueryStreamu64KHR"));
    }
        return dispatch_eglQueryStreamu64KHR0(dpy, stream, Buffers.getDirectBufferByteOffset(stream), attribute, value, Buffers.getDirectBufferByteOffset(value), __addr_);
  }

  /** Entry point to C language function:  EGLBoolean eglQueryStreamu64KHR(EGLDisplay dpy, EGLStreamKHR stream, EGLenum attribute, EGLuint64KHR *  value)  
Part of EGL_KHR_stream

      @param stream a direct only {@link java.nio.Buffer}
      @param value a direct only {@link java.nio.LongBuffer}   */
  private native boolean dispatch_eglQueryStreamu64KHR0(long dpy, Object stream, int stream_byte_offset, int attribute, Object value, int value_byte_offset, long procAddress);

  /** Entry point to C language function:  EGLBoolean eglStreamConsumerGLTextureExternalKHR(EGLDisplay dpy, EGLStreamKHR stream)  
Part of EGL_KHR_stream_consumer_gltexture

      @param stream a direct only {@link java.nio.Buffer}   */
  public boolean eglStreamConsumerGLTextureExternalKHR(long dpy, Buffer stream)  {

    if (!Buffers.isDirect(stream))
      throw new RuntimeException("Argument \"stream\" is not a direct buffer");
    final long __addr_ = _table._addressof_eglStreamConsumerGLTextureExternalKHR;
    if (__addr_ == 0) {
      throw new UnsupportedOperationException(String.format("Method \"%s\" not available", "eglStreamConsumerGLTextureExternalKHR"));
    }
        return dispatch_eglStreamConsumerGLTextureExternalKHR0(dpy, stream, Buffers.getDirectBufferByteOffset(stream), __addr_);
  }

  /** Entry point to C language function:  EGLBoolean eglStreamConsumerGLTextureExternalKHR(EGLDisplay dpy, EGLStreamKHR stream)  
Part of EGL_KHR_stream_consumer_gltexture

      @param stream a direct only {@link java.nio.Buffer}   */
  private native boolean dispatch_eglStreamConsumerGLTextureExternalKHR0(long dpy, Object stream, int stream_byte_offset, long procAddress);

  /** Entry point to C language function:  EGLBoolean eglStreamConsumerAcquireKHR(EGLDisplay dpy, EGLStreamKHR stream)  
Part of EGL_KHR_stream_consumer_gltexture

      @param stream a direct only {@link java.nio.Buffer}   */
  public boolean eglStreamConsumerAcquireKHR(long dpy, Buffer stream)  {

    if (!Buffers.isDirect(stream))
      throw new RuntimeException("Argument \"stream\" is not a direct buffer");
    final long __addr_ = _table._addressof_eglStreamConsumerAcquireKHR;
    if (__addr_ == 0) {
      throw new UnsupportedOperationException(String.format("Method \"%s\" not available", "eglStreamConsumerAcquireKHR"));
    }
        return dispatch_eglStreamConsumerAcquireKHR0(dpy, stream, Buffers.getDirectBufferByteOffset(stream), __addr_);
  }

  /** Entry point to C language function:  EGLBoolean eglStreamConsumerAcquireKHR(EGLDisplay dpy, EGLStreamKHR stream)  
Part of EGL_KHR_stream_consumer_gltexture

      @param stream a direct only {@link java.nio.Buffer}   */
  private native boolean dispatch_eglStreamConsumerAcquireKHR0(long dpy, Object stream, int stream_byte_offset, long procAddress);

  /** Entry point to C language function:  EGLBoolean eglStreamConsumerReleaseKHR(EGLDisplay dpy, EGLStreamKHR stream)  
Part of EGL_KHR_stream_consumer_gltexture

      @param stream a direct only {@link java.nio.Buffer}   */
  public boolean eglStreamConsumerReleaseKHR(long dpy, Buffer stream)  {

    if (!Buffers.isDirect(stream))
      throw new RuntimeException("Argument \"stream\" is not a direct buffer");
    final long __addr_ = _table._addressof_eglStreamConsumerReleaseKHR;
    if (__addr_ == 0) {
      throw new UnsupportedOperationException(String.format("Method \"%s\" not available", "eglStreamConsumerReleaseKHR"));
    }
        return dispatch_eglStreamConsumerReleaseKHR0(dpy, stream, Buffers.getDirectBufferByteOffset(stream), __addr_);
  }

  /** Entry point to C language function:  EGLBoolean eglStreamConsumerReleaseKHR(EGLDisplay dpy, EGLStreamKHR stream)  
Part of EGL_KHR_stream_consumer_gltexture

      @param stream a direct only {@link java.nio.Buffer}   */
  private native boolean dispatch_eglStreamConsumerReleaseKHR0(long dpy, Object stream, int stream_byte_offset, long procAddress);

  /** Entry point to C language function:  EGLNativeFileDescriptorKHR eglGetStreamFileDescriptorKHR(EGLDisplay dpy, EGLStreamKHR stream)  
Part of EGL_KHR_stream_cross_process_fd

      @param stream a direct only {@link java.nio.Buffer}   */
  public int eglGetStreamFileDescriptorKHR(long dpy, Buffer stream)  {

    if (!Buffers.isDirect(stream))
      throw new RuntimeException("Argument \"stream\" is not a direct buffer");
    final long __addr_ = _table._addressof_eglGetStreamFileDescriptorKHR;
    if (__addr_ == 0) {
      throw new UnsupportedOperationException(String.format("Method \"%s\" not available", "eglGetStreamFileDescriptorKHR"));
    }
        return dispatch_eglGetStreamFileDescriptorKHR0(dpy, stream, Buffers.getDirectBufferByteOffset(stream), __addr_);
  }

  /** Entry point to C language function:  EGLNativeFileDescriptorKHR eglGetStreamFileDescriptorKHR(EGLDisplay dpy, EGLStreamKHR stream)  
Part of EGL_KHR_stream_cross_process_fd

      @param stream a direct only {@link java.nio.Buffer}   */
  private native int dispatch_eglGetStreamFileDescriptorKHR0(long dpy, Object stream, int stream_byte_offset, long procAddress);

  /** Entry point to C language function:  EGLStreamKHR eglCreateStreamFromFileDescriptorKHR(EGLDisplay dpy, EGLNativeFileDescriptorKHR file_descriptor)  
Part of EGL_KHR_stream_cross_process_fd
   */
  public ByteBuffer eglCreateStreamFromFileDescriptorKHR(long dpy, int file_descriptor)  {

    final long __addr_ = _table._addressof_eglCreateStreamFromFileDescriptorKHR;
    if (__addr_ == 0) {
      throw new UnsupportedOperationException(String.format("Method \"%s\" not available", "eglCreateStreamFromFileDescriptorKHR"));
    }
    final ByteBuffer _res;
    _res = dispatch_eglCreateStreamFromFileDescriptorKHR0(dpy, file_descriptor, __addr_);
    if (_res == null) return null;
    Buffers.nativeOrder(_res);
    return _res;
  }

  /** Entry point to C language function:  EGLStreamKHR eglCreateStreamFromFileDescriptorKHR(EGLDisplay dpy, EGLNativeFileDescriptorKHR file_descriptor)  
Part of EGL_KHR_stream_cross_process_fd
   */
  private native ByteBuffer dispatch_eglCreateStreamFromFileDescriptorKHR0(long dpy, int file_descriptor, long procAddress);

  /** Entry point to C language function:  EGLBoolean eglQueryStreamTimeKHR(EGLDisplay dpy, EGLStreamKHR stream, EGLenum attribute, EGLTimeKHR *  value)  
Part of EGL_KHR_stream_fifo

      @param stream a direct only {@link java.nio.Buffer}
      @param value a direct only {@link java.nio.LongBuffer}   */
  public boolean eglQueryStreamTimeKHR(long dpy, Buffer stream, int attribute, LongBuffer value)  {

    if (!Buffers.isDirect(stream))
      throw new RuntimeException("Argument \"stream\" is not a direct buffer");
    if (!Buffers.isDirect(value))
      throw new RuntimeException("Argument \"value\" is not a direct buffer");
    final long __addr_ = _table._addressof_eglQueryStreamTimeKHR;
    if (__addr_ == 0) {
      throw new UnsupportedOperationException(String.format("Method \"%s\" not available", "eglQueryStreamTimeKHR"));
    }
        return dispatch_eglQueryStreamTimeKHR0(dpy, stream, Buffers.getDirectBufferByteOffset(stream), attribute, value, Buffers.getDirectBufferByteOffset(value), __addr_);
  }

  /** Entry point to C language function:  EGLBoolean eglQueryStreamTimeKHR(EGLDisplay dpy, EGLStreamKHR stream, EGLenum attribute, EGLTimeKHR *  value)  
Part of EGL_KHR_stream_fifo

      @param stream a direct only {@link java.nio.Buffer}
      @param value a direct only {@link java.nio.LongBuffer}   */
  private native boolean dispatch_eglQueryStreamTimeKHR0(long dpy, Object stream, int stream_byte_offset, int attribute, Object value, int value_byte_offset, long procAddress);

  /** Entry point to C language function:  EGLSurface eglCreateStreamProducerSurfaceKHR(EGLDisplay dpy, EGLConfig config, EGLStreamKHR stream, const EGLint *  attrib_list)  
Part of EGL_KHR_stream_producer_eglsurface

      @param stream a direct only {@link java.nio.Buffer}
      @param attrib_list a direct only {@link java.nio.IntBuffer}   */
  public long eglCreateStreamProducerSurfaceKHR(long dpy, long config, Buffer stream, IntBuffer attrib_list)  {

    if (!Buffers.isDirect(stream))
      throw new RuntimeException("Argument \"stream\" is not a direct buffer");
    if (!Buffers.isDirect(attrib_list))
      throw new RuntimeException("Argument \"attrib_list\" is not a direct buffer");
    final long __addr_ = _table._addressof_eglCreateStreamProducerSurfaceKHR;
    if (__addr_ == 0) {
      throw new UnsupportedOperationException(String.format("Method \"%s\" not available", "eglCreateStreamProducerSurfaceKHR"));
    }
        return dispatch_eglCreateStreamProducerSurfaceKHR0(dpy, config, stream, Buffers.getDirectBufferByteOffset(stream), attrib_list, Buffers.getDirectBufferByteOffset(attrib_list), __addr_);
  }

  /** Entry point to C language function:  EGLSurface eglCreateStreamProducerSurfaceKHR(EGLDisplay dpy, EGLConfig config, EGLStreamKHR stream, const EGLint *  attrib_list)  
Part of EGL_KHR_stream_producer_eglsurface

      @param stream a direct only {@link java.nio.Buffer}
      @param attrib_list a direct only {@link java.nio.IntBuffer}   */
  private native long dispatch_eglCreateStreamProducerSurfaceKHR0(long dpy, long config, Object stream, int stream_byte_offset, Object attrib_list, int attrib_list_byte_offset, long procAddress);

  /** Entry point to C language function:  EGLBoolean eglSwapBuffersWithDamageKHR(EGLDisplay dpy, EGLSurface surface, EGLint *  rects, EGLint n_rects)  
Part of EGL_KHR_swap_buffers_with_damage

      @param rects a direct only {@link java.nio.IntBuffer}   */
  public boolean eglSwapBuffersWithDamageKHR(long dpy, long surface, IntBuffer rects, int n_rects)  {

    if (!Buffers.isDirect(rects))
      throw new RuntimeException("Argument \"rects\" is not a direct buffer");
    final long __addr_ = _table._addressof_eglSwapBuffersWithDamageKHR;
    if (__addr_ == 0) {
      throw new UnsupportedOperationException(String.format("Method \"%s\" not available", "eglSwapBuffersWithDamageKHR"));
    }
        return dispatch_eglSwapBuffersWithDamageKHR0(dpy, surface, rects, Buffers.getDirectBufferByteOffset(rects), n_rects, __addr_);
  }

  /** Entry point to C language function:  EGLBoolean eglSwapBuffersWithDamageKHR(EGLDisplay dpy, EGLSurface surface, EGLint *  rects, EGLint n_rects)  
Part of EGL_KHR_swap_buffers_with_damage

      @param rects a direct only {@link java.nio.IntBuffer}   */
  private native boolean dispatch_eglSwapBuffersWithDamageKHR0(long dpy, long surface, Object rects, int rects_byte_offset, int n_rects, long procAddress);

  /** Entry point to C language function:  EGLint eglWaitSyncKHR(EGLDisplay dpy, EGLSyncKHR sync, EGLint flags)  
Part of EGL_KHR_wait_sync
   */
  public int eglWaitSyncKHR(long dpy, long sync, int flags)  {

    final long __addr_ = _table._addressof_eglWaitSyncKHR;
    if (__addr_ == 0) {
      throw new UnsupportedOperationException(String.format("Method \"%s\" not available", "eglWaitSyncKHR"));
    }
        return dispatch_eglWaitSyncKHR0(dpy, sync, flags, __addr_);
  }

  /** Entry point to C language function:  EGLint eglWaitSyncKHR(EGLDisplay dpy, EGLSyncKHR sync, EGLint flags)  
Part of EGL_KHR_wait_sync
   */
  private native int dispatch_eglWaitSyncKHR0(long dpy, long sync, int flags, long procAddress);

  /** Entry point to C language function:  EGLint eglDupNativeFenceFDANDROID(EGLDisplay dpy, EGLSyncKHR sync)  
Part of EGL_ANDROID_native_fence_sync
   */
  public int eglDupNativeFenceFDANDROID(long dpy, long sync)  {

    final long __addr_ = _table._addressof_eglDupNativeFenceFDANDROID;
    if (__addr_ == 0) {
      throw new UnsupportedOperationException(String.format("Method \"%s\" not available", "eglDupNativeFenceFDANDROID"));
    }
        return dispatch_eglDupNativeFenceFDANDROID0(dpy, sync, __addr_);
  }

  /** Entry point to C language function:  EGLint eglDupNativeFenceFDANDROID(EGLDisplay dpy, EGLSyncKHR sync)  
Part of EGL_ANDROID_native_fence_sync
   */
  private native int dispatch_eglDupNativeFenceFDANDROID0(long dpy, long sync, long procAddress);

  /** Entry point to C language function:  EGLBoolean eglQuerySurfacePointerANGLE(EGLDisplay dpy, EGLSurface surface, EGLint attribute, void *  *  value)  
Part of EGL_ANGLE_query_surface_pointer

      @param value a direct only {@link com.jogamp.common.nio.PointerBuffer}   */
  public boolean eglQuerySurfacePointerANGLE(long dpy, long surface, int attribute, PointerBuffer value)  {

    if (!Buffers.isDirect(value))
      throw new RuntimeException("Argument \"value\" is not a direct buffer");
    final long __addr_ = _table._addressof_eglQuerySurfacePointerANGLE;
    if (__addr_ == 0) {
      throw new UnsupportedOperationException(String.format("Method \"%s\" not available", "eglQuerySurfacePointerANGLE"));
    }
        return dispatch_eglQuerySurfacePointerANGLE0(dpy, surface, attribute, value != null ? value.getBuffer() : null, Buffers.getDirectBufferByteOffset(value), __addr_);
  }

  /** Entry point to C language function:  EGLBoolean eglQuerySurfacePointerANGLE(EGLDisplay dpy, EGLSurface surface, EGLint attribute, void *  *  value)  
Part of EGL_ANGLE_query_surface_pointer

      @param value a direct only {@link com.jogamp.common.nio.PointerBuffer}   */
  private native boolean dispatch_eglQuerySurfacePointerANGLE0(long dpy, long surface, int attribute, Object value, int value_byte_offset, long procAddress);

  /** Entry point to C language function:  EGLBoolean eglQueryDeviceAttribEXT(EGLDeviceEXT device, EGLint attribute, EGLAttrib *  value)  
Part of EGL_EXT_device_base

      @param device a direct only {@link java.nio.Buffer}
      @param value a direct only {@link com.jogamp.common.nio.PointerBuffer}   */
  public boolean eglQueryDeviceAttribEXT(Buffer device, int attribute, PointerBuffer value)  {

    if (!Buffers.isDirect(device))
      throw new RuntimeException("Argument \"device\" is not a direct buffer");
    if (!Buffers.isDirect(value))
      throw new RuntimeException("Argument \"value\" is not a direct buffer");
    final long __addr_ = _table._addressof_eglQueryDeviceAttribEXT;
    if (__addr_ == 0) {
      throw new UnsupportedOperationException(String.format("Method \"%s\" not available", "eglQueryDeviceAttribEXT"));
    }
        return dispatch_eglQueryDeviceAttribEXT0(device, Buffers.getDirectBufferByteOffset(device), attribute, value != null ? value.getBuffer() : null, Buffers.getDirectBufferByteOffset(value), __addr_);
  }

  /** Entry point to C language function:  EGLBoolean eglQueryDeviceAttribEXT(EGLDeviceEXT device, EGLint attribute, EGLAttrib *  value)  
Part of EGL_EXT_device_base

      @param device a direct only {@link java.nio.Buffer}
      @param value a direct only {@link com.jogamp.common.nio.PointerBuffer}   */
  private native boolean dispatch_eglQueryDeviceAttribEXT0(Object device, int device_byte_offset, int attribute, Object value, int value_byte_offset, long procAddress);

  /** Entry point to C language function:  const char *  eglQueryDeviceStringEXT(EGLDeviceEXT device, EGLint name)  
Part of EGL_EXT_device_base

      @param device a direct only {@link java.nio.Buffer}   */
  public ByteBuffer eglQueryDeviceStringEXT(Buffer device, int name)  {

    if (!Buffers.isDirect(device))
      throw new RuntimeException("Argument \"device\" is not a direct buffer");
    final long __addr_ = _table._addressof_eglQueryDeviceStringEXT;
    if (__addr_ == 0) {
      throw new UnsupportedOperationException(String.format("Method \"%s\" not available", "eglQueryDeviceStringEXT"));
    }
    final ByteBuffer _res;
    _res = dispatch_eglQueryDeviceStringEXT0(device, Buffers.getDirectBufferByteOffset(device), name, __addr_);
    if (_res == null) return null;
    Buffers.nativeOrder(_res);
    return _res;
  }

  /** Entry point to C language function:  const char *  eglQueryDeviceStringEXT(EGLDeviceEXT device, EGLint name)  
Part of EGL_EXT_device_base

      @param device a direct only {@link java.nio.Buffer}   */
  private native ByteBuffer dispatch_eglQueryDeviceStringEXT0(Object device, int device_byte_offset, int name, long procAddress);

  /** Entry point to C language function:  EGLBoolean eglQueryDevicesEXT(EGLint max_devices, EGLDeviceEXT *  devices, EGLint *  num_devices)  
Part of EGL_EXT_device_base

      @param devices a direct only {@link com.jogamp.common.nio.PointerBuffer}
      @param num_devices a direct only {@link java.nio.IntBuffer}   */
  public boolean eglQueryDevicesEXT(int max_devices, PointerBuffer devices, IntBuffer num_devices)  {

    if (!Buffers.isDirect(devices))
      throw new RuntimeException("Argument \"devices\" is not a direct buffer");
    if (!Buffers.isDirect(num_devices))
      throw new RuntimeException("Argument \"num_devices\" is not a direct buffer");
    final long __addr_ = _table._addressof_eglQueryDevicesEXT;
    if (__addr_ == 0) {
      throw new UnsupportedOperationException(String.format("Method \"%s\" not available", "eglQueryDevicesEXT"));
    }
        return dispatch_eglQueryDevicesEXT0(max_devices, devices != null ? devices.getBuffer() : null, Buffers.getDirectBufferByteOffset(devices), num_devices, Buffers.getDirectBufferByteOffset(num_devices), __addr_);
  }

  /** Entry point to C language function:  EGLBoolean eglQueryDevicesEXT(EGLint max_devices, EGLDeviceEXT *  devices, EGLint *  num_devices)  
Part of EGL_EXT_device_base

      @param devices a direct only {@link com.jogamp.common.nio.PointerBuffer}
      @param num_devices a direct only {@link java.nio.IntBuffer}   */
  private native boolean dispatch_eglQueryDevicesEXT0(int max_devices, Object devices, int devices_byte_offset, Object num_devices, int num_devices_byte_offset, long procAddress);

  /** Entry point to C language function:  EGLBoolean eglQueryDisplayAttribEXT(EGLDisplay dpy, EGLint attribute, EGLAttrib *  value)  
Part of EGL_EXT_device_base

      @param value a direct only {@link com.jogamp.common.nio.PointerBuffer}   */
  public boolean eglQueryDisplayAttribEXT(long dpy, int attribute, PointerBuffer value)  {

    if (!Buffers.isDirect(value))
      throw new RuntimeException("Argument \"value\" is not a direct buffer");
    final long __addr_ = _table._addressof_eglQueryDisplayAttribEXT;
    if (__addr_ == 0) {
      throw new UnsupportedOperationException(String.format("Method \"%s\" not available", "eglQueryDisplayAttribEXT"));
    }
        return dispatch_eglQueryDisplayAttribEXT0(dpy, attribute, value != null ? value.getBuffer() : null, Buffers.getDirectBufferByteOffset(value), __addr_);
  }

  /** Entry point to C language function:  EGLBoolean eglQueryDisplayAttribEXT(EGLDisplay dpy, EGLint attribute, EGLAttrib *  value)  
Part of EGL_EXT_device_base

      @param value a direct only {@link com.jogamp.common.nio.PointerBuffer}   */
  private native boolean dispatch_eglQueryDisplayAttribEXT0(long dpy, int attribute, Object value, int value_byte_offset, long procAddress);

  /** Entry point to C language function:  EGLBoolean eglGetOutputLayersEXT(EGLDisplay dpy, const EGLAttrib *  attrib_list, EGLOutputLayerEXT *  layers, EGLint max_layers, EGLint *  num_layers)  
Part of EGL_EXT_output_base

      @param attrib_list a direct only {@link com.jogamp.common.nio.PointerBuffer}
      @param layers a direct only {@link com.jogamp.common.nio.PointerBuffer}
      @param num_layers a direct only {@link java.nio.IntBuffer}   */
  public boolean eglGetOutputLayersEXT(long dpy, PointerBuffer attrib_list, PointerBuffer layers, int max_layers, IntBuffer num_layers)  {

    if (!Buffers.isDirect(attrib_list))
      throw new RuntimeException("Argument \"attrib_list\" is not a direct buffer");
    if (!Buffers.isDirect(layers))
      throw new RuntimeException("Argument \"layers\" is not a direct buffer");
    if (!Buffers.isDirect(num_layers))
      throw new RuntimeException("Argument \"num_layers\" is not a direct buffer");
    final long __addr_ = _table._addressof_eglGetOutputLayersEXT;
    if (__addr_ == 0) {
      throw new UnsupportedOperationException(String.format("Method \"%s\" not available", "eglGetOutputLayersEXT"));
    }
        return dispatch_eglGetOutputLayersEXT0(dpy, attrib_list != null ? attrib_list.getBuffer() : null, Buffers.getDirectBufferByteOffset(attrib_list), layers != null ? layers.getBuffer() : null, Buffers.getDirectBufferByteOffset(layers), max_layers, num_layers, Buffers.getDirectBufferByteOffset(num_layers), __addr_);
  }

  /** Entry point to C language function:  EGLBoolean eglGetOutputLayersEXT(EGLDisplay dpy, const EGLAttrib *  attrib_list, EGLOutputLayerEXT *  layers, EGLint max_layers, EGLint *  num_layers)  
Part of EGL_EXT_output_base

      @param attrib_list a direct only {@link com.jogamp.common.nio.PointerBuffer}
      @param layers a direct only {@link com.jogamp.common.nio.PointerBuffer}
      @param num_layers a direct only {@link java.nio.IntBuffer}   */
  private native boolean dispatch_eglGetOutputLayersEXT0(long dpy, Object attrib_list, int attrib_list_byte_offset, Object layers, int layers_byte_offset, int max_layers, Object num_layers, int num_layers_byte_offset, long procAddress);

  /** Entry point to C language function:  EGLBoolean eglGetOutputPortsEXT(EGLDisplay dpy, const EGLAttrib *  attrib_list, EGLOutputPortEXT *  ports, EGLint max_ports, EGLint *  num_ports)  
Part of EGL_EXT_output_base

      @param attrib_list a direct only {@link com.jogamp.common.nio.PointerBuffer}
      @param ports a direct only {@link com.jogamp.common.nio.PointerBuffer}
      @param num_ports a direct only {@link java.nio.IntBuffer}   */
  public boolean eglGetOutputPortsEXT(long dpy, PointerBuffer attrib_list, PointerBuffer ports, int max_ports, IntBuffer num_ports)  {

    if (!Buffers.isDirect(attrib_list))
      throw new RuntimeException("Argument \"attrib_list\" is not a direct buffer");
    if (!Buffers.isDirect(ports))
      throw new RuntimeException("Argument \"ports\" is not a direct buffer");
    if (!Buffers.isDirect(num_ports))
      throw new RuntimeException("Argument \"num_ports\" is not a direct buffer");
    final long __addr_ = _table._addressof_eglGetOutputPortsEXT;
    if (__addr_ == 0) {
      throw new UnsupportedOperationException(String.format("Method \"%s\" not available", "eglGetOutputPortsEXT"));
    }
        return dispatch_eglGetOutputPortsEXT0(dpy, attrib_list != null ? attrib_list.getBuffer() : null, Buffers.getDirectBufferByteOffset(attrib_list), ports != null ? ports.getBuffer() : null, Buffers.getDirectBufferByteOffset(ports), max_ports, num_ports, Buffers.getDirectBufferByteOffset(num_ports), __addr_);
  }

  /** Entry point to C language function:  EGLBoolean eglGetOutputPortsEXT(EGLDisplay dpy, const EGLAttrib *  attrib_list, EGLOutputPortEXT *  ports, EGLint max_ports, EGLint *  num_ports)  
Part of EGL_EXT_output_base

      @param attrib_list a direct only {@link com.jogamp.common.nio.PointerBuffer}
      @param ports a direct only {@link com.jogamp.common.nio.PointerBuffer}
      @param num_ports a direct only {@link java.nio.IntBuffer}   */
  private native boolean dispatch_eglGetOutputPortsEXT0(long dpy, Object attrib_list, int attrib_list_byte_offset, Object ports, int ports_byte_offset, int max_ports, Object num_ports, int num_ports_byte_offset, long procAddress);

  /** Entry point to C language function:  EGLBoolean eglOutputLayerAttribEXT(EGLDisplay dpy, EGLOutputLayerEXT layer, EGLint attribute, EGLAttrib value)  
Part of EGL_EXT_output_base

      @param layer a direct only {@link java.nio.Buffer}   */
  public boolean eglOutputLayerAttribEXT(long dpy, Buffer layer, int attribute, long value)  {

    if (!Buffers.isDirect(layer))
      throw new RuntimeException("Argument \"layer\" is not a direct buffer");
    final long __addr_ = _table._addressof_eglOutputLayerAttribEXT;
    if (__addr_ == 0) {
      throw new UnsupportedOperationException(String.format("Method \"%s\" not available", "eglOutputLayerAttribEXT"));
    }
        return dispatch_eglOutputLayerAttribEXT0(dpy, layer, Buffers.getDirectBufferByteOffset(layer), attribute, value, __addr_);
  }

  /** Entry point to C language function:  EGLBoolean eglOutputLayerAttribEXT(EGLDisplay dpy, EGLOutputLayerEXT layer, EGLint attribute, EGLAttrib value)  
Part of EGL_EXT_output_base

      @param layer a direct only {@link java.nio.Buffer}   */
  private native boolean dispatch_eglOutputLayerAttribEXT0(long dpy, Object layer, int layer_byte_offset, int attribute, long value, long procAddress);

  /** Entry point to C language function:  EGLBoolean eglQueryOutputLayerAttribEXT(EGLDisplay dpy, EGLOutputLayerEXT layer, EGLint attribute, EGLAttrib *  value)  
Part of EGL_EXT_output_base

      @param layer a direct only {@link java.nio.Buffer}
      @param value a direct only {@link com.jogamp.common.nio.PointerBuffer}   */
  public boolean eglQueryOutputLayerAttribEXT(long dpy, Buffer layer, int attribute, PointerBuffer value)  {

    if (!Buffers.isDirect(layer))
      throw new RuntimeException("Argument \"layer\" is not a direct buffer");
    if (!Buffers.isDirect(value))
      throw new RuntimeException("Argument \"value\" is not a direct buffer");
    final long __addr_ = _table._addressof_eglQueryOutputLayerAttribEXT;
    if (__addr_ == 0) {
      throw new UnsupportedOperationException(String.format("Method \"%s\" not available", "eglQueryOutputLayerAttribEXT"));
    }
        return dispatch_eglQueryOutputLayerAttribEXT0(dpy, layer, Buffers.getDirectBufferByteOffset(layer), attribute, value != null ? value.getBuffer() : null, Buffers.getDirectBufferByteOffset(value), __addr_);
  }

  /** Entry point to C language function:  EGLBoolean eglQueryOutputLayerAttribEXT(EGLDisplay dpy, EGLOutputLayerEXT layer, EGLint attribute, EGLAttrib *  value)  
Part of EGL_EXT_output_base

      @param layer a direct only {@link java.nio.Buffer}
      @param value a direct only {@link com.jogamp.common.nio.PointerBuffer}   */
  private native boolean dispatch_eglQueryOutputLayerAttribEXT0(long dpy, Object layer, int layer_byte_offset, int attribute, Object value, int value_byte_offset, long procAddress);

  /** Entry point to C language function:  const char *  eglQueryOutputLayerStringEXT(EGLDisplay dpy, EGLOutputLayerEXT layer, EGLint name)  
Part of EGL_EXT_output_base

      @param layer a direct only {@link java.nio.Buffer}   */
  public ByteBuffer eglQueryOutputLayerStringEXT(long dpy, Buffer layer, int name)  {

    if (!Buffers.isDirect(layer))
      throw new RuntimeException("Argument \"layer\" is not a direct buffer");
    final long __addr_ = _table._addressof_eglQueryOutputLayerStringEXT;
    if (__addr_ == 0) {
      throw new UnsupportedOperationException(String.format("Method \"%s\" not available", "eglQueryOutputLayerStringEXT"));
    }
    final ByteBuffer _res;
    _res = dispatch_eglQueryOutputLayerStringEXT0(dpy, layer, Buffers.getDirectBufferByteOffset(layer), name, __addr_);
    if (_res == null) return null;
    Buffers.nativeOrder(_res);
    return _res;
  }

  /** Entry point to C language function:  const char *  eglQueryOutputLayerStringEXT(EGLDisplay dpy, EGLOutputLayerEXT layer, EGLint name)  
Part of EGL_EXT_output_base

      @param layer a direct only {@link java.nio.Buffer}   */
  private native ByteBuffer dispatch_eglQueryOutputLayerStringEXT0(long dpy, Object layer, int layer_byte_offset, int name, long procAddress);

  /** Entry point to C language function:  EGLBoolean eglOutputPortAttribEXT(EGLDisplay dpy, EGLOutputPortEXT port, EGLint attribute, EGLAttrib value)  
Part of EGL_EXT_output_base

      @param port a direct only {@link java.nio.Buffer}   */
  public boolean eglOutputPortAttribEXT(long dpy, Buffer port, int attribute, long value)  {

    if (!Buffers.isDirect(port))
      throw new RuntimeException("Argument \"port\" is not a direct buffer");
    final long __addr_ = _table._addressof_eglOutputPortAttribEXT;
    if (__addr_ == 0) {
      throw new UnsupportedOperationException(String.format("Method \"%s\" not available", "eglOutputPortAttribEXT"));
    }
        return dispatch_eglOutputPortAttribEXT0(dpy, port, Buffers.getDirectBufferByteOffset(port), attribute, value, __addr_);
  }

  /** Entry point to C language function:  EGLBoolean eglOutputPortAttribEXT(EGLDisplay dpy, EGLOutputPortEXT port, EGLint attribute, EGLAttrib value)  
Part of EGL_EXT_output_base

      @param port a direct only {@link java.nio.Buffer}   */
  private native boolean dispatch_eglOutputPortAttribEXT0(long dpy, Object port, int port_byte_offset, int attribute, long value, long procAddress);

  /** Entry point to C language function:  EGLBoolean eglQueryOutputPortAttribEXT(EGLDisplay dpy, EGLOutputPortEXT port, EGLint attribute, EGLAttrib *  value)  
Part of EGL_EXT_output_base

      @param port a direct only {@link java.nio.Buffer}
      @param value a direct only {@link com.jogamp.common.nio.PointerBuffer}   */
  public boolean eglQueryOutputPortAttribEXT(long dpy, Buffer port, int attribute, PointerBuffer value)  {

    if (!Buffers.isDirect(port))
      throw new RuntimeException("Argument \"port\" is not a direct buffer");
    if (!Buffers.isDirect(value))
      throw new RuntimeException("Argument \"value\" is not a direct buffer");
    final long __addr_ = _table._addressof_eglQueryOutputPortAttribEXT;
    if (__addr_ == 0) {
      throw new UnsupportedOperationException(String.format("Method \"%s\" not available", "eglQueryOutputPortAttribEXT"));
    }
        return dispatch_eglQueryOutputPortAttribEXT0(dpy, port, Buffers.getDirectBufferByteOffset(port), attribute, value != null ? value.getBuffer() : null, Buffers.getDirectBufferByteOffset(value), __addr_);
  }

  /** Entry point to C language function:  EGLBoolean eglQueryOutputPortAttribEXT(EGLDisplay dpy, EGLOutputPortEXT port, EGLint attribute, EGLAttrib *  value)  
Part of EGL_EXT_output_base

      @param port a direct only {@link java.nio.Buffer}
      @param value a direct only {@link com.jogamp.common.nio.PointerBuffer}   */
  private native boolean dispatch_eglQueryOutputPortAttribEXT0(long dpy, Object port, int port_byte_offset, int attribute, Object value, int value_byte_offset, long procAddress);

  /** Entry point to C language function:  const char *  eglQueryOutputPortStringEXT(EGLDisplay dpy, EGLOutputPortEXT port, EGLint name)  
Part of EGL_EXT_output_base

      @param port a direct only {@link java.nio.Buffer}   */
  public ByteBuffer eglQueryOutputPortStringEXT(long dpy, Buffer port, int name)  {

    if (!Buffers.isDirect(port))
      throw new RuntimeException("Argument \"port\" is not a direct buffer");
    final long __addr_ = _table._addressof_eglQueryOutputPortStringEXT;
    if (__addr_ == 0) {
      throw new UnsupportedOperationException(String.format("Method \"%s\" not available", "eglQueryOutputPortStringEXT"));
    }
    final ByteBuffer _res;
    _res = dispatch_eglQueryOutputPortStringEXT0(dpy, port, Buffers.getDirectBufferByteOffset(port), name, __addr_);
    if (_res == null) return null;
    Buffers.nativeOrder(_res);
    return _res;
  }

  /** Entry point to C language function:  const char *  eglQueryOutputPortStringEXT(EGLDisplay dpy, EGLOutputPortEXT port, EGLint name)  
Part of EGL_EXT_output_base

      @param port a direct only {@link java.nio.Buffer}   */
  private native ByteBuffer dispatch_eglQueryOutputPortStringEXT0(long dpy, Object port, int port_byte_offset, int name, long procAddress);

  /** Entry point to C language function:  EGLDisplay eglGetPlatformDisplayEXT(EGLenum platform, void *  native_display, const EGLint *  attrib_list)  
Part of EGL_EXT_platform_base

      @param native_display a direct only {@link java.nio.Buffer}
      @param attrib_list a direct only {@link java.nio.IntBuffer}   */
  public long eglGetPlatformDisplayEXT(int platform, Buffer native_display, IntBuffer attrib_list)  {

    if (!Buffers.isDirect(native_display))
      throw new RuntimeException("Argument \"native_display\" is not a direct buffer");
    if (!Buffers.isDirect(attrib_list))
      throw new RuntimeException("Argument \"attrib_list\" is not a direct buffer");
    final long __addr_ = _table._addressof_eglGetPlatformDisplayEXT;
    if (__addr_ == 0) {
      throw new UnsupportedOperationException(String.format("Method \"%s\" not available", "eglGetPlatformDisplayEXT"));
    }
        return dispatch_eglGetPlatformDisplayEXT0(platform, native_display, Buffers.getDirectBufferByteOffset(native_display), attrib_list, Buffers.getDirectBufferByteOffset(attrib_list), __addr_);
  }

  /** Entry point to C language function:  EGLDisplay eglGetPlatformDisplayEXT(EGLenum platform, void *  native_display, const EGLint *  attrib_list)  
Part of EGL_EXT_platform_base

      @param native_display a direct only {@link java.nio.Buffer}
      @param attrib_list a direct only {@link java.nio.IntBuffer}   */
  private native long dispatch_eglGetPlatformDisplayEXT0(int platform, Object native_display, int native_display_byte_offset, Object attrib_list, int attrib_list_byte_offset, long procAddress);

  /** Entry point to C language function:  EGLSurface eglCreatePlatformWindowSurfaceEXT(EGLDisplay dpy, EGLConfig config, void *  native_window, const EGLint *  attrib_list)  
Part of EGL_EXT_platform_base

      @param native_window a direct only {@link java.nio.Buffer}
      @param attrib_list a direct only {@link java.nio.IntBuffer}   */
  public long eglCreatePlatformWindowSurfaceEXT(long dpy, long config, Buffer native_window, IntBuffer attrib_list)  {

    if (!Buffers.isDirect(native_window))
      throw new RuntimeException("Argument \"native_window\" is not a direct buffer");
    if (!Buffers.isDirect(attrib_list))
      throw new RuntimeException("Argument \"attrib_list\" is not a direct buffer");
    final long __addr_ = _table._addressof_eglCreatePlatformWindowSurfaceEXT;
    if (__addr_ == 0) {
      throw new UnsupportedOperationException(String.format("Method \"%s\" not available", "eglCreatePlatformWindowSurfaceEXT"));
    }
        return dispatch_eglCreatePlatformWindowSurfaceEXT0(dpy, config, native_window, Buffers.getDirectBufferByteOffset(native_window), attrib_list, Buffers.getDirectBufferByteOffset(attrib_list), __addr_);
  }

  /** Entry point to C language function:  EGLSurface eglCreatePlatformWindowSurfaceEXT(EGLDisplay dpy, EGLConfig config, void *  native_window, const EGLint *  attrib_list)  
Part of EGL_EXT_platform_base

      @param native_window a direct only {@link java.nio.Buffer}
      @param attrib_list a direct only {@link java.nio.IntBuffer}   */
  private native long dispatch_eglCreatePlatformWindowSurfaceEXT0(long dpy, long config, Object native_window, int native_window_byte_offset, Object attrib_list, int attrib_list_byte_offset, long procAddress);

  /** Entry point to C language function:  EGLSurface eglCreatePlatformPixmapSurfaceEXT(EGLDisplay dpy, EGLConfig config, void *  native_pixmap, const EGLint *  attrib_list)  
Part of EGL_EXT_platform_base

      @param native_pixmap a direct only {@link java.nio.Buffer}
      @param attrib_list a direct only {@link java.nio.IntBuffer}   */
  public long eglCreatePlatformPixmapSurfaceEXT(long dpy, long config, Buffer native_pixmap, IntBuffer attrib_list)  {

    if (!Buffers.isDirect(native_pixmap))
      throw new RuntimeException("Argument \"native_pixmap\" is not a direct buffer");
    if (!Buffers.isDirect(attrib_list))
      throw new RuntimeException("Argument \"attrib_list\" is not a direct buffer");
    final long __addr_ = _table._addressof_eglCreatePlatformPixmapSurfaceEXT;
    if (__addr_ == 0) {
      throw new UnsupportedOperationException(String.format("Method \"%s\" not available", "eglCreatePlatformPixmapSurfaceEXT"));
    }
        return dispatch_eglCreatePlatformPixmapSurfaceEXT0(dpy, config, native_pixmap, Buffers.getDirectBufferByteOffset(native_pixmap), attrib_list, Buffers.getDirectBufferByteOffset(attrib_list), __addr_);
  }

  /** Entry point to C language function:  EGLSurface eglCreatePlatformPixmapSurfaceEXT(EGLDisplay dpy, EGLConfig config, void *  native_pixmap, const EGLint *  attrib_list)  
Part of EGL_EXT_platform_base

      @param native_pixmap a direct only {@link java.nio.Buffer}
      @param attrib_list a direct only {@link java.nio.IntBuffer}   */
  private native long dispatch_eglCreatePlatformPixmapSurfaceEXT0(long dpy, long config, Object native_pixmap, int native_pixmap_byte_offset, Object attrib_list, int attrib_list_byte_offset, long procAddress);

  /** Entry point to C language function:  EGLBoolean eglStreamConsumerOutputEXT(EGLDisplay dpy, EGLStreamKHR stream, EGLOutputLayerEXT layer)  
Part of EGL_EXT_stream_consumer_egloutput

      @param stream a direct only {@link java.nio.Buffer}
      @param layer a direct only {@link java.nio.Buffer}   */
  public boolean eglStreamConsumerOutputEXT(long dpy, Buffer stream, Buffer layer)  {

    if (!Buffers.isDirect(stream))
      throw new RuntimeException("Argument \"stream\" is not a direct buffer");
    if (!Buffers.isDirect(layer))
      throw new RuntimeException("Argument \"layer\" is not a direct buffer");
    final long __addr_ = _table._addressof_eglStreamConsumerOutputEXT;
    if (__addr_ == 0) {
      throw new UnsupportedOperationException(String.format("Method \"%s\" not available", "eglStreamConsumerOutputEXT"));
    }
        return dispatch_eglStreamConsumerOutputEXT0(dpy, stream, Buffers.getDirectBufferByteOffset(stream), layer, Buffers.getDirectBufferByteOffset(layer), __addr_);
  }

  /** Entry point to C language function:  EGLBoolean eglStreamConsumerOutputEXT(EGLDisplay dpy, EGLStreamKHR stream, EGLOutputLayerEXT layer)  
Part of EGL_EXT_stream_consumer_egloutput

      @param stream a direct only {@link java.nio.Buffer}
      @param layer a direct only {@link java.nio.Buffer}   */
  private native boolean dispatch_eglStreamConsumerOutputEXT0(long dpy, Object stream, int stream_byte_offset, Object layer, int layer_byte_offset, long procAddress);

  /** Entry point to C language function:  EGLBoolean eglSwapBuffersWithDamageEXT(EGLDisplay dpy, EGLSurface surface, EGLint *  rects, EGLint n_rects)  
Part of EGL_EXT_swap_buffers_with_damage

      @param rects a direct only {@link java.nio.IntBuffer}   */
  public boolean eglSwapBuffersWithDamageEXT(long dpy, long surface, IntBuffer rects, int n_rects)  {

    if (!Buffers.isDirect(rects))
      throw new RuntimeException("Argument \"rects\" is not a direct buffer");
    final long __addr_ = _table._addressof_eglSwapBuffersWithDamageEXT;
    if (__addr_ == 0) {
      throw new UnsupportedOperationException(String.format("Method \"%s\" not available", "eglSwapBuffersWithDamageEXT"));
    }
        return dispatch_eglSwapBuffersWithDamageEXT0(dpy, surface, rects, Buffers.getDirectBufferByteOffset(rects), n_rects, __addr_);
  }

  /** Entry point to C language function:  EGLBoolean eglSwapBuffersWithDamageEXT(EGLDisplay dpy, EGLSurface surface, EGLint *  rects, EGLint n_rects)  
Part of EGL_EXT_swap_buffers_with_damage

      @param rects a direct only {@link java.nio.IntBuffer}   */
  private native boolean dispatch_eglSwapBuffersWithDamageEXT0(long dpy, long surface, Object rects, int rects_byte_offset, int n_rects, long procAddress);

  /** Entry point to C language function:  EGLSurface eglCreatePixmapSurfaceHI(EGLDisplay dpy, EGLConfig config, struct EGLClientPixmapHI *  pixmap)  
Part of EGL_HI_clientpixmap
   */
  public long eglCreatePixmapSurfaceHI(long dpy, long config, EGLClientPixmapHI pixmap)  {

    final long __addr_ = _table._addressof_eglCreatePixmapSurfaceHI;
    if (__addr_ == 0) {
      throw new UnsupportedOperationException(String.format("Method \"%s\" not available", "eglCreatePixmapSurfaceHI"));
    }
        return dispatch_eglCreatePixmapSurfaceHI0(dpy, config, ((pixmap == null) ? null : pixmap.getBuffer()), __addr_);
  }

  /** Entry point to C language function:  EGLSurface eglCreatePixmapSurfaceHI(EGLDisplay dpy, EGLConfig config, struct EGLClientPixmapHI *  pixmap)  
Part of EGL_HI_clientpixmap
   */
  private native long dispatch_eglCreatePixmapSurfaceHI0(long dpy, long config, ByteBuffer pixmap, long procAddress);

  /** Entry point to C language function:  EGLImageKHR eglCreateDRMImageMESA(EGLDisplay dpy, const EGLint *  attrib_list)  
Part of EGL_MESA_drm_image

      @param attrib_list a direct only {@link java.nio.IntBuffer}   */
  public long eglCreateDRMImageMESA(long dpy, IntBuffer attrib_list)  {

    if (!Buffers.isDirect(attrib_list))
      throw new RuntimeException("Argument \"attrib_list\" is not a direct buffer");
    final long __addr_ = _table._addressof_eglCreateDRMImageMESA;
    if (__addr_ == 0) {
      throw new UnsupportedOperationException(String.format("Method \"%s\" not available", "eglCreateDRMImageMESA"));
    }
        return dispatch_eglCreateDRMImageMESA0(dpy, attrib_list, Buffers.getDirectBufferByteOffset(attrib_list), __addr_);
  }

  /** Entry point to C language function:  EGLImageKHR eglCreateDRMImageMESA(EGLDisplay dpy, const EGLint *  attrib_list)  
Part of EGL_MESA_drm_image

      @param attrib_list a direct only {@link java.nio.IntBuffer}   */
  private native long dispatch_eglCreateDRMImageMESA0(long dpy, Object attrib_list, int attrib_list_byte_offset, long procAddress);

  /** Entry point to C language function:  EGLBoolean eglExportDRMImageMESA(EGLDisplay dpy, EGLImageKHR image, EGLint *  name, EGLint *  handle, EGLint *  stride)  
Part of EGL_MESA_drm_image

      @param name a direct only {@link java.nio.IntBuffer}
      @param handle a direct only {@link java.nio.IntBuffer}
      @param stride a direct only {@link java.nio.IntBuffer}   */
  public boolean eglExportDRMImageMESA(long dpy, long image, IntBuffer name, IntBuffer handle, IntBuffer stride)  {

    if (!Buffers.isDirect(name))
      throw new RuntimeException("Argument \"name\" is not a direct buffer");
    if (!Buffers.isDirect(handle))
      throw new RuntimeException("Argument \"handle\" is not a direct buffer");
    if (!Buffers.isDirect(stride))
      throw new RuntimeException("Argument \"stride\" is not a direct buffer");
    final long __addr_ = _table._addressof_eglExportDRMImageMESA;
    if (__addr_ == 0) {
      throw new UnsupportedOperationException(String.format("Method \"%s\" not available", "eglExportDRMImageMESA"));
    }
        return dispatch_eglExportDRMImageMESA0(dpy, image, name, Buffers.getDirectBufferByteOffset(name), handle, Buffers.getDirectBufferByteOffset(handle), stride, Buffers.getDirectBufferByteOffset(stride), __addr_);
  }

  /** Entry point to C language function:  EGLBoolean eglExportDRMImageMESA(EGLDisplay dpy, EGLImageKHR image, EGLint *  name, EGLint *  handle, EGLint *  stride)  
Part of EGL_MESA_drm_image

      @param name a direct only {@link java.nio.IntBuffer}
      @param handle a direct only {@link java.nio.IntBuffer}
      @param stride a direct only {@link java.nio.IntBuffer}   */
  private native boolean dispatch_eglExportDRMImageMESA0(long dpy, long image, Object name, int name_byte_offset, Object handle, int handle_byte_offset, Object stride, int stride_byte_offset, long procAddress);

  /** Entry point to C language function:  EGLBoolean eglExportDMABUFImageQueryMESA(EGLDisplay dpy, EGLImageKHR image, int *  fourcc, int *  num_planes, EGLuint64KHR *  modifiers)  
Part of EGL_MESA_image_dma_buf_export

      @param fourcc a direct only {@link java.nio.IntBuffer}
      @param num_planes a direct only {@link java.nio.IntBuffer}
      @param modifiers a direct only {@link java.nio.LongBuffer}   */
  public boolean eglExportDMABUFImageQueryMESA(long dpy, long image, IntBuffer fourcc, IntBuffer num_planes, LongBuffer modifiers)  {

    if (!Buffers.isDirect(fourcc))
      throw new RuntimeException("Argument \"fourcc\" is not a direct buffer");
    if (!Buffers.isDirect(num_planes))
      throw new RuntimeException("Argument \"num_planes\" is not a direct buffer");
    if (!Buffers.isDirect(modifiers))
      throw new RuntimeException("Argument \"modifiers\" is not a direct buffer");
    final long __addr_ = _table._addressof_eglExportDMABUFImageQueryMESA;
    if (__addr_ == 0) {
      throw new UnsupportedOperationException(String.format("Method \"%s\" not available", "eglExportDMABUFImageQueryMESA"));
    }
        return dispatch_eglExportDMABUFImageQueryMESA0(dpy, image, fourcc, Buffers.getDirectBufferByteOffset(fourcc), num_planes, Buffers.getDirectBufferByteOffset(num_planes), modifiers, Buffers.getDirectBufferByteOffset(modifiers), __addr_);
  }

  /** Entry point to C language function:  EGLBoolean eglExportDMABUFImageQueryMESA(EGLDisplay dpy, EGLImageKHR image, int *  fourcc, int *  num_planes, EGLuint64KHR *  modifiers)  
Part of EGL_MESA_image_dma_buf_export

      @param fourcc a direct only {@link java.nio.IntBuffer}
      @param num_planes a direct only {@link java.nio.IntBuffer}
      @param modifiers a direct only {@link java.nio.LongBuffer}   */
  private native boolean dispatch_eglExportDMABUFImageQueryMESA0(long dpy, long image, Object fourcc, int fourcc_byte_offset, Object num_planes, int num_planes_byte_offset, Object modifiers, int modifiers_byte_offset, long procAddress);

  /** Entry point to C language function:  EGLBoolean eglExportDMABUFImageMESA(EGLDisplay dpy, EGLImageKHR image, int *  fds, EGLint *  strides, EGLint *  offsets)  
Part of EGL_MESA_image_dma_buf_export

      @param fds a direct only {@link java.nio.IntBuffer}
      @param strides a direct only {@link java.nio.IntBuffer}
      @param offsets a direct only {@link java.nio.IntBuffer}   */
  public boolean eglExportDMABUFImageMESA(long dpy, long image, IntBuffer fds, IntBuffer strides, IntBuffer offsets)  {

    if (!Buffers.isDirect(fds))
      throw new RuntimeException("Argument \"fds\" is not a direct buffer");
    if (!Buffers.isDirect(strides))
      throw new RuntimeException("Argument \"strides\" is not a direct buffer");
    if (!Buffers.isDirect(offsets))
      throw new RuntimeException("Argument \"offsets\" is not a direct buffer");
    final long __addr_ = _table._addressof_eglExportDMABUFImageMESA;
    if (__addr_ == 0) {
      throw new UnsupportedOperationException(String.format("Method \"%s\" not available", "eglExportDMABUFImageMESA"));
    }
        return dispatch_eglExportDMABUFImageMESA0(dpy, image, fds, Buffers.getDirectBufferByteOffset(fds), strides, Buffers.getDirectBufferByteOffset(strides), offsets, Buffers.getDirectBufferByteOffset(offsets), __addr_);
  }

  /** Entry point to C language function:  EGLBoolean eglExportDMABUFImageMESA(EGLDisplay dpy, EGLImageKHR image, int *  fds, EGLint *  strides, EGLint *  offsets)  
Part of EGL_MESA_image_dma_buf_export

      @param fds a direct only {@link java.nio.IntBuffer}
      @param strides a direct only {@link java.nio.IntBuffer}
      @param offsets a direct only {@link java.nio.IntBuffer}   */
  private native boolean dispatch_eglExportDMABUFImageMESA0(long dpy, long image, Object fds, int fds_byte_offset, Object strides, int strides_byte_offset, Object offsets, int offsets_byte_offset, long procAddress);

  /** Entry point to C language function:  EGLBoolean eglSwapBuffersRegionNOK(EGLDisplay dpy, EGLSurface surface, EGLint numRects, const EGLint *  rects)  
Part of EGL_NOK_swap_region

      @param rects a direct only {@link java.nio.IntBuffer}   */
  public boolean eglSwapBuffersRegionNOK(long dpy, long surface, int numRects, IntBuffer rects)  {

    if (!Buffers.isDirect(rects))
      throw new RuntimeException("Argument \"rects\" is not a direct buffer");
    final long __addr_ = _table._addressof_eglSwapBuffersRegionNOK;
    if (__addr_ == 0) {
      throw new UnsupportedOperationException(String.format("Method \"%s\" not available", "eglSwapBuffersRegionNOK"));
    }
        return dispatch_eglSwapBuffersRegionNOK0(dpy, surface, numRects, rects, Buffers.getDirectBufferByteOffset(rects), __addr_);
  }

  /** Entry point to C language function:  EGLBoolean eglSwapBuffersRegionNOK(EGLDisplay dpy, EGLSurface surface, EGLint numRects, const EGLint *  rects)  
Part of EGL_NOK_swap_region

      @param rects a direct only {@link java.nio.IntBuffer}   */
  private native boolean dispatch_eglSwapBuffersRegionNOK0(long dpy, long surface, int numRects, Object rects, int rects_byte_offset, long procAddress);

  /** Entry point to C language function:  EGLBoolean eglSwapBuffersRegion2NOK(EGLDisplay dpy, EGLSurface surface, EGLint numRects, const EGLint *  rects)  
Part of EGL_NOK_swap_region2

      @param rects a direct only {@link java.nio.IntBuffer}   */
  public boolean eglSwapBuffersRegion2NOK(long dpy, long surface, int numRects, IntBuffer rects)  {

    if (!Buffers.isDirect(rects))
      throw new RuntimeException("Argument \"rects\" is not a direct buffer");
    final long __addr_ = _table._addressof_eglSwapBuffersRegion2NOK;
    if (__addr_ == 0) {
      throw new UnsupportedOperationException(String.format("Method \"%s\" not available", "eglSwapBuffersRegion2NOK"));
    }
        return dispatch_eglSwapBuffersRegion2NOK0(dpy, surface, numRects, rects, Buffers.getDirectBufferByteOffset(rects), __addr_);
  }

  /** Entry point to C language function:  EGLBoolean eglSwapBuffersRegion2NOK(EGLDisplay dpy, EGLSurface surface, EGLint numRects, const EGLint *  rects)  
Part of EGL_NOK_swap_region2

      @param rects a direct only {@link java.nio.IntBuffer}   */
  private native boolean dispatch_eglSwapBuffersRegion2NOK0(long dpy, long surface, int numRects, Object rects, int rects_byte_offset, long procAddress);

  /** Entry point to C language function:  EGLBoolean eglQueryNativeDisplayNV(EGLDisplay dpy, EGLNativeDisplayType *  display_id)  
Part of EGL_NV_native_query

      @param display_id a direct only {@link com.jogamp.common.nio.PointerBuffer}   */
  public boolean eglQueryNativeDisplayNV(long dpy, PointerBuffer display_id)  {

    if (!Buffers.isDirect(display_id))
      throw new RuntimeException("Argument \"display_id\" is not a direct buffer");
    final long __addr_ = _table._addressof_eglQueryNativeDisplayNV;
    if (__addr_ == 0) {
      throw new UnsupportedOperationException(String.format("Method \"%s\" not available", "eglQueryNativeDisplayNV"));
    }
        return dispatch_eglQueryNativeDisplayNV0(dpy, display_id != null ? display_id.getBuffer() : null, Buffers.getDirectBufferByteOffset(display_id), __addr_);
  }

  /** Entry point to C language function:  EGLBoolean eglQueryNativeDisplayNV(EGLDisplay dpy, EGLNativeDisplayType *  display_id)  
Part of EGL_NV_native_query

      @param display_id a direct only {@link com.jogamp.common.nio.PointerBuffer}   */
  private native boolean dispatch_eglQueryNativeDisplayNV0(long dpy, Object display_id, int display_id_byte_offset, long procAddress);

  /** Entry point to C language function:  EGLBoolean eglQueryNativeWindowNV(EGLDisplay dpy, EGLSurface surf, EGLNativeWindowType *  window)  
Part of EGL_NV_native_query

      @param window a direct only {@link com.jogamp.common.nio.PointerBuffer}   */
  public boolean eglQueryNativeWindowNV(long dpy, long surf, PointerBuffer window)  {

    if (!Buffers.isDirect(window))
      throw new RuntimeException("Argument \"window\" is not a direct buffer");
    final long __addr_ = _table._addressof_eglQueryNativeWindowNV;
    if (__addr_ == 0) {
      throw new UnsupportedOperationException(String.format("Method \"%s\" not available", "eglQueryNativeWindowNV"));
    }
        return dispatch_eglQueryNativeWindowNV0(dpy, surf, window != null ? window.getBuffer() : null, Buffers.getDirectBufferByteOffset(window), __addr_);
  }

  /** Entry point to C language function:  EGLBoolean eglQueryNativeWindowNV(EGLDisplay dpy, EGLSurface surf, EGLNativeWindowType *  window)  
Part of EGL_NV_native_query

      @param window a direct only {@link com.jogamp.common.nio.PointerBuffer}   */
  private native boolean dispatch_eglQueryNativeWindowNV0(long dpy, long surf, Object window, int window_byte_offset, long procAddress);

  /** Entry point to C language function:  EGLBoolean eglQueryNativePixmapNV(EGLDisplay dpy, EGLSurface surf, EGLNativePixmapType *  pixmap)  
Part of EGL_NV_native_query

      @param pixmap a direct only {@link com.jogamp.common.nio.PointerBuffer}   */
  public boolean eglQueryNativePixmapNV(long dpy, long surf, PointerBuffer pixmap)  {

    if (!Buffers.isDirect(pixmap))
      throw new RuntimeException("Argument \"pixmap\" is not a direct buffer");
    final long __addr_ = _table._addressof_eglQueryNativePixmapNV;
    if (__addr_ == 0) {
      throw new UnsupportedOperationException(String.format("Method \"%s\" not available", "eglQueryNativePixmapNV"));
    }
        return dispatch_eglQueryNativePixmapNV0(dpy, surf, pixmap != null ? pixmap.getBuffer() : null, Buffers.getDirectBufferByteOffset(pixmap), __addr_);
  }

  /** Entry point to C language function:  EGLBoolean eglQueryNativePixmapNV(EGLDisplay dpy, EGLSurface surf, EGLNativePixmapType *  pixmap)  
Part of EGL_NV_native_query

      @param pixmap a direct only {@link com.jogamp.common.nio.PointerBuffer}   */
  private native boolean dispatch_eglQueryNativePixmapNV0(long dpy, long surf, Object pixmap, int pixmap_byte_offset, long procAddress);

  /** Entry point to C language function:  EGLBoolean eglPostSubBufferNV(EGLDisplay dpy, EGLSurface surface, EGLint x, EGLint y, EGLint width, EGLint height)  
Part of EGL_NV_post_sub_buffer
   */
  public boolean eglPostSubBufferNV(long dpy, long surface, int x, int y, int width, int height)  {

    final long __addr_ = _table._addressof_eglPostSubBufferNV;
    if (__addr_ == 0) {
      throw new UnsupportedOperationException(String.format("Method \"%s\" not available", "eglPostSubBufferNV"));
    }
        return dispatch_eglPostSubBufferNV0(dpy, surface, x, y, width, height, __addr_);
  }

  /** Entry point to C language function:  EGLBoolean eglPostSubBufferNV(EGLDisplay dpy, EGLSurface surface, EGLint x, EGLint y, EGLint width, EGLint height)  
Part of EGL_NV_post_sub_buffer
   */
  private native boolean dispatch_eglPostSubBufferNV0(long dpy, long surface, int x, int y, int width, int height, long procAddress);

  /** Entry point to C language function:  EGLSyncKHR eglCreateStreamSyncNV(EGLDisplay dpy, EGLStreamKHR stream, EGLenum type, const EGLint *  attrib_list)  
Part of EGL_NV_stream_sync

      @param stream a direct only {@link java.nio.Buffer}
      @param attrib_list a direct only {@link java.nio.IntBuffer}   */
  public long eglCreateStreamSyncNV(long dpy, Buffer stream, int type, IntBuffer attrib_list)  {

    if (!Buffers.isDirect(stream))
      throw new RuntimeException("Argument \"stream\" is not a direct buffer");
    if (!Buffers.isDirect(attrib_list))
      throw new RuntimeException("Argument \"attrib_list\" is not a direct buffer");
    final long __addr_ = _table._addressof_eglCreateStreamSyncNV;
    if (__addr_ == 0) {
      throw new UnsupportedOperationException(String.format("Method \"%s\" not available", "eglCreateStreamSyncNV"));
    }
        return dispatch_eglCreateStreamSyncNV0(dpy, stream, Buffers.getDirectBufferByteOffset(stream), type, attrib_list, Buffers.getDirectBufferByteOffset(attrib_list), __addr_);
  }

  /** Entry point to C language function:  EGLSyncKHR eglCreateStreamSyncNV(EGLDisplay dpy, EGLStreamKHR stream, EGLenum type, const EGLint *  attrib_list)  
Part of EGL_NV_stream_sync

      @param stream a direct only {@link java.nio.Buffer}
      @param attrib_list a direct only {@link java.nio.IntBuffer}   */
  private native long dispatch_eglCreateStreamSyncNV0(long dpy, Object stream, int stream_byte_offset, int type, Object attrib_list, int attrib_list_byte_offset, long procAddress);

  /** Entry point to C language function:  EGLSyncNV eglCreateFenceSyncNV(EGLDisplay dpy, EGLenum condition, const EGLint *  attrib_list)  
Part of EGL_NV_sync

      @param attrib_list a direct only {@link java.nio.IntBuffer}   */
  public ByteBuffer eglCreateFenceSyncNV(long dpy, int condition, IntBuffer attrib_list)  {

    if (!Buffers.isDirect(attrib_list))
      throw new RuntimeException("Argument \"attrib_list\" is not a direct buffer");
    final long __addr_ = _table._addressof_eglCreateFenceSyncNV;
    if (__addr_ == 0) {
      throw new UnsupportedOperationException(String.format("Method \"%s\" not available", "eglCreateFenceSyncNV"));
    }
    final ByteBuffer _res;
    _res = dispatch_eglCreateFenceSyncNV0(dpy, condition, attrib_list, Buffers.getDirectBufferByteOffset(attrib_list), __addr_);
    if (_res == null) return null;
    Buffers.nativeOrder(_res);
    return _res;
  }

  /** Entry point to C language function:  EGLSyncNV eglCreateFenceSyncNV(EGLDisplay dpy, EGLenum condition, const EGLint *  attrib_list)  
Part of EGL_NV_sync

      @param attrib_list a direct only {@link java.nio.IntBuffer}   */
  private native ByteBuffer dispatch_eglCreateFenceSyncNV0(long dpy, int condition, Object attrib_list, int attrib_list_byte_offset, long procAddress);

  /** Entry point to C language function:  EGLBoolean eglDestroySyncNV(EGLSyncNV sync)  
Part of EGL_NV_sync

      @param sync a direct only {@link java.nio.Buffer}   */
  public boolean eglDestroySyncNV(Buffer sync)  {

    if (!Buffers.isDirect(sync))
      throw new RuntimeException("Argument \"sync\" is not a direct buffer");
    final long __addr_ = _table._addressof_eglDestroySyncNV;
    if (__addr_ == 0) {
      throw new UnsupportedOperationException(String.format("Method \"%s\" not available", "eglDestroySyncNV"));
    }
        return dispatch_eglDestroySyncNV0(sync, Buffers.getDirectBufferByteOffset(sync), __addr_);
  }

  /** Entry point to C language function:  EGLBoolean eglDestroySyncNV(EGLSyncNV sync)  
Part of EGL_NV_sync

      @param sync a direct only {@link java.nio.Buffer}   */
  private native boolean dispatch_eglDestroySyncNV0(Object sync, int sync_byte_offset, long procAddress);

  /** Entry point to C language function:  EGLBoolean eglFenceNV(EGLSyncNV sync)  
Part of EGL_NV_sync

      @param sync a direct only {@link java.nio.Buffer}   */
  public boolean eglFenceNV(Buffer sync)  {

    if (!Buffers.isDirect(sync))
      throw new RuntimeException("Argument \"sync\" is not a direct buffer");
    final long __addr_ = _table._addressof_eglFenceNV;
    if (__addr_ == 0) {
      throw new UnsupportedOperationException(String.format("Method \"%s\" not available", "eglFenceNV"));
    }
        return dispatch_eglFenceNV0(sync, Buffers.getDirectBufferByteOffset(sync), __addr_);
  }

  /** Entry point to C language function:  EGLBoolean eglFenceNV(EGLSyncNV sync)  
Part of EGL_NV_sync

      @param sync a direct only {@link java.nio.Buffer}   */
  private native boolean dispatch_eglFenceNV0(Object sync, int sync_byte_offset, long procAddress);

  /** Entry point to C language function:  EGLint eglClientWaitSyncNV(EGLSyncNV sync, EGLint flags, EGLTimeNV timeout)  
Part of EGL_NV_sync

      @param sync a direct only {@link java.nio.Buffer}   */
  public int eglClientWaitSyncNV(Buffer sync, int flags, long timeout)  {

    if (!Buffers.isDirect(sync))
      throw new RuntimeException("Argument \"sync\" is not a direct buffer");
    final long __addr_ = _table._addressof_eglClientWaitSyncNV;
    if (__addr_ == 0) {
      throw new UnsupportedOperationException(String.format("Method \"%s\" not available", "eglClientWaitSyncNV"));
    }
        return dispatch_eglClientWaitSyncNV0(sync, Buffers.getDirectBufferByteOffset(sync), flags, timeout, __addr_);
  }

  /** Entry point to C language function:  EGLint eglClientWaitSyncNV(EGLSyncNV sync, EGLint flags, EGLTimeNV timeout)  
Part of EGL_NV_sync

      @param sync a direct only {@link java.nio.Buffer}   */
  private native int dispatch_eglClientWaitSyncNV0(Object sync, int sync_byte_offset, int flags, long timeout, long procAddress);

  /** Entry point to C language function:  EGLBoolean eglSignalSyncNV(EGLSyncNV sync, EGLenum mode)  
Part of EGL_NV_sync

      @param sync a direct only {@link java.nio.Buffer}   */
  public boolean eglSignalSyncNV(Buffer sync, int mode)  {

    if (!Buffers.isDirect(sync))
      throw new RuntimeException("Argument \"sync\" is not a direct buffer");
    final long __addr_ = _table._addressof_eglSignalSyncNV;
    if (__addr_ == 0) {
      throw new UnsupportedOperationException(String.format("Method \"%s\" not available", "eglSignalSyncNV"));
    }
        return dispatch_eglSignalSyncNV0(sync, Buffers.getDirectBufferByteOffset(sync), mode, __addr_);
  }

  /** Entry point to C language function:  EGLBoolean eglSignalSyncNV(EGLSyncNV sync, EGLenum mode)  
Part of EGL_NV_sync

      @param sync a direct only {@link java.nio.Buffer}   */
  private native boolean dispatch_eglSignalSyncNV0(Object sync, int sync_byte_offset, int mode, long procAddress);

  /** Entry point to C language function:  EGLBoolean eglGetSyncAttribNV(EGLSyncNV sync, EGLint attribute, EGLint *  value)  
Part of EGL_NV_sync

      @param sync a direct only {@link java.nio.Buffer}
      @param value a direct only {@link java.nio.IntBuffer}   */
  public boolean eglGetSyncAttribNV(Buffer sync, int attribute, IntBuffer value)  {

    if (!Buffers.isDirect(sync))
      throw new RuntimeException("Argument \"sync\" is not a direct buffer");
    if (!Buffers.isDirect(value))
      throw new RuntimeException("Argument \"value\" is not a direct buffer");
    final long __addr_ = _table._addressof_eglGetSyncAttribNV;
    if (__addr_ == 0) {
      throw new UnsupportedOperationException(String.format("Method \"%s\" not available", "eglGetSyncAttribNV"));
    }
        return dispatch_eglGetSyncAttribNV0(sync, Buffers.getDirectBufferByteOffset(sync), attribute, value, Buffers.getDirectBufferByteOffset(value), __addr_);
  }

  /** Entry point to C language function:  EGLBoolean eglGetSyncAttribNV(EGLSyncNV sync, EGLint attribute, EGLint *  value)  
Part of EGL_NV_sync

      @param sync a direct only {@link java.nio.Buffer}
      @param value a direct only {@link java.nio.IntBuffer}   */
  private native boolean dispatch_eglGetSyncAttribNV0(Object sync, int sync_byte_offset, int attribute, Object value, int value_byte_offset, long procAddress);

  /** Entry point to C language function:  EGLuint64NV eglGetSystemTimeFrequencyNV(void)  
Part of EGL_NV_system_time
   */
  public long eglGetSystemTimeFrequencyNV()  {

    final long __addr_ = _table._addressof_eglGetSystemTimeFrequencyNV;
    if (__addr_ == 0) {
      throw new UnsupportedOperationException(String.format("Method \"%s\" not available", "eglGetSystemTimeFrequencyNV"));
    }
        return dispatch_eglGetSystemTimeFrequencyNV0(__addr_);
  }

  /** Entry point to C language function:  EGLuint64NV eglGetSystemTimeFrequencyNV(void)  
Part of EGL_NV_system_time
   */
  private native long dispatch_eglGetSystemTimeFrequencyNV0(long procAddress);

  /** Entry point to C language function:  EGLuint64NV eglGetSystemTimeNV(void)  
Part of EGL_NV_system_time
   */
  public long eglGetSystemTimeNV()  {

    final long __addr_ = _table._addressof_eglGetSystemTimeNV;
    if (__addr_ == 0) {
      throw new UnsupportedOperationException(String.format("Method \"%s\" not available", "eglGetSystemTimeNV"));
    }
        return dispatch_eglGetSystemTimeNV0(__addr_);
  }

  /** Entry point to C language function:  EGLuint64NV eglGetSystemTimeNV(void)  
Part of EGL_NV_system_time
   */
  private native long dispatch_eglGetSystemTimeNV0(long procAddress);


  // --- Begin CustomJavaCode .cfg declarations
  public EGLExtImpl(EGLContext context, EGLExtProcAddressTable table) {
    this._context = context; 
    this._table = table; 
  }
  public boolean isFunctionAvailable(String glFunctionName)
  {
    return _context.isFunctionAvailable(glFunctionName);
  }
  public boolean isExtensionAvailable(String glExtensionName)
  {
    return _context.isExtensionAvailable(glExtensionName);
  }
  private final EGLContext _context;
  private final EGLExtProcAddressTable _table;
  final EGLExtProcAddressTable getProcAdressTable() { return _table; }
  // ---- End CustomJavaCode .cfg declarations

} // end of class EGLExtImpl