add gbm java & build modifications

author: Erik De Rijcke <Erik.De.Rijcke@prodatamobility.com> 2015-05-10 21:13:04 +0200
committer: Sven Gothel <sgothel@jausoft.com> 2019-11-21 03:39:44 +0100
commit: e1d767a4063d2503f9099d24a570664f6acd1a34 (patch)
tree: cde62bfb7e260a4423d4a5c102783cd205148b5d
parent: f4281b5ee80d7674134bfee357695a98382884a3 (diff)
6 files changed, 494 insertions, 1 deletions
diff --git a/make/build-common.xml b/make/build-common.xml
index 97b0699fd..0967b6b0f 100644
--- a/make/build-common.xml
+++ b/make/build-common.xml
@@ -414,6 +414,8 @@
         <property name="newt-driver-intelgdl.jar" value="${build.newt}/newt-driver-intelgdl.jar" />    <!-- excluded from all -->
         <property name="newt-driver-bcm-old.jar"  value="${build.newt}/newt-driver-bcm-old.jar" />     <!-- excluded from all -->
         <property name="newt-driver-bcm-vc.jar"   value="${build.newt}/newt-driver-bcm-vc.jar" />
+        <property name="newt-driver-gbm.jar"      value="${build.newt}/newt-driver-gbm.jar" />
+
         <path id="newt_all_atoms.classpath">
             <pathelement location="${newt.jar}" />
             <pathelement location="${newt-ogl.jar}" />
@@ -426,6 +428,7 @@
             <pathelement location="${newt-driver-osx.jar}" />
             <pathelement location="${newt-driver-ios.jar}" />
             <pathelement location="${newt-driver-bcm-vc.jar}" />
+            <pathelement location="${newt-driver-gbm.jar}" />
         </path>
         <path id="newt_all-noawt_atoms.classpath">
             <pathelement location="${newt.jar}" />
@@ -436,6 +439,7 @@
             <pathelement location="${newt-driver-osx.jar}" />
             <pathelement location="${newt-driver-ios.jar}" />
             <pathelement location="${newt-driver-bcm-vc.jar}" />
+            <pathelement location="${newt-driver-gbm.jar}" />
         </path>
         <path id="newt_all-mobile_atoms.classpath">
             <pathelement location="${newt.jar}" />
@@ -445,6 +449,7 @@
             <pathelement location="${newt-driver-win.jar}" />
             <pathelement location="${newt-driver-ios.jar}" />
             <pathelement location="${newt-driver-bcm-vc.jar}" />
+            <pathelement location="${newt-driver-gbm.jar}" />
         </path>
         <path id="newt_all-android_atoms.classpath">
             <pathelement location="${newt.jar}" />
diff --git a/make/build-newt.xml b/make/build-newt.xml
index f33142e0a..447a41189 100644
--- a/make/build-newt.xml
+++ b/make/build-newt.xml
@@ -49,6 +49,7 @@
        setup.addNativeKD
        setup.addNativeIntelGDL
        setup.addNativeBroadcom  ( always true if 'isLinux' )
+       setup.addNativeGBM  ( always true if 'isLinux' )
 
    - Internal settings, may not be necessary to set them manually,
      since all JAR archives are orthogonal.
@@ -75,6 +76,10 @@
            <isset property="isLinux"/>
         </condition>
 
+        <condition property="setup.addNativeGBM">
+            <isset property="isLinux"/>
+        </condition>
+
         <condition property="setup.nonatives">
             <and>
                 <isfalse value="${isWindows}" />
@@ -85,6 +90,7 @@
                 <isfalse value="${setup.addNativeKD}" />
                 <isfalse value="${setup.addNativeIntelGDL}" />
                 <isfalse value="${setup.addNativeBroadcom}" />
+                <isfalse value="${setup.addNativeGBM}" />
             </and>
         </condition>
 
