private void initPanels(GLCapabilities caps) {
    // create panels to draw on
    myPanels = new GLJPanel[3];
    myPanels[0] = new GLJPanel(caps);
    myPanels[1] = new GLJPanel(caps);
    myPanels[2] = new GLJPanel(caps);

    setLayout(new GridLayout(1, 3));
    add(myPanels[0]);
    add(myPanels[1]);
    add(myPanels[2]);

    // The cross section view
    CrossSectionView view0 = new CrossSectionView(this);
    myPanels[0].addGLEventListener(view0);

    // the spine view
    SpineView view1 = new SpineView(this);
    myPanels[1].addGLEventListener(view1);
    myPanels[1].addMouseMotionListener(view1);

    // the extrusion view
    ExtrusionView view2 = new ExtrusionView(this);
    myPanels[2].addGLEventListener(view2);
    myPanels[2].addMouseMotionListener(view2);

    FPSAnimator animator = new FPSAnimator(60);
    animator.add(myPanels[0]);
    animator.add(myPanels[1]);
    animator.add(myPanels[2]);
    animator.start();
  }
  /** The entry main() method */
  public static void main(String[] args) {
    // Create the OpenGL rendering canvas
    GLCanvas canvas = new GLCanvas(); // heavy-weight GLCanvas
    canvas.setPreferredSize(new Dimension(CANVAS_WIDTH, CANVAS_HEIGHT));
    canvas.addGLEventListener(new JOGL2Nehe11Flag());

    // Create a animator that drives canvas' display() at the specified FPS.
    final FPSAnimator animator = new FPSAnimator(canvas, FPS, true);

    // Create the top-level container frame
    final JFrame frame = new JFrame(); // Swing's JFrame or AWT's Frame
    frame.getContentPane().add(canvas);
    frame.addWindowListener(
        new WindowAdapter() {
          @Override
          public void windowClosing(WindowEvent e) {
            // Use a dedicate thread to run the stop() to ensure that the
            // animator stops before program exits.
            new Thread() {
              @Override
              public void run() {
                animator.stop(); // stop the animator loop
                System.exit(0);
              }
            }.start();
          }
        });
    frame.setTitle(TITLE);
    frame.pack();
    frame.setVisible(true);
    animator.start(); // start the animation loop
  }
Exemple #3
0
 public void setFrameRate(float fps) {
   if (animator != null) {
     animator.stop();
     animator.setFPS((int) fps);
     pgl.setFps(fps);
     animator.start();
   }
 }
Exemple #4
0
 public static FPSAnimator startFpsAnimator(int fps, GlimpseCanvas... canvases) {
   FPSAnimator animator = new FPSAnimator(fps);
   for (GlimpseCanvas canvas : canvases) {
     animator.add(canvas.getGLDrawable());
   }
   animator.start();
   return animator;
 }
Exemple #5
0
 public boolean isStopped() {
   if (animator != null) {
     return !animator.isAnimating();
   } else {
     return true;
   }
 }
