Exemplo n.º 1
0
  /** Your new java application main entry, which pipelines your application */
  public static void main(String[] args) {
    useMainThread = MAIN_THREAD_CRITERIA;

    if (DEBUG)
      System.err.println(
          "MainThread.main(): "
              + Thread.currentThread().getName()
              + " useMainThread "
              + useMainThread);

    if (args.length == 0) {
      return;
    }

    String mainClassName = args[0];
    String[] mainClassArgs = new String[args.length - 1];
    if (args.length > 1) {
      System.arraycopy(args, 1, mainClassArgs, 0, args.length - 1);
    }

    NEWTJNILibLoader.loadNEWT();

    mainAction = new MainAction(mainClassName, mainClassArgs);

    if (NativeWindowFactory.TYPE_MACOSX.equals(NativeWindowFactory.getNativeWindowType(false))) {
      ReflectionUtil.callStaticMethod(
          "com.jogamp.newt.impl.macosx.MacDisplay",
          "initSingleton",
          null,
          null,
          MainThread.class.getClassLoader());
    }

    if (useMainThread) {
      shouldStop = false;
      tasks = new ArrayList();
      mainThread = Thread.currentThread();

      // dispatch user's main thread ..
      mainAction.start();

      // do our main thread task scheduling
      singletonMainThread.run();
    } else {
      // run user's main in this thread
      mainAction.run();
    }
  }
Exemplo n.º 2
0
  private static final void initSingletonImpl() {
    registerFactoryShutdownHook();

    final String nwt = NativeWindowFactory.getNativeWindowType(true);
    GLDrawableFactory tmp = null;
    String factoryClassName = Debug.getProperty("jogl.gldrawablefactory.class.name", true);
    ClassLoader cl = GLDrawableFactory.class.getClassLoader();
    if (null == factoryClassName) {
      if (nwt == NativeWindowFactory.TYPE_X11) {
        factoryClassName = "jogamp.opengl.x11.glx.X11GLXDrawableFactory";
      } else if (nwt == NativeWindowFactory.TYPE_WINDOWS) {
        factoryClassName = "jogamp.opengl.windows.wgl.WindowsWGLDrawableFactory";
      } else if (nwt == NativeWindowFactory.TYPE_MACOSX) {
        if (ReflectionUtil.isClassAvailable(macosxFactoryClassNameAWTCGL, cl)) {
          factoryClassName = macosxFactoryClassNameAWTCGL;
        } else {
          factoryClassName = macosxFactoryClassNameCGL;
        }
      } else {
        // may use egl*Factory ..
        if (DEBUG || GLProfile.DEBUG) {
          System.err.println(
              "GLDrawableFactory.static - No native Windowing Factory for: "
                  + nwt
                  + "; May use EGLDrawableFactory, if available.");
        }
      }
    }
    if (null != factoryClassName) {
      if (DEBUG || GLProfile.DEBUG) {
        System.err.println(
            "GLDrawableFactory.static - Native OS Factory for: " + nwt + ": " + factoryClassName);
      }
      try {
        tmp = (GLDrawableFactory) ReflectionUtil.createInstance(factoryClassName, cl);
      } catch (JogampRuntimeException jre) {
        if (DEBUG || GLProfile.DEBUG) {
          System.err.println(
              "Info: GLDrawableFactory.static - Native Platform: "
                  + nwt
                  + " - not available: "
                  + factoryClassName);
          jre.printStackTrace();
        }
      }
    }
    if (null != tmp && tmp.isComplete()) {
      nativeOSFactory = tmp;
    }
    tmp = null;

    if (!disableOpenGLES) {
      try {
        tmp =
            (GLDrawableFactory)
                ReflectionUtil.createInstance("jogamp.opengl.egl.EGLDrawableFactory", cl);
      } catch (JogampRuntimeException jre) {
        if (DEBUG || GLProfile.DEBUG) {
          System.err.println("Info: GLDrawableFactory.static - EGLDrawableFactory - not available");
          jre.printStackTrace();
        }
      }
      if (null != tmp && tmp.isComplete()) {
        eglFactory = tmp;
      }
    } else if (DEBUG || GLProfile.DEBUG) {
      System.err.println("Info: GLDrawableFactory.static - EGLDrawableFactory - disabled!");
    }
  }