@@ -97,6 +103,7 @@
         <echo message="setup.addNativeKD: ${setup.addNativeKD}" />
         <echo message="setup.addNativeIntelGDL: ${setup.addNativeIntelGDL}" />
         <echo message="setup.addNativeBroadcom: ${setup.addNativeBroadcom}" />
+        <echo message="setup.addNativeGBM: ${setup.addNativeGBM}" />
         <echo message="setup.nonatives: ${setup.nonatives}" />
 
         <!-- partitioning -->
@@ -149,6 +156,9 @@
         <property name="java.part.driver.bcm.vc"
                   value="jogamp/newt/driver/bcm/vc/**"/>
 
+        <property name="java.part.driver.gbm"
+                  value="jogamp/newt/driver/gbm/**"/>
+
         <property name="java.part.driver.android"
                   value="jogamp/newt/driver/android/**"/>
 
@@ -235,6 +245,7 @@
         <mkdir dir="${src.generated.c}/IntelGDL" />
         <mkdir dir="${src.generated.c}/bcm/egl" />
         <mkdir dir="${src.generated.c}/bcm/vc/iv" />
+        <mkdir dir="${src.generated.c}/gbm" />
         <mkdir dir="${classes}" />
         <mkdir dir="${obj.newt}" />
     </target>
@@ -317,6 +328,25 @@
             <include name="jogamp/newt/driver/bcm/vc/iv/WindowDriver.java" />
         </javac>
 
+        <!-- create EGL GBM native headers -->
+        <javac srcdir="${src.java}"
+               destdir="${classes}"
+               excludes="${java.excludes.all} ${java.part.driver.android}"
+               nativeheaderdir="${src.generated.c}/gbm"
+               fork="yes"
+               includeAntRuntime="false"
+               memoryMaximumSize="${javac.memorymax}"
+               encoding="UTF-8"
+               source="${target.sourcelevel}" 
+               target="${target.targetlevel}"
+               bootclasspath="${target.rt.jar}"
+               debug="${javacdebug}" debuglevel="${javacdebuglevel}">
+            <classpath refid="jogl_nativewindow_gluegen.classpath"/>
+            <include name="jogamp/newt/driver/gbm/DisplayDriver.java" />
+            <include name="jogamp/newt/driver/gbm/ScreenDriver.java" />
+            <include name="jogamp/newt/driver/gbm/WindowDriver.java" />
+        </javac>
+
         <!-- create Windows native headers -->
         <javac srcdir="${src.java}"
                destdir="${classes}"
@@ -495,6 +525,12 @@
         <!-- syslibset libs="EGL"/ -->
       </linker>
 
+        <linker id="linker.cfg.linux.newt.bcm_vc" extends="linker.cfg.linux">
+            <syslibset libs="EGL"/>
+            <syslibset libs="gbm"/>
+            <syslibset libs="drm"/>
+        </linker>
+
       <linker id="linker.cfg.linux.newt.bcm_egl" extends="linker.cfg.linux">
         <syslibset libs="EGL"/>
         <syslibset libs="GLES_CM"/>
@@ -863,6 +899,7 @@
           <include name="${rootrel.src.c}/IntelGDL.c"         if="setup.addNativeIntelGDL"/>
           <include name="${rootrel.src.c}/bcm_egl.c"          if="setup.addNativeBroadcom"/>
           <include name="${rootrel.src.c}/bcm_vc_iv.c"        if="setup.addNativeBroadcom"/>
+          <include name="${rootrel.src.c}/gbm.c"              if="setup.addNativeGBM"/>
         </patternset>
 
         <echo message="Compiling @{output.lib.name}" />
@@ -911,7 +948,7 @@
                 <includepath path="stub_includes/embedded/IntelGDL" if="setup.addNativeIntelGDL" />
                 <includepath path="${src.generated.c}/bcm/egl"      if="setup.addNativeBroadcom" />
                 <includepath path="${src.generated.c}/bcm/vc/iv"    if="setup.addNativeBroadcom" />