Exemple #6
0
  private void initUI() {
    setTitle("pfps");
    setSize(800, 600);
    setLocationRelativeTo(null);
    setDefaultCloseOperation(EXIT_ON_CLOSE);

    glcanvas_ = new GLCanvas(glcap_);
    glcanvas_.addGLEventListener(this);
    this.getContentPane().add(glcanvas_, BorderLayout.CENTER);
    animator_ = new FPSAnimator(glcanvas_, 60);
    animator_.start();
    glcanvas_.addKeyListener(input_);
    glcanvas_.addMouseMotionListener(input_);

    moveTimer_ =
        new Timer(
            MOVE_TIMER_FREQ,
            new ActionListener() {
              @Override
              public void actionPerformed(ActionEvent e) {
                onMoveTimer();
              }
            });
    moveTimer_.start();

    this.addWindowListener(
        new WindowAdapter() {
          @Override
          public void windowOpened(WindowEvent e) {
            MyFrame.this.windowOpened(e);
          }
        });
  }
  public Janela(int width, int height, GLCanvas canvas) throws IOException {
    animator = new FPSAnimator(canvas, 240);
    setSize(new Dimension(width, height));
    setLocationRelativeTo(null);
    setMinimumSize(getSize());
    setDefaultCloseOperation(EXIT_ON_CLOSE);
    JPanel panel = new JPanel();
    panel.setLayout(new BorderLayout());
    panel.add(canvas, BorderLayout.CENTER);
    getContentPane().add(panel);
    canvas.addGLEventListener(new GLWindow(panel, canvas));
    addWindowListener(
        new WindowAdapter() {

          @Override
          public void windowClosing(WindowEvent e) {
            super.windowClosing(
                e); // To change body of generated methods, choose Tools | Templates.
            animator.stop();
            System.out.println("Animação parou!");
          }
        });
    setExtendedState(JFrame.MAXIMIZED_BOTH);
    setVisible(true);
    JDInfo info = new JDInfo(this, true);
    info.setVisible(true);
    animator.start();
    clip = Applet.newAudioClip(new File("./resources/Cabin.wav").toURL());
    clip.loop();
  }
  /** KeyListener method. */
  @Override
  public void keyPressed(KeyEvent ke) {
    animator.start();
    int DELTA_SIZE = 1;

    switch (ke.getKeyCode()) {
      case KeyEvent.VK_UP:
        gcodeRenderer.pan(0, DELTA_SIZE);
        // this.eye.y+=DELTA_SIZE;
        break;
      case KeyEvent.VK_DOWN:
        gcodeRenderer.pan(0, -DELTA_SIZE);
        break;
      case KeyEvent.VK_LEFT:
        gcodeRenderer.pan(-DELTA_SIZE, 0);
        break;
      case KeyEvent.VK_RIGHT:
        gcodeRenderer.pan(DELTA_SIZE, 0);
        break;
      case KeyEvent.VK_MINUS:
        if (ke.isControlDown()) gcodeRenderer.zoom(-1);
        break;
      case KeyEvent.VK_0:
      case KeyEvent.VK_ESCAPE:
        gcodeRenderer.resetView();
        break;
    }

    switch (ke.getKeyChar()) {
      case '+':
        if (ke.isControlDown()) gcodeRenderer.zoom(1);
        break;
    }
  }
 private void run() {
   setSize(800, 800);
   setLocationRelativeTo(null);
   setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
   setVisible(true);
   animator.start();
 }
Exemple #10
0
 public boolean stopThread() {
   if (animator != null) {
     return animator.stop();
   } else {
     return false;
   }
 }
  /** UGS Event Listener */
  @Override
  public void UGSEvent(UGSEvent cse) {
    if (cse.isFileChangeEvent()) {
      animator.pause();

      switch (cse.getFileState()) {
        case FILE_LOADING:
          setGcodeFile(cse.getFile());
          break;
        case FILE_LOADED:
          setProcessedGcodeFile(cse.getFile());
          break;
      }

      animator.resume();
    }
  }
 @Override
 public void mousePressed(MouseEvent e) {
   switch (e.getButton()) {
     case MouseEvent.BUTTON1:
       animator.resume();
       System.out.println("button 1, left click");
       break;
     case MouseEvent.BUTTON2:
       System.out.println("button 2");
       break;
     case MouseEvent.BUTTON3:
       System.out.println("button 3, right click");
       willAnimatorPause = true;
       animator.resume();
       break;
   }
 }
Exemple #13
0
  @Override
  public void init(GLAutoDrawable drawable) {
    super.init(drawable);
    GL3 gl = drawable.getGL().getGL3();
    gl.glClearColor(1, 1, 1, 1); // Hintergrundfarbe (RGBA)

    fpsAnimator = new FPSAnimator(drawable, 60, true);
    fpsAnimator.start();
  }
 public FirstStepNewtLast() {
   GLCapabilities caps = new GLCapabilities(GLProfile.get(GLProfile.GL2));
   GLWindow glWindow = GLWindow.create(caps);
   glWindow.setTitle("First demo (Newt)");
   glWindow.setSize(300, 300);
   glWindow.addWindowListener(
       new WindowAdapter() {
         @Override
         public void windowDestroyed(WindowEvent arg0) {
           System.exit(0);
         }
       });
   glWindow.addGLEventListener(this);
   FPSAnimator animator = new FPSAnimator(10); // (2)
   animator.add(glWindow);
   animator.start();
   glWindow.setVisible(true);
 }