Exemplo n.º 3
0
/**
 * NEWT Utility class MainThread
 *
 * <p>This class provides a startup singleton <i>main thread</i>, from which a new thread with the
 * users main class is launched.<br>
 * Such behavior is necessary for native windowing toolkits, where the windowing management must
 * happen on the so called <i>main thread</i> e.g. for Mac OS X !<br>
 * Utilizing this class as a launchpad, now you are able to use a NEWT multithreaded application
 * with window handling within the different threads, even on these restricted platforms.<br>
 * To support your NEWT Window platform, you have to pass your <i>main thread</i> actions to {@link
 * #invoke invoke(..)}, have a look at the {@link com.jogamp.newt.macosx.MacWindow MacWindow}
 * implementation.<br>
 * <i>TODO</i>: Some hardcoded dependencies exist in this implementation, where you have to patch
 * this code or factor it out.
 *
 * <p>If your platform is not Mac OS X, but you want to test your code without modifying this class,
 * you have to set the system property <code>newt.MainThread.force</code> to <code>true</code>.
 *
 * <p>The code is compatible with all other platform, which support multithreaded windowing
 * handling. Since those platforms won't trigger the <i>main thread</i> serialization, the main
 * method will be simply executed, in case you haven't set <code>newt.MainThread.force</code> to
 * <code>true</code>.
 *
 * <p>Test case on Mac OS X (or any other platform):
 *
 * <PRE>
 * java -XstartOnFirstThread com.jogamp.newt.util.MainThread demos.es1.RedSquare -GL2 -GL2 -GL2 -GL2
 * </PRE>
 *
 * Which starts 4 threads, each with a window and OpenGL rendering.<br>
 */
public class MainThread implements EDTUtil {
  private static AccessControlContext localACC = AccessController.getContext();
  public static final boolean MAIN_THREAD_CRITERIA =
      (!NativeWindowFactory.isAWTAvailable()
              && NativeWindowFactory.TYPE_MACOSX.equals(
                  NativeWindowFactory.getNativeWindowType(false)))
          || Debug.getBooleanProperty("newt.MainThread.force", true, localACC);

  protected static final boolean DEBUG = Debug.debug("MainThread");

  private static MainThread singletonMainThread = new MainThread(); // one singleton MainThread

  private static boolean isExit = false;
  private static volatile boolean isRunning = false;
  private static Object taskWorkerLock = new Object();
  private static boolean shouldStop;
  private static ArrayList tasks;
  private static Thread mainThread;

  private static Timer pumpMessagesTimer = null;
  private static TimerTask pumpMessagesTimerTask = null;
  private static Map /*<Display, Runnable>*/ pumpMessageDisplayMap = new HashMap();

  private static boolean useMainThread = false;
  private static Class cAWTEventQueue = null;
  private static Method mAWTInvokeAndWait = null;
  private static Method mAWTInvokeLater = null;
  private static Method mAWTIsDispatchThread = null;

  static class MainAction extends Thread {
    private String mainClassName;
    private String[] mainClassArgs;

    private Class mainClass;
    private Method mainClassMain;

    public MainAction(String mainClassName, String[] mainClassArgs) {
      this.mainClassName = mainClassName;
      this.mainClassArgs = mainClassArgs;
    }

    public void run() {
      if (useMainThread) {
        // we have to start first to provide the service ..
        singletonMainThread.waitUntilRunning();
      }

      // start user app ..
      try {
        Class mainClass = ReflectionUtil.getClass(mainClassName, true, getClass().getClassLoader());
        if (null == mainClass) {
          throw new RuntimeException(
              new ClassNotFoundException("MainThread couldn't find main class " + mainClassName));
        }
        try {
          mainClassMain = mainClass.getDeclaredMethod("main", new Class[] {String[].class});
          mainClassMain.setAccessible(true);
        } catch (Throwable t) {
          throw new RuntimeException(t);
        }
        if (DEBUG)
          System.err.println(
              "MainAction.run(): " + Thread.currentThread().getName() + " invoke " + mainClassName);
        mainClassMain.invoke(null, new Object[] {mainClassArgs});
      } catch (InvocationTargetException ite) {
        ite.getTargetException().printStackTrace();
      } catch (Throwable t) {
        t.printStackTrace();
      }

      if (DEBUG)
        System.err.println(
            "MainAction.run(): " + Thread.currentThread().getName() + " user app fin");

      if (useMainThread) {
        singletonMainThread.stop();
        if (DEBUG)
          System.err.println(
              "MainAction.run(): " + Thread.currentThread().getName() + " MainThread fin - stop");
        System.exit(0);
      }
    }
  }