-    
+                <includepath path="${src.generated.c}/gbm"          if="setup.addNativeGBM" />
                 <!-- This must come last to not override real include paths -->
                 <!-- includepath path="stub_includes/macosx" if="isOSX" / -->
               </compiler>
@@ -1057,6 +1094,10 @@
             <fileset dir="${classes}"
                      includes="${java.part.driver.bcm.vc}"/>
         </jar>
+        <jar manifest="${build.newt}/manifest.mf" destfile="${newt-driver-gbm.jar}" filesonly="true">
+            <fileset dir="${classes}"
+                     includes="${java.part.driver.gbm}"/>
+        </jar>
         <jar manifest="${build.newt}/manifest.mf" destfile="${newt-driver-intelgdl.jar}" filesonly="true">
             <fileset dir="${classes}"
                      includes="${java.part.driver.intelgdl}"/>
diff --git a/src/newt/classes/jogamp/newt/driver/gbm/DisplayDriver.java b/src/newt/classes/jogamp/newt/driver/gbm/DisplayDriver.java
new file mode 100644
index 000000000..0e43536c6
--- /dev/null
+++ b/src/newt/classes/jogamp/newt/driver/gbm/DisplayDriver.java
@@ -0,0 +1,192 @@
+//Copyright 2015 Erik De Rijcke
+//
+//Licensed under the Apache License,Version2.0(the"License");
+//you may not use this file except in compliance with the License.
+//You may obtain a copy of the License at
+//
+//http://www.apache.org/licenses/LICENSE-2.0
+//
+//Unless required by applicable law or agreed to in writing,software
+//distributed under the License is distributed on an"AS IS"BASIS,
+//WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,either express or implied.
+//See the License for the specific language governing permissions and
+//limitations under the License.
+package jogamp.newt.driver.gbm;
+
+import com.jogamp.nativewindow.AbstractGraphicsDevice;
+import com.jogamp.nativewindow.NativeWindowException;
+import com.jogamp.nativewindow.egl.EGLGraphicsDevice;
+import com.jogamp.opengl.GLDrawableFactory;
+import jogamp.newt.DisplayImpl;
+import jogamp.newt.NEWTJNILibLoader;
+import jogamp.opengl.egl.EGLDisplayUtil;
+
+public class DisplayDriver extends DisplayImpl {
+
+    static {
+        NEWTJNILibLoader.loadNEWT();
+
+        if (!DisplayDriver.initIDs()) {
+            throw new NativeWindowException("Failed to initialize gbm Display jmethodIDs");
+        }
+//        if (!ScreenDriver.initIDs()) {
+//            throw new NativeWindowException("Failed to initialize gbm Screen jmethodIDs");
+//        }
+//        if (!WindowDriver.initIDs()) {
+//            throw new NativeWindowException("Failed to initialize gbm Window jmethodIDs");
+//        }
+    }
+
+    protected static native boolean initIDs();
+
+    private long dev;
+    private long surface;
+
+    private int fd;
+    private long mode;
+
+    static {
+        NEWTJNILibLoader.loadNEWT();
+        GLDrawableFactory.initSingleton();
+    }
+
+    //private final EGLGraphicsDevice.EGLDisplayLifecycleCallback eglDisplayLifecycleCallback;
+    private long connector;
+    private long encoder;
+
+    public long getConnector() {
+        return connector;
+    }
+
+    public long getEncoder() {
+        return encoder;
+    }
+
+    public static void initSingleton() {
+        // just exist to ensure static init has been run
+    }
+
+    @Override
+    protected void createNativeImpl() {
+        final EGLGraphicsDevice eglGraphicsDevice = EGLDisplayUtil.eglCreateEGLGraphicsDevice(dev, AbstractGraphicsDevice.DEFAULT_CONNECTION, AbstractGraphicsDevice.DEFAULT_UNIT);
+        eglGraphicsDevice.open();
+
+        this.aDevice = eglGraphicsDevice;
+    }
+
+    private native void initGbm();
+//    {
+//
+//
+//    }
+
+    public long getSurface() {
+        return surface;
+    }
+
+    private native void init();
+//    {
+//
+//        String[] modules = {
+//                "i915", "radeon", "nouveau", "vmwgfx", "omapdrm", "exynos", "msm"
+//        };
+//        drmModeRes resources;
+//        connector = null;
+//        encoder = null;
+//
+//        for (int i = 0; i < modules.length; i++) {
+//            if(DEBUG){
+//                System.out.println(String.format("trying to load module %s...", modules[i]));
+//            }
+//            fd = DrmLibrary.INSTANCE.drmOpen(modules[i], null);
+//            if (fd < 0) {
+//                throw new NativeWindowException("Can not open drm device.");
+//            } else {
+//                break;
+//            }
+//        }
+//
+//        if (fd < 0) {
+//            throw new NativeWindowException("could not open drm device");
+//        }
+//
+//        resources = DrmLibrary.INSTANCE.drmModeGetResources(fd);
+//        if (resources == null) {
+//            throw new NativeWindowException("drmModeGetResources failed");
+//        }
+//
+//	/* find a connected connector: */
+//        for (int i = 0; i < resources.count_connectors; i++) {
+//            connector = DrmLibrary.INSTANCE.drmModeGetConnector(fd, resources.connectors.getInt(i));
+//            if (connector.connection == drmModeConnection.DRM_MODE_CONNECTED) {
+//                        /* it's connected, let's use this! */
+//                break;
+//            }
+//            DrmLibrary.INSTANCE.drmModeFreeConnector(connector);
+//            connector = null;
+//        }
+//
+//        if (connector == null) {
+//                /* we could be fancy and listen for hotplug events and wait for
+//                 * a connector..
+//		 */
+//            throw new NativeWindowException("no connected connector!");
+//        }
+//
+//	/* find highest resolution mode: */
+//        drmModeModeInfo[] drmModeModeInfos = (drmModeModeInfo[]) connector.modes.toArray(connector.count_modes);
+//        for (int i = 0, area = 0; i < drmModeModeInfos.length; i++) {
+//            drmModeModeInfo current_mode = drmModeModeInfos[i];
+//            int current_area = current_mode.hdisplay * current_mode.vdisplay;
+//            if (current_area > area) {
+//                mode = current_mode;
+//                area = current_area;
+//            }
+//        }
+//
+//        if (mode == null) {
+//            throw new NativeWindowException("could not find mode!");
+//        }
+//
+//	/* find encoder: */
+//        for (int i = 0; i < resources.count_encoders; i++) {
+//            encoder = DrmLibrary.INSTANCE.drmModeGetEncoder(fd, resources.encoders.getInt(i));
+//            if (encoder.encoder_id == connector.encoder_id) {
+//                break;
+//            }
+//            DrmLibrary.INSTANCE.drmModeFreeEncoder(encoder);
+//            encoder = null;
+//        }
+//
+//        if (encoder == null) {
+//            throw new NativeWindowException("no encoder!");
+//        }
+//
+//        final int crtc_id = encoder.crtc_id;
+//        final int connector_id = connector.connector_id;
+//
+//        dev = GbmLibrary.INSTANCE.gbm_create_device(fd);
+//    }
+
+    @Override
+    protected void closeNativeImpl(final AbstractGraphicsDevice aDevice) {
+        //DrmLibrary.INSTANCE.drmModeFreeConnector(this.connector);
+        aDevice.close();
+        destroyDisplay();
+        //GbmLibrary.INSTANCE.gbm_device_destroy(dev);
+        this.dev = 0;
+        //CLibrary.INSTANCE.close(this.fd);
+        this.fd = 0;
+    }
+
+    private native void destroyDisplay();
+
+    @Override
+    protected void dispatchMessagesNative() {
+        //NA
+    }
+
+    public long getGbmDevice() {
+        return dev;
+    }
+}
diff --git a/src/newt/classes/jogamp/newt/driver/gbm/ScreenDriver.java b/src/newt/classes/jogamp/newt/driver/gbm/ScreenDriver.java
new file mode 100644
index 000000000..0066d42e4
--- /dev/null
+++ b/src/newt/classes/jogamp/newt/driver/gbm/ScreenDriver.java
@@ -0,0 +1,88 @@
+package jogamp.newt.driver.gbm;
+
+import com.jogamp.nativewindow.DefaultGraphicsScreen;
+import com.jogamp.newt.MonitorDevice;
+import com.jogamp.newt.MonitorMode;
+import jogamp.newt.MonitorModeProps;
+import jogamp.newt.ScreenImpl;
+
+public class ScreenDriver extends ScreenImpl {
+
+
+    @Override
+    protected void createNativeImpl() {
+        this.aScreen = new DefaultGraphicsScreen(getDisplay().getGraphicsDevice(),
+                                                 this.screen_idx);
+    }
+
+    @Override
+    protected void closeNativeImpl() {
+    }
+
+    @Override
+    protected int validateScreenIndex(final int idx) {
+        return 0;
+    }
+
+    @Override
+    protected void collectNativeMonitorModesAndDevicesImpl(final MonitorModeProps.Cache cache) {
+//        DisplayDriver display = (DisplayDriver) getDisplay();
+//        final drmModeConnector connector = display.getConnector();
+//        final drmModeEncoder encoder = display.getEncoder();
+//        //TODO collect info from init method
+//        int[] props = new int[MonitorModeProps.NUM_MONITOR_MODE_PROPERTIES_ALL];
+//        int   i     = 0;
+//        props[i++] = MonitorModeProps.NUM_MONITOR_MODE_PROPERTIES_ALL;
+//        props[i++] = connector.modes.hdisplay; // width
+//        props[i++] = connector.modes.vdisplay; // height
+//        props[i++] = ScreenImpl.default_sm_bpp; // FIXME
+//        props[i++] = ScreenImpl.default_sm_rate * 100; // FIXME
+//        props[i++] = connector.modes.flags; // flags
+//        props[i++] = 0; // mode_idx
+//        props[i++] = 0; // rotation
+//        final MonitorMode currentMode = MonitorModeProps.streamInMonitorMode(null,
+//                cache,
+//                props,
+//                0);
+//
+//        props = new int[MonitorModeProps.MIN_MONITOR_DEVICE_PROPERTIES - 1 - MonitorModeProps.NUM_MONITOR_MODE_PROPERTIES];
+//        i = 0;
+//        props[i++] = props.length;
+//        props[i++] = encoder.crtc_id; // crt_idx
+//        props[i++] = 0; // is-clone
+//        props[i++] = 1; // is-primary
+//        props[i++] = ScreenImpl.default_sm_widthmm; // FIXME
+//        props[i++] = ScreenImpl.default_sm_heightmm; // FIXME
+//        props[i++] = 0; // rotated viewport x pixel-units
+//        props[i++] = 0; // rotated viewport y pixel-units
+//        props[i++] = connector.modes.hdisplay; // rotated viewport width pixel-units
+//        props[i++] = connector.modes.vdisplay; // rotated viewport height pixel-units
+//        props[i++] = 0; // rotated viewport x window-units
+//        props[i++] = 0; // rotated viewport y window-units
+//        props[i++] = connector.modes.hdisplay; // rotated viewport width window-units
+//        props[i++] = connector.modes.vdisplay; // rotated viewport height window-units
+//        MonitorModeProps.streamInMonitorDevice(cache,
+//                this,
+//                currentMode,
+//                null,
+//                cache.monitorModes,
+//                props,
+//                0,
+//                null);
+    }
+
+    @Override
+    protected MonitorMode queryCurrentMonitorModeImpl(final MonitorDevice monitor) {
+        //TODO collect info from init method
+
+        return null;
+    }
+
+    @Override
+    protected boolean setCurrentMonitorModeImpl(final MonitorDevice monitor,
+                                                final MonitorMode mode) {
+        //TODO collect info from init method
+
+        return false;
+    }
+}
diff --git a/src/newt/classes/jogamp/newt/driver/gbm/WindowDriver.java b/src/newt/classes/jogamp/newt/driver/gbm/WindowDriver.java
new file mode 100644
index 000000000..9c5803e1a
--- /dev/null
+++ b/src/newt/classes/jogamp/newt/driver/gbm/WindowDriver.java
@@ -0,0 +1,118 @@
+//Copyright 2015 Erik De Rijcke
+//
+//Licensed under the Apache License,Version2.0(the"License");
+//you may not use this file except in compliance with the License.
+//You may obtain a copy of the License at
+//
+//http://www.apache.org/licenses/LICENSE-2.0
+//
+//Unless required by applicable law or agreed to in writing,software
+//distributed under the License is distributed on an"AS IS"BASIS,
+//WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,either express or implied.
+//See the License for the specific language governing permissions and
+//limitations under the License.
+package jogamp.newt.driver.gbm;
+
+import com.jogamp.nativewindow.*;
+import com.jogamp.nativewindow.util.Insets;
+import com.jogamp.nativewindow.util.Point;
+import jogamp.newt.WindowImpl;
+import jogamp.newt.driver.linux.LinuxEventDeviceTracker;
+import jogamp.newt.driver.linux.LinuxMouseTracker;
+
+public class WindowDriver extends WindowImpl {
+
+    private final LinuxMouseTracker linuxMouseTracker;
+    private final LinuxEventDeviceTracker linuxEventDeviceTracker;
+
+    public WindowDriver() {
+        this.linuxMouseTracker = LinuxMouseTracker.getSingleton();
+        this.linuxEventDeviceTracker = LinuxEventDeviceTracker.getSingleton();
+    }
+
+    @Override
+    protected void createNativeImpl() {
+        if (0 != getParentWindowHandle()) {
+            throw new RuntimeException("Window parenting not supported (yet)");
+        }
+
+        final ScreenDriver screen = (ScreenDriver) getScreen();
+        final DisplayDriver display = (DisplayDriver) screen.getDisplay();
+
+        // Create own screen/device resource instance allowing independent ownership,
+        // while still utilizing shared EGL resources.
+        final AbstractGraphicsScreen aScreen = screen.getGraphicsScreen();
+        final AbstractGraphicsDevice aDevice = display.getGraphicsDevice();
+        final DefaultGraphicsScreen eglScreen = new DefaultGraphicsScreen(aDevice, aScreen.getIndex());
+
+        final AbstractGraphicsConfiguration cfg = GraphicsConfigurationFactory.getFactory(getScreen().getDisplay().getGraphicsDevice(), capsRequested).chooseGraphicsConfiguration(
+                capsRequested, capsRequested, capabilitiesChooser, eglScreen, VisualIDHolder.VID_UNDEFINED);
+        if (null == cfg) {
+            throw new NativeWindowException("Error choosing GraphicsConfiguration creating window: "+this);
+        }
+        final Capabilities chosenCaps = (Capabilities) cfg.getChosenCapabilities();
+        // FIXME: Pass along opaque flag, since EGL doesn't determine it
+        if(capsRequested.isBackgroundOpaque() != chosenCaps.isBackgroundOpaque()) {
+            chosenCaps.setBackgroundOpaque(capsRequested.isBackgroundOpaque());
+        }
+        setGraphicsConfiguration(cfg);
+        long nativeWindowHandle = createSurface(display.getGbmDevice());
+        if (nativeWindowHandle == 0) {
+            throw new NativeWindowException("Error creating egl window: "+cfg);
+        }
+        setWindowHandle(nativeWindowHandle);
+        if (0 == getWindowHandle()) {
+            throw new NativeWindowException("Error native Window Handle is null");
+        }
+
+        addWindowListener(linuxEventDeviceTracker);
+        addWindowListener(linuxMouseTracker);
+        focusChanged(false, true);
+    }
+
+    private native long createSurface(final long gbmDevice);
+    //{
+        //        surface = GbmLibrary.INSTANCE.gbm_surface_create(dev,
+//                                                         mode.hdisplay, mode.vdisplay,
+//                                                         GbmLibrary.Constants.GBM_FORMAT_XRGB8888,
+//                                                         GBM_BO.GBM_BO_USE_SCANOUT | GBM_BO.GBM_BO_USE_RENDERING);
+//        if (surface == null) {
+//            throw new NativeWindowException("failed to create gbm surface");
+//        }
+//
+//        return 0;
+    //}
+
+    @Override
+    protected void closeNativeImpl() {
+        removeWindowListener(this.linuxMouseTracker);
+        removeWindowListener(this.linuxEventDeviceTracker);
+    }
+
+    @Override
+    protected void requestFocusImpl(final boolean force) {
+        focusChanged(false,
+                     true);
+    }
+
+    @Override
+    protected boolean reconfigureWindowImpl(final int x,
+                                            final int y,
+                                            final int width,
+                                            final int height,
+                                            final int flags) {
+        return false;
+    }
+
+    @Override
+    protected Point getLocationOnScreenImpl(final int x,
+                                            final int y) {
+        return new Point(x,
+                         y);
+    }
+
+    @Override
+    protected void updateInsetsImpl(final Insets insets) {
+
+    }
+}
diff --git a/src/newt/native/gbm.c b/src/newt/native/gbm.c
new file mode 100644
index 000000000..8b0baedc5
--- /dev/null
+++ b/src/newt/native/gbm.c
@@ -0,0 +1,49 @@
+#include "jogamp_newt_driver_gbm_DisplayDriver.h"
+#include "jogamp_newt_driver_gbm_ScreenDriver.h"
+#include "jogamp_newt_driver_gbm_WindowDriver.h"
+
+/*
+ * Class:     jogamp_newt_driver_gbm_DisplayDriver
+ * Method:    initIDs
+ * Signature: ()Z
+ */
+JNIEXPORT jboolean JNICALL Java_jogamp_newt_driver_gbm_DisplayDriver_initIDs
+  (JNIEnv *env, jclass cls){
+  }
+
+/*
+ * Class:     jogamp_newt_driver_gbm_DisplayDriver
+ * Method:    initGbm
+ * Signature: ()V
+ */
+JNIEXPORT void JNICALL Java_jogamp_newt_driver_gbm_DisplayDriver_initGbm
+  (JNIEnv *env, jobject this){
+
+  }
+
+/*
+ * Class:     jogamp_newt_driver_gbm_DisplayDriver
+ * Method:    init
+ * Signature: ()V
+ */
+JNIEXPORT void JNICALL Java_jogamp_newt_driver_gbm_DisplayDriver_init
+  (JNIEnv *env, jobject this){
+  }
+
+/*
+ * Class:     jogamp_newt_driver_gbm_DisplayDriver
+ * Method:    destroyDisplay
+ * Signature: ()V
+ */
+JNIEXPORT void JNICALL Java_jogamp_newt_driver_gbm_DisplayDriver_destroyDisplay
+  (JNIEnv *env, jobject this){
+  }
+
+/*
+ * Class:     jogamp_newt_driver_gbm_WindowDriver
+ * Method:    createSurface
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_jogamp_newt_driver_gbm_WindowDriver_createSurface
+  (JNIEnv *env, jobject this, jlong gbmDevice){
+  }
+\ No newline at end of file
author	Erik De Rijcke <Erik.De.Rijcke@prodatamobility.com>	2015-05-10 21:13:04 +0200
committer	Sven Gothel <sgothel@jausoft.com>	2019-11-21 03:39:44 +0100
commit	e1d767a4063d2503f9099d24a570664f6acd1a34 (patch)
tree	cde62bfb7e260a4423d4a5c102783cd205148b5d
parent	f4281b5ee80d7674134bfee357695a98382884a3 (diff)