Exemple #15
0
  public static void main(String[] args) {
    GLProfile glp = GLProfile.getDefault();
    GLCapabilities caps = new GLCapabilities(glp);
    GLCanvas canvas = new GLCanvas(caps);
    cube unCube = new cube();
    canvas.addGLEventListener(unCube);
    Frame frame = new Frame("AWT Window Test");
    FPSAnimator anim = new FPSAnimator(canvas, 60);
    anim.start();
    frame.setSize(400, 400);
    frame.add(canvas);
    frame.setVisible(true);

    frame.addKeyListener(
        new KeyListener() {

          @Override
          public void keyPressed(KeyEvent e) {
            // TODO Auto-generated method stub
            int keyCode = e.getKeyCode();
            unCube.handleKeyPress(keyCode); // Here is the handleKeyPress function's call
            frame.add(canvas);
          }

          @Override
          public void keyReleased(KeyEvent e) {
            // TODO Auto-generated method stub

          }

          @Override
          public void keyTyped(KeyEvent e) {
            // TODO Auto-generated method stub

          }
        });

    frame.addWindowListener(
        new WindowAdapter() {
          public void windowClosing(WindowEvent e) {
            System.exit(0);
          }
        });
  }
  @Override
  public void display(GLAutoDrawable drawable) {
    GL2 gl = drawable.getGL().getGL2();
    gl.glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // GL_DEPTH_BUFFER_BITを追加
    gl.glLoadIdentity();

    // 視点位置と視線方向
    glu.gluLookAt(3.0f, 4.0f, 5.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f);

    // 光源の位置設定
    //		gl.glLightfv(GL_LIGHT0, GL_POSITION, light0pos, 0);
    //		gl.glLightfv(GL_LIGHT1, GL_POSITION, light1pos, 0);

    // 図形の回転
    gl.glTranslatef(0.5f, 0.5f, 0.5f);
    gl.glRotatef(r, 0.0f, 1.0f, 0.0f);
    gl.glTranslatef(-0.5f, -0.5f, -0.5f);
    // 図形の色 (赤)
    //		gl.glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, red, 0);//追加
    //		gl.glColor3f(0.0f, 0.0f, 0.0f);

    // 図形の描画
    gl.glBegin(GL_QUADS);
    for (int j = 0; j < 6; ++j) {
      //			gl.glColor3fv(color[j], 0); //追加
      //			gl.glNormal3fv(normal[j], 0);
      for (int i = 0; i < 4; ++i) {
        gl.glNormal3fv(vertex[face[j][i]], 0);
        gl.glVertex3fv(vertex[face[j][i]], 0);
      }
    }
    gl.glEnd();

    // 一周回ったら回転角を 0 に戻す
    if (r++ >= 360.0f) r = 0;
    System.out.println("anim:" + animator.isAnimating() + ", r:" + r);
    if (willAnimatorPause) {
      animator.pause();
      System.out.println("animoator paused:");
      willAnimatorPause = false;
    }
  }
 /**
  * Mouse pressed is called on mouse-down. Mouse released and mouse clicked are called on mouse-up.
  */
 @Override
 public void mousePressed(MouseEvent e) {
   // Zoom
   if (e.getButton() == MouseEvent.BUTTON1 && e.isMetaDown()) {
     selecting = true;
     selectionStart = gcodeRenderer.getMouseWorldLocation();
     selection.setStart(selectionStart);
   } else {
     animator.start();
   }
 }
 @Override
 public void mouseReleased(MouseEvent e) {
   // Finish selecting.
   if (selecting) {
     selecting = false;
     selectionEnd = gcodeRenderer.getMouseWorldLocation();
     gcodeRenderer.zoomToRegion(selectionStart, selectionEnd, 1.0);
     selection.clear();
     gcodeRenderer.forceRedraw();
   }
   animator.stop();
 }
 public CubeSample6InvalidNormal() {
   GLCapabilities caps = new GLCapabilities(GLProfile.get(GLProfile.GL2));
   glu = new GLU();
   GLWindow glWindow = GLWindow.create(caps);
   glWindow.setTitle("Cube demo (Newt)");
   glWindow.setSize(300, 300);
   glWindow.addWindowListener(
       new WindowAdapter() {
         @Override
         public void windowDestroyed(WindowEvent arg0) {
           System.exit(0);
         }
       });
   glWindow.addGLEventListener(this);
   glWindow.addMouseListener(this);
   animator = new FPSAnimator(30);
   animator.add(glWindow);
   animator.start();
   animator.pause();
   glWindow.setVisible(true);
 }
  private void initPanels(GLCapabilities caps) {
    // create a panel to draw on
    myPanels = new GLJPanel[1];
    myPanels[0] = new GLJPanel(caps);

    // create a panel of sliders
    JPanel panel = initSliders();

    setLayout(new GridLayout(1, 2));
    add(myPanels[0]);
    add(panel);

    TextureView view1 = new TextureView(this);
    myPanels[0].addGLEventListener(view1);
    myPanels[0].addMouseMotionListener(view1);
    myPanels[0].addKeyListener(this);
    myPanels[0].setFocusable(true);

    FPSAnimator animator = new FPSAnimator(60);
    animator.add(myPanels[0]);
    animator.start();
  }