  private static MainAction mainAction;

  /** Your new java application main entry, which pipelines your application */
  public static void main(String[] args) {
    useMainThread = MAIN_THREAD_CRITERIA;

    if (DEBUG)
      System.err.println(
          "MainThread.main(): "
              + Thread.currentThread().getName()
              + " useMainThread "
              + useMainThread);

    if (args.length == 0) {
      return;
    }

    String mainClassName = args[0];
    String[] mainClassArgs = new String[args.length - 1];
    if (args.length > 1) {
      System.arraycopy(args, 1, mainClassArgs, 0, args.length - 1);
    }

    NEWTJNILibLoader.loadNEWT();

    mainAction = new MainAction(mainClassName, mainClassArgs);

    if (NativeWindowFactory.TYPE_MACOSX.equals(NativeWindowFactory.getNativeWindowType(false))) {
      ReflectionUtil.callStaticMethod(
          "com.jogamp.newt.impl.macosx.MacDisplay",
          "initSingleton",
          null,
          null,
          MainThread.class.getClassLoader());
    }

    if (useMainThread) {
      shouldStop = false;
      tasks = new ArrayList();
      mainThread = Thread.currentThread();

      // dispatch user's main thread ..
      mainAction.start();

      // do our main thread task scheduling
      singletonMainThread.run();
    } else {
      // run user's main in this thread
      mainAction.run();
    }
  }

  public static final MainThread getSingleton() {
    return singletonMainThread;
  }

  public static Runnable removePumpMessage(Display dpy) {
    synchronized (pumpMessageDisplayMap) {
      return (Runnable) pumpMessageDisplayMap.remove(dpy);
    }
  }

  public static void addPumpMessage(Display dpy, Runnable pumpMessage) {
    if (useMainThread) {
      return; // error ?
    }
    if (null == pumpMessagesTimer) {
      synchronized (MainThread.class) {
        if (null == pumpMessagesTimer) {
          pumpMessagesTimer = new Timer();
          pumpMessagesTimerTask =
              new TimerTask() {
                public void run() {
                  synchronized (pumpMessageDisplayMap) {
                    for (Iterator i = pumpMessageDisplayMap.values().iterator(); i.hasNext(); ) {
                      ((Runnable) i.next()).run();
                    }
                  }
                }
              };
          pumpMessagesTimer.scheduleAtFixedRate(
              pumpMessagesTimerTask, 0, defaultEDTPollGranularity);
        }
      }
    }
    synchronized (pumpMessageDisplayMap) {
      pumpMessageDisplayMap.put(dpy, pumpMessage);
    }
  }

  private void initAWTReflection() {
    if (null == cAWTEventQueue) {
      ClassLoader cl = MainThread.class.getClassLoader();
      cAWTEventQueue = ReflectionUtil.getClass("java.awt.EventQueue", true, cl);
      mAWTInvokeAndWait =
          ReflectionUtil.getMethod(
              cAWTEventQueue, "invokeAndWait", new Class[] {java.lang.Runnable.class}, cl);
      mAWTInvokeLater =
          ReflectionUtil.getMethod(
              cAWTEventQueue, "invokeLater", new Class[] {java.lang.Runnable.class}, cl);
      mAWTIsDispatchThread =
          ReflectionUtil.getMethod(cAWTEventQueue, "isDispatchThread", new Class[] {}, cl);
    }
  }

  public void start() {
    // nop
  }

  public void stop() {
    if (DEBUG)
      System.err.println("MainThread.stop(): " + Thread.currentThread().getName() + " start");
    synchronized (taskWorkerLock) {
      if (isRunning) {
        shouldStop = true;
      }
      taskWorkerLock.notifyAll();
    }
    if (DEBUG)
      System.err.println("MainThread.stop(): " + Thread.currentThread().getName() + " end");
  }