Exemple #21
0
  public Engine(GLCanvas canvas) {
    frame = new Frame("TRIPPIN' BALLS");
    frame.add(canvas);
    frame.setSize(600, 600);
    if (fullscreen) frame.setUndecorated(true);
    frame.setVisible(true);

    if (fullscreen) {
      GraphicsEnvironment ge = GraphicsEnvironment.getLocalGraphicsEnvironment();
      ge.getDefaultScreenDevice().setFullScreenWindow(frame);
    }

    input = new Input();
    frame.addWindowListener(input);
    canvas.addKeyListener(input);
    canvas.addMouseListener(input);
    canvas.addMouseWheelListener(input);
    canvas.addFocusListener(input);

    animator = new FPSAnimator(canvas, 60);
    animator.add(canvas);
    animator.start();
    animator.getTotalFrames();
  }
Exemple #22
0
  public void run() {

    // Create a animator that drives canvas' display() at the specified FPS.
    final FPSAnimator animator = new FPSAnimator(canvas, fPS, true);

    // Create the top-level container
    frame.addWindowListener(
        new WindowAdapter() {
          @Override
          public void windowClosing(WindowEvent e) {
            // Use a dedicate thread to run the stop() to ensure that the
            // animator stops before program exits.
            new Thread() {
              @Override
              public void run() {
                if (animator.isStarted()) animator.stop();
                System.exit(0);
              }
            }.start();
          }
        });
    frame.setVisible(true);
    animator.start();
  }
Exemple #23
0
  protected void initAnimator() {
    //  System.err.println("1. create animator");
    animator = new FPSAnimator(window, 60);
    drawException = null;
    animator.setUncaughtExceptionHandler(
        new GLAnimatorControl.UncaughtExceptionHandler() {
          @Override
          public void uncaughtException(
              final GLAnimatorControl animator,
              final GLAutoDrawable drawable,
              final Throwable cause) {
            synchronized (waitObject) {
              //        System.err.println("Caught exception: " + cause.getMessage());
              drawException = cause;
              waitObject.notify();
            }
          }
        });

    new Thread(
            new Runnable() {
              public void run() {
                synchronized (waitObject) {
                  try {
                    if (drawException == null) waitObject.wait();
                  } catch (InterruptedException e) {
                    e.printStackTrace();
                  }
                  //        System.err.println("Caught exception: " + drawException.getMessage());
                  if (drawException != null) {
                    Throwable cause = drawException.getCause();
                    if (cause instanceof ThreadDeath) {
                      //            System.out.println("caught ThreadDeath");
                      //            throw (ThreadDeath)cause;
                    } else if (cause instanceof RuntimeException) {
                      throw (RuntimeException) cause;
                    } else {
                      throw new RuntimeException(cause);
                    }
                  }
                }
              }
            })
        .start();
  }
Exemple #24
0
 public void startThread() {
   if (animator != null) {
     if (placedWindow) {
       window.setVisible(true);
       animator.start();
       requestedStart = false;
     } else {
       // The GL window is not visible until it has been placed, so we cannot
       // start the animator because it requires the window to be visible.
       requestedStart = true;
       // Need this assignment to bypass the while loop in runSketch, otherwise
       // the programs hangs waiting for defaultSize to be false, but it never
       // happens because the animation thread is not yet running to avoid showing
       // the window in the wrong place:
       // https://github.com/processing/processing/issues/3308
       //      sketch.defaultSize = false;
     }
   }
 }
 /** KeyListener method. */
 @Override
 public void keyReleased(KeyEvent ke) {
   animator.stop();
 }
Exemple #26
0
  public static void main(String _args[]) {

    final NBodyKernel kernel =
        new NBodyKernel(Range.create(Integer.getInteger("bodies", 8192), 256));

    final JFrame frame = new JFrame("NBody");

    final JPanel panel = new JPanel(new BorderLayout());
    final JPanel controlPanel = new JPanel(new FlowLayout());
    panel.add(controlPanel, BorderLayout.SOUTH);

    final JButton startButton = new JButton("Start");

    startButton.addActionListener(
        new ActionListener() {
          @Override
          public void actionPerformed(ActionEvent e) {
            running = true;
            startButton.setEnabled(false);
          }
        });
    controlPanel.add(startButton);
    controlPanel.add(new JLabel(kernel.getExecutionMode().toString()));

    controlPanel.add(new JLabel("   Particles"));
    controlPanel.add(new JTextField("" + kernel.range.getGlobalSize(0), 5));

    controlPanel.add(new JLabel("FPS"));
    final JTextField framesPerSecondTextField = new JTextField("0", 5);

    controlPanel.add(framesPerSecondTextField);
    controlPanel.add(new JLabel("Score("));
    final JLabel miniLabel =
        new JLabel("<html><small>calcs</small><hr/><small>&micro;sec</small></html>");

    controlPanel.add(miniLabel);
    controlPanel.add(new JLabel(")"));

    final JTextField positionUpdatesPerMicroSecondTextField = new JTextField("0", 5);

    controlPanel.add(positionUpdatesPerMicroSecondTextField);
    final GLCapabilities caps = new GLCapabilities(null);
    caps.setDoubleBuffered(true);
    caps.setHardwareAccelerated(true);
    final GLCanvas canvas = new GLCanvas(caps);
    final Dimension dimension =
        new Dimension(Integer.getInteger("width", 742), Integer.getInteger("height", 742));
    canvas.setPreferredSize(dimension);

    canvas.addGLEventListener(
        new GLEventListener() {
          private double ratio;

          private final float xeye = 0f;

          private final float yeye = 0f;

          private final float zeye = 100f;

          private final float xat = 0f;

          private final float yat = 0f;

          private final float zat = 0f;

          public final float zoomFactor = 1.0f;

          private int frames;

          private long last = System.currentTimeMillis();

          @Override
          public void dispose(GLAutoDrawable drawable) {}

          @Override
          public void display(GLAutoDrawable drawable) {

            final GL2 gl = drawable.getGL().getGL2();

            gl.glLoadIdentity();
            gl.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT);
            gl.glColor3f(1f, 1f, 1f);

            final GLU glu = new GLU();
            glu.gluPerspective(45f, ratio, 0f, 1000f);

            glu.gluLookAt(xeye, yeye, zeye * zoomFactor, xat, yat, zat, 0f, 1f, 0f);
            if (running) {
              kernel.execute(kernel.range);
              if (kernel.isExplicit()) {
                kernel.get(kernel.xyz);
              }
              final List<ProfileInfo> profileInfo = kernel.getProfileInfo();
              if ((profileInfo != null) && (profileInfo.size() > 0)) {
                for (final ProfileInfo p : profileInfo) {
                  System.out.print(
                      " "
                          + p.getType()
                          + " "
                          + p.getLabel()
                          + ((p.getEnd() - p.getStart()) / 1000)
                          + "us");
                }
                System.out.println();
              }
            }
            kernel.render(gl);

            final long now = System.currentTimeMillis();
            final long time = now - last;
            frames++;

            if (time > 1000) { // We update the frames/sec every second
              if (running) {
                final float framesPerSecond = (frames * 1000.0f) / time;
                final int updatesPerMicroSecond =
                    (int)
                        ((framesPerSecond
                                * kernel.range.getGlobalSize(0)
                                * kernel.range.getGlobalSize(0))
                            / 1000000);
                framesPerSecondTextField.setText(String.format("%5.2f", framesPerSecond));
                positionUpdatesPerMicroSecondTextField.setText(
                    String.format("%4d", updatesPerMicroSecond));
              }
              frames = 0;
              last = now;
            }
            gl.glFlush();
          }

          @Override
          public void init(GLAutoDrawable drawable) {
            final GL2 gl = drawable.getGL().getGL2();

            gl.glShadeModel(GLLightingFunc.GL_SMOOTH);
            gl.glEnable(GL.GL_BLEND);
            gl.glBlendFunc(GL.GL_SRC_ALPHA, GL.GL_ONE);
            try {
              final InputStream textureStream = Local.class.getResourceAsStream("particle.jpg");
              final Texture texture = TextureIO.newTexture(textureStream, false, null);
              texture.enable(gl);
            } catch (final IOException e) {
              e.printStackTrace();
            } catch (final GLException e) {
              e.printStackTrace();
            }
          }

          @Override
          public void reshape(GLAutoDrawable drawable, int x, int y, int _width, int _height) {
            width = _width;
            height = _height;

            final GL2 gl = drawable.getGL().getGL2();
            gl.glViewport(0, 0, width, height);

            ratio = (double) width / (double) height;
          }
        });

    panel.add(canvas, BorderLayout.CENTER);
    frame.getContentPane().add(panel, BorderLayout.CENTER);

    frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
    frame.pack();
    frame.setVisible(true);

    final FPSAnimator animator = new FPSAnimator(canvas, 100);
    animator.start();
  }