  public boolean isCurrentThreadEDT() {
    if (NativeWindowFactory.isAWTAvailable()) {
      initAWTReflection();
      return ((Boolean) ReflectionUtil.callMethod(null, mAWTIsDispatchThread, null)).booleanValue();
    }
    return isRunning() && mainThread == Thread.currentThread();
  }

  public boolean isRunning() {
    if (useMainThread) {
      synchronized (taskWorkerLock) {
        return isRunning;
      }
    }
    return true; // AWT is always running
  }

  private void invokeLater(Runnable task) {
    synchronized (taskWorkerLock) {
      if (isRunning() && mainThread != Thread.currentThread()) {
        tasks.add(task);
        taskWorkerLock.notifyAll();
      } else {
        // if !running or isEDTThread, do it right away
        task.run();
      }
    }
  }

  /** invokes the given Runnable */
  public void invoke(boolean wait, Runnable r) {
    if (r == null) {
      return;
    }

    if (NativeWindowFactory.isAWTAvailable()) {
      initAWTReflection();

      // handover to AWT MainThread ..
      try {
        if (((Boolean) ReflectionUtil.callMethod(null, mAWTIsDispatchThread, null))
            .booleanValue()) {
          r.run();
          return;
        }
        if (wait) {
          ReflectionUtil.callMethod(null, mAWTInvokeAndWait, new Object[] {r});
        } else {
          ReflectionUtil.callMethod(null, mAWTInvokeLater, new Object[] {r});
        }
      } catch (Exception e) {
        throw new NativeWindowException(e);
      }
      return;
    }

    // if this main thread is not being used or
    // if this is already the main thread .. just execute.
    if (!isRunning() || mainThread == Thread.currentThread()) {
      r.run();
      return;
    }

    boolean doWait = wait && isRunning() && mainThread != Thread.currentThread();
    Object lock = new Object();
    RunnableTask rTask = new RunnableTask(r, doWait ? lock : null, true);
    Throwable throwable = null;
    synchronized (lock) {
      invokeLater(rTask);
      if (doWait) {
        try {
          lock.wait();
        } catch (InterruptedException ie) {
          throwable = ie;
        }
      }
    }
    if (null == throwable) {
      throwable = rTask.getThrowable();
    }
    if (null != throwable) {
      throw new RuntimeException(throwable);
    }
  }

  public void waitUntilIdle() {}

  public void waitUntilStopped() {}

  private void waitUntilRunning() {
    synchronized (taskWorkerLock) {
      if (isExit) return;

      while (!isRunning) {
        try {
          taskWorkerLock.wait();
        } catch (InterruptedException e) {
          e.printStackTrace();
        }
      }
    }
  }