Exemple #27
0
 public void resumeThread() {
   if (animator != null) {
     animator.resume();
   }
 }
  protected void runTestGL(final GLCapabilities caps)
      throws AWTException, InterruptedException, InvocationTargetException {
    final JFrame frame = new JFrame("Swing GLJPanel");
    frame.setLocation(xpos, ypos);
    Assert.assertNotNull(frame);

    final FPSAnimator animator = useAnimator ? new FPSAnimator(60) : null;
    final SnapshotGLEventListener snap = new SnapshotGLEventListener();
    final GLJPanel glJPanel = newGLJPanel(frame, caps, animator, snap);
    if (null != animator) {
      animator.start();
      Assert.assertEquals(true, animator.isAnimating());
    }
    final Screen screen = NewtFactoryAWT.createScreen(glJPanel, true);
    screen.addReference(); // initial native creation - keep alive!
    System.err.println("GetPixelScale: AWT -> Screen: " + screen);

    final QuitAdapter quitAdapter = new QuitAdapter();
    new AWTKeyAdapter(new TraceKeyAdapter(quitAdapter), glJPanel).addTo(glJPanel);
    new AWTWindowAdapter(new TraceWindowAdapter(quitAdapter), glJPanel).addTo(frame);

    final JFrame[] frame2 = {null};
    final GLJPanel[] glJPanel2 = {null};

    final com.jogamp.newt.event.KeyListener kl =
        new com.jogamp.newt.event.KeyAdapter() {
          @Override
          public void keyPressed(final KeyEvent e) {
            if (e.isAutoRepeat()) {
              return;
            }
            if (e.getKeySymbol() == KeyEvent.VK_P) {
              System.err.println();
              {
                // Just for manual validation!
                final java.awt.Point los = glJPanel.getLocationOnScreen();
                final RectangleImmutable r =
                    new Rectangle(los.x, los.y, glJPanel.getWidth(), glJPanel.getHeight());
                System.err.printf("GetPixelScale: Panel Bounds: %s window-units%n", r.toString());
                System.err.printf(
                    "GetPixelScale: Panel Resolution: %d x %d pixel-units%n",
                    glJPanel.getSurfaceWidth(), glJPanel.getSurfaceHeight());
              }
              final MonitorDevice monitor = NewtFactoryAWT.getMonitorDevice(screen, glJPanel);
              System.err.printf("GetPixelScale: %s%n", monitor.toString());
              final float[] pixelPerMM;
              final boolean cached;
              if (e.isShiftDown()) {
                // SHIFT: query current mode!
                pixelPerMM = monitor.getPixelsPerMM(monitor.queryCurrentMode(), new float[2]);
                cached = false;
              } else {
                // Default: Use cached mode!
                pixelPerMM = monitor.getPixelsPerMM(new float[2]);
                cached = true;
              }
              System.err.println(
                  "  pixel/mm ["
                      + pixelPerMM[0]
                      + ", "
                      + pixelPerMM[1]
                      + "], cached-mode "
                      + cached);
              System.err.println(
                  "  pixel/in ["
                      + pixelPerMM[0] * 25.4f
                      + ", "
                      + pixelPerMM[1] * 25.4f
                      + "], cached-mode "
                      + cached);
              System.err.println();
            } else if (e.getKeyChar() == 'x') {
              final float[] hadSurfacePixelScale = glJPanel.getCurrentSurfaceScale(new float[2]);
              final float[] reqSurfacePixelScale;
              if (hadSurfacePixelScale[0] == ScalableSurface.IDENTITY_PIXELSCALE) {
                reqSurfacePixelScale =
                    new float[] {
                      ScalableSurface.AUTOMAX_PIXELSCALE, ScalableSurface.AUTOMAX_PIXELSCALE
                    };
              } else {
                reqSurfacePixelScale =
                    new float[] {
                      ScalableSurface.IDENTITY_PIXELSCALE, ScalableSurface.IDENTITY_PIXELSCALE
                    };
              }
              System.err.println(
                  "[set PixelScale pre]: had "
                      + hadSurfacePixelScale[0]
                      + "x"
                      + hadSurfacePixelScale[1]
                      + " -> req "
                      + reqSurfacePixelScale[0]
                      + "x"
                      + reqSurfacePixelScale[1]);
              glJPanel.setSurfaceScale(reqSurfacePixelScale);
              final float[] valReqSurfacePixelScale =
                  glJPanel.getRequestedSurfaceScale(new float[2]);
              final float[] hasSurfacePixelScale1 = glJPanel.getCurrentSurfaceScale(new float[2]);
              System.err.println(
                  "[set PixelScale post]: "
                      + hadSurfacePixelScale[0]
                      + "x"
                      + hadSurfacePixelScale[1]
                      + " (had) -> "
                      + reqSurfacePixelScale[0]
                      + "x"
                      + reqSurfacePixelScale[1]
                      + " (req) -> "
                      + valReqSurfacePixelScale[0]
                      + "x"
                      + valReqSurfacePixelScale[1]
                      + " (val) -> "
                      + hasSurfacePixelScale1[0]
                      + "x"
                      + hasSurfacePixelScale1[1]
                      + " (has)");
              setTitle(frame, glJPanel, caps);
            } else if (e.getKeyChar() == 'm') {
              final GLCapabilitiesImmutable capsPre = glJPanel.getChosenGLCapabilities();
              final GLCapabilities capsNew = new GLCapabilities(capsPre.getGLProfile());
              capsNew.copyFrom(capsPre);
              final boolean msaa;
              if (capsPre.getSampleBuffers()) {
                capsNew.setSampleBuffers(false);
                msaa = false;
              } else {
                capsNew.setSampleBuffers(true);
                capsNew.setNumSamples(4);
                msaa = true;
              }
              System.err.println("[set MSAA " + msaa + " Caps had]: " + capsPre);
              System.err.println("[set MSAA " + msaa + " Caps new]: " + capsNew);
              System.err.println("XXX-A1: " + animator.toString());
              glJPanel.setRequestedGLCapabilities(capsNew);
              System.err.println("XXX-A2: " + animator.toString());
              System.err.println("XXX: " + glJPanel.toString());
            } else if (e.getKeyChar() == 'n') {
              System.err.println("XXX: frame2: " + frame2[0]);
              if (null != frame2[0]) {
                System.err.println("XXX: frame2.isShowing: " + frame2[0].isShowing());
              }
              System.err.println("XXX: glJPanel2: " + glJPanel2[0]);
              if (null != frame2[0] && frame2[0].isShowing()) {
                destroy(frame2[0], glJPanel2[0]);
                frame2[0] = null;
                glJPanel2[0] = null;
              } else {
                frame2[0] = new JFrame("GLJPanel2");
                frame2[0].setLocation(frame.getX() + frame.getWidth() + 64, frame.getY());
                final FPSAnimator animator2 = useAnimator ? new FPSAnimator(60) : null;
                if (null != animator2) {
                  animator2.start();
                }
                final SnapshotGLEventListener snap2 = new SnapshotGLEventListener();
                try {
                  glJPanel2[0] = newGLJPanel(frame2[0], caps, animator2, snap2);
                } catch (final Exception e2) {
                  e2.printStackTrace();
                  destroy(frame2[0], glJPanel2[0]);
                  frame2[0] = null;
                  glJPanel2[0] = null;
                }
              }
            }
          }
        };
    new AWTKeyAdapter(kl, glJPanel).addTo(glJPanel);

    snap.setMakeSnapshot();

    if (null != rwsize) {
      Thread.sleep(500); // 500ms delay
      setFrameSize(frame, true, rwsize);
      System.err.println(
          "window resize pos/siz: "
              + glJPanel.getX()
              + "/"
              + glJPanel.getY()
              + " "
              + glJPanel.getSurfaceWidth()
              + "x"
              + glJPanel.getSurfaceHeight());
    }

    snap.setMakeSnapshot();

    final long t0 = System.currentTimeMillis();
    long t1 = t0;
    boolean triggerSnap = false;
    while (!quitAdapter.shouldQuit() && t1 - t0 < duration) {
      Thread.sleep(100);
      t1 = System.currentTimeMillis();
      snap.getDisplayCount();
      if (!triggerSnap && snap.getDisplayCount() > 1) {
        // Snapshot only after one frame has been rendered to suite FBO MSAA!
        snap.setMakeSnapshot();
        triggerSnap = true;
      }
    }

    Assert.assertNotNull(frame);
    Assert.assertNotNull(glJPanel);

    if (useAnimator) {
      Assert.assertNotNull(animator);
      animator.stop();
      Assert.assertEquals(false, animator.isAnimating());
    } else {
      Assert.assertNull(animator);
    }

    screen.removeReference(); // final native destroy
    destroy(frame, glJPanel);
    if (null != frame2[0]) {
      destroy(frame2[0], glJPanel2[0]);
    }
  }
  protected GLJPanel newGLJPanel(
      final JFrame frame,
      final GLCapabilities caps,
      final FPSAnimator animator,
      final SnapshotGLEventListener snap)
      throws AWTException, InterruptedException, InvocationTargetException {
    final GLJPanel glJPanel = new GLJPanel(caps);
    Assert.assertNotNull(glJPanel);
    glJPanel.setSkipGLOrientationVerticalFlip(skipGLOrientationVerticalFlip);
    glJPanel.setMinimumSize(wsize);
    glJPanel.setPreferredSize(wsize);
    glJPanel.setSize(wsize);
    glJPanel.setSurfaceScale(reqSurfacePixelScale);
    {
      final GLEventListener demo = createDemo(caps);
      if (null != demo) {
        glJPanel.addGLEventListener(demo);
      }
    }
    if (null != snap) {
      glJPanel.addGLEventListener(snap);
    }
    glJPanel.addGLEventListener(
        new GLEventListener() {
          @Override
          public void init(final GLAutoDrawable drawable) {}

          @Override
          public void dispose(final GLAutoDrawable drawable) {}

          @Override
          public void display(final GLAutoDrawable drawable) {}

          @Override
          public void reshape(
              final GLAutoDrawable drawable,
              final int x,
              final int y,
              final int width,
              final int height) {
            setTitle(frame, glJPanel, caps);
          }
        });
    setTitle(frame, glJPanel, caps);

    frame.addComponentListener(
        new ComponentListener() {
          @Override
          public void componentResized(final ComponentEvent e) {
            setTitle(frame, glJPanel, caps);
          }

          @Override
          public void componentMoved(final ComponentEvent e) {
            setTitle(frame, glJPanel, caps);
          }

          @Override
          public void componentShown(final ComponentEvent e) {}

          @Override
          public void componentHidden(final ComponentEvent e) {}
        });

    if (SwingUtilities.isEventDispatchThread()) {
      frame.getContentPane().add(glJPanel, BorderLayout.CENTER);
      frame.getContentPane().validate();
      frame.pack();
      frame.setVisible(true);
    } else {
      SwingUtilities.invokeAndWait(
          new Runnable() {
            public void run() {
              frame.getContentPane().add(glJPanel, BorderLayout.CENTER);
              frame.getContentPane().validate();
              frame.pack();
              frame.setVisible(true);
            }
          });
      Assert.assertEquals(true, AWTRobotUtil.waitForVisible(frame, true));
      Assert.assertEquals(true, AWTRobotUtil.waitForRealized(glJPanel, true));

      final float[] minSurfacePixelScale = glJPanel.getMinimumSurfaceScale(new float[2]);
      final float[] maxSurfacePixelScale = glJPanel.getMaximumSurfaceScale(new float[2]);
      final float[] valReqSurfacePixelScale = glJPanel.getRequestedSurfaceScale(new float[2]);
      final float[] hasSurfacePixelScale = glJPanel.getCurrentSurfaceScale(new float[2]);
      System.err.println(
          "HiDPI PixelScale: min "
              + minSurfacePixelScale[0]
              + "x"
              + minSurfacePixelScale[1]
              + ", max "
              + maxSurfacePixelScale[0]
              + "x"
              + maxSurfacePixelScale[1]
              + ", req "
              + reqSurfacePixelScale[0]
              + "x"
              + reqSurfacePixelScale[1]
              + " -> val "
              + valReqSurfacePixelScale[0]
              + "x"
              + valReqSurfacePixelScale[1]
              + " -> has "
              + hasSurfacePixelScale[0]
              + "x"
              + hasSurfacePixelScale[1]);
      setTitle(frame, glJPanel, caps);
    }

    if (null != animator) {
      animator.add(glJPanel);
      animator.setUpdateFPSFrames(60, System.err);
    }
    return glJPanel;
  }
Exemple #30
0
 public void pauseThread() {
   if (animator != null) {
     animator.pause();
   }
 }