  public void run() {
    if (DEBUG) System.err.println("MainThread.run(): " + Thread.currentThread().getName());
    synchronized (taskWorkerLock) {
      isRunning = true;
      taskWorkerLock.notifyAll();
    }
    while (!shouldStop) {
      try {
        // wait for something todo ..
        synchronized (taskWorkerLock) {
          while (!shouldStop && tasks.size() == 0) {
            try {
              taskWorkerLock.wait();
            } catch (InterruptedException e) {
              e.printStackTrace();
            }
          }

          // take over the tasks ..
          if (!shouldStop && tasks.size() > 0) {
            Runnable task = (Runnable) tasks.remove(0);
            task.run(); // FIXME: could be run outside of lock
          }
          taskWorkerLock.notifyAll();
        }
      } catch (Throwable t) {
        // handle errors ..
        t.printStackTrace();
      } finally {
        // epilog - unlock locked stuff
      }
    }
    if (DEBUG) System.err.println("MainThread.run(): " + Thread.currentThread().getName() + " fin");
    synchronized (taskWorkerLock) {
      isRunning = false;
      isExit = true;
      taskWorkerLock.notifyAll();
    }
  }
}
Exemplo n.º 4
0
  public EGLDrawableFactory() {
    super();

    // Register our GraphicsConfigurationFactory implementations
    // The act of constructing them causes them to be registered
    EGLGraphicsConfigurationFactory.registerFactory();

    // Check for other underlying stuff ..
    if (NativeWindowFactory.TYPE_X11 == NativeWindowFactory.getNativeWindowType(true)) {
      hasX11 = true;
      try {
        ReflectionUtil.createInstance(
            "jogamp.opengl.x11.glx.X11GLXGraphicsConfigurationFactory",
            EGLDrawableFactory.class.getClassLoader());
      } catch (Exception jre) {
        /* n/a .. */
      }
    }

    // FIXME: Probably need to move EGL from a static model
    // to a dynamic one, where there can be 2 instances
    // for each ES profile with their own ProcAddressTable.

    synchronized (EGLDrawableFactory.class) {
      final boolean hasDesktopES2 = null != eglES2DynamicLookupHelper;

      if (!hasDesktopES2 && null == eglES1DynamicLookupHelper) {
        GLDynamicLookupHelper tmp = null;
        try {
          tmp = new GLDynamicLookupHelper(new EGLES1DynamicLibraryBundleInfo());
        } catch (GLException gle) {
          if (DEBUG) {
            gle.printStackTrace();
          }
        }
        if (null != tmp && tmp.isLibComplete()) {
          eglES1DynamicLookupHelper = tmp;
          EGL.resetProcAddressTable(eglES1DynamicLookupHelper);
          final boolean isANGLEES1 = isANGLE(eglES1DynamicLookupHelper);
          isANGLE |= isANGLEES1;
          if (DEBUG || GLProfile.DEBUG) {
            System.err.println("Info: EGLDrawableFactory: EGL ES1 - OK, isANGLE: " + isANGLEES1);
          }
        } else if (DEBUG || GLProfile.DEBUG) {
          System.err.println("Info: EGLDrawableFactory: EGL ES1 - NOPE (ES1 lib)");
        }
      }
      if (!hasDesktopES2 && null == eglES2DynamicLookupHelper) {
        GLDynamicLookupHelper tmp = null;
        try {
          tmp = new GLDynamicLookupHelper(new EGLES2DynamicLibraryBundleInfo());
        } catch (GLException gle) {
          if (DEBUG) {
            gle.printStackTrace();
          }
        }
        if (null != tmp && tmp.isLibComplete()) {
          eglES2DynamicLookupHelper = tmp;
          EGL.resetProcAddressTable(eglES2DynamicLookupHelper);
          final boolean includesES1 =
              null == eglES1DynamicLookupHelper && includesES1(eglES2DynamicLookupHelper);
          if (includesES1) {
            eglES1DynamicLookupHelper = tmp;
          }
          final boolean isANGLEES2 = isANGLE(eglES2DynamicLookupHelper);
          isANGLE |= isANGLEES2;
          if (DEBUG || GLProfile.DEBUG) {
            System.err.println(
                "Info: EGLDrawableFactory: EGL ES2 - OK (includesES1 "
                    + includesES1
                    + ", isANGLE: "
                    + isANGLEES2
                    + ")");
            if (includesES1) {
              System.err.println("Info: EGLDrawableFactory: EGL ES1 - OK (ES2 lib)");
            }
          }
        } else if (DEBUG || GLProfile.DEBUG) {
          System.err.println("Info: EGLDrawableFactory: EGL ES2 - NOPE");
        }
      }
      if (null != eglES2DynamicLookupHelper || null != eglES1DynamicLookupHelper) {
        if (isANGLE && !enableANGLE) {
          if (DEBUG || GLProfile.DEBUG) {
            System.err.println("Info: EGLDrawableFactory.init - EGL/ES2 ANGLE disabled");
          }
        } else {
          if (isANGLE && (DEBUG || GLProfile.DEBUG)) {
            System.err.println("Info: EGLDrawableFactory.init - EGL/ES2 ANGLE enabled");
          }
          sharedMap = new HashMap<String /*uniqueKey*/, SharedResource>();
          sharedMapCreateAttempt = new HashSet<String>();

          // FIXME: Following triggers eglInitialize(..) which crashed on Windows w/ Chrome/Angle,
          // FF/Angle!
          defaultDevice =
              EGLDisplayUtil.eglCreateEGLGraphicsDevice(
                  EGL.EGL_DEFAULT_DISPLAY,
                  AbstractGraphicsDevice.DEFAULT_CONNECTION,
                  AbstractGraphicsDevice.DEFAULT_UNIT);
        }
      }
    }
  }