예제 #1
0
  @Override
  public void start(Stage stage) {
    stage.initStyle(StageStyle.TRANSPARENT);
    stage.setAlwaysOnTop(true);
    VBox box = new VBox();
    imageView = new ImageView(sprites[currentFrame]);

    box.getChildren().add(imageView);
    final Scene scene = new Scene(box, 0, 0);
    Rectangle2D screenBounds = Screen.getPrimary().getVisualBounds();
    stage.setX(currentX);
    stage.setY(currentY);
    scene.setFill(null);
    stage.setScene(scene);
    mainLoop = new Timeline();
    mainLoop.setCycleCount(Animation.INDEFINITE);
    renderFrame =
        new KeyFrame(
            frameDuration,
            new EventHandler<ActionEvent>() {
              public void handle(ActionEvent event) {
                Double currentFrameWidth = sprites[currentFrame].getWidth();
                Double currentFrameHeight = sprites[currentFrame].getHeight();
                stage.setWidth(currentFrameWidth);
                stage.setHeight(currentFrameHeight);
                currentY = screenBounds.getMinY() + screenBounds.getHeight() - currentFrameHeight;

                Double minLimitX = 0.0;
                Double maxLimitX =
                    screenBounds.getMinX() + screenBounds.getWidth() - currentFrameWidth;
                if (currentX >= maxLimitX || currentX <= minLimitX) {
                  velocity = -1 * velocity;
                  currentX = currentX >= maxLimitX ? maxLimitX - 1 : minLimitX + 1;
                  currentWalkingFrame = 0;
                } else {
                  currentX += velocity;
                }

                if (velocity > 0) {
                  currentFrame = walking_right_indexes[currentWalkingFrame];
                } else {
                  currentFrame = walking_left_indexes[currentWalkingFrame];
                }

                stage.setX(currentX);
                stage.setY(currentY);
                imageView.setImage(sprites[currentFrame]);
                currentWalkingFrame = (++currentWalkingFrame) % walking_right_indexes.length;
              }
            });
    mainLoop.getKeyFrames().add(renderFrame);
    stage.show();
    mainLoop.play();
  }
예제 #2
0
  public void setMode(Mode mode) {
    if (mode != this.mode) {
      Mode previousMode = this.mode;
      this.mode = mode;
      log.info(String.format("Dock mode is now %s", mode));
      switch (mode) {
        case LAUNCHERS:
          rebuildIcons();
          setAvailable();
          flinger.recentre();
          break;
        case UPDATE:
          try {
            // Starting an update, so hide the all other windows
            hideIfShowing(signInPopup);
            hideIfShowing(optionsPopup);
            hideIfShowing(resourceGroupPopup);
            setAvailable();
            updateScene =
                (Update)
                    context.openScene(
                        Update.class, Configuration.getDefault().isVertical() ? "Vertical" : null);
            Scene scn = updateScene.getScene();
            scn.setFill(new Color(0, 0, 0, 0));

            /*
             * The update popup will get future update events, but it
             * needs this one to initialize
             */
            updateScene.initUpdate(appsToUpdate, previousMode);

            Parent sceneRoot = scn.rootProperty().get();
            scn.setRoot(new Group());

            if (cfg.isVertical())
              ((VBox) sceneRoot).minWidthProperty().bind(shortcuts.heightProperty());
            else ((HBox) sceneRoot).minHeightProperty().bind(shortcuts.widthProperty());

            flinger.getContent().getChildren().clear();
            flinger.getContent().getChildren().add(sceneRoot);
          } catch (IOException ioe) {
            log.error("Failed to load update scene.", ioe);
          }
          break;
        case IDLE:
          flinger.getContent().getChildren().clear();
          setAvailable();
          break;
        default:
          throw new UnsupportedOperationException();
      }
    }
  }
  @Override
  public void start(Stage stage) {
    if (!Platform.isSupported(ConditionalFeature.SCENE3D)) {
      throw new RuntimeException("*** ERROR: common conditional SCENE3D is not supported");
    }

    stage.setTitle("JavaFX SubScene And Scene Anti-aliasing Test");

    Group root = new Group();
    Scene scene = new Scene(root, 1000, 800);
    scene.setFill(Color.color(0.2, 0.2, 0.2, 1.0));

    HBox hbox = new HBox();
    hbox.setLayoutX(75);
    hbox.setLayoutY(200);

    PhongMaterial phongMaterial = new PhongMaterial(Color.color(1.0, 0.7, 0.8));
    Cylinder cylinder1 = new Cylinder(100, 200);
    cylinder1.setMaterial(phongMaterial);
    SubScene noMsaa =
        createSubScene(
            "Scene Anti-aliasing = false",
            cylinder1,
            Color.TRANSPARENT,
            new PerspectiveCamera(),
            false);
    hbox.getChildren().add(noMsaa);

    Cylinder cylinder2 = new Cylinder(100, 200);
    cylinder2.setMaterial(phongMaterial);
    SubScene msaa =
        createSubScene(
            "Scene Anti-aliasing = true",
            cylinder2,
            Color.TRANSPARENT,
            new PerspectiveCamera(),
            true);
    hbox.getChildren().add(msaa);

    Slider slider = new Slider(0, 360, 0);
    slider.setBlockIncrement(1);
    slider.setTranslateX(425);
    slider.setTranslateY(625);
    cylinder1.rotateProperty().bind(slider.valueProperty());
    cylinder2.rotateProperty().bind(slider.valueProperty());
    root.getChildren().addAll(hbox, slider);

    stage.setScene(scene);
    stage.show();
  }
예제 #4
0
파일: Jidget.java 프로젝트: derari/jidget
  private synchronized void asyncInitFrame() {
    if (active) {
      Scene scene = new Scene(root);
      scene.setFill(Color.TRANSPARENT);
      for (File f : styles) {
        scene.getStylesheets().add(f.toURI().toString());
      }
      styles = null;

      this.frame = FrameFactory.create(scene);
      double x = Double.isNaN(memento.x) ? frame.getX() : memento.x;
      double y = Double.isNaN(memento.y) ? frame.getY() : memento.y;
      frame.setLocation(x, y);
    }
  }
예제 #5
0
파일: Main.java 프로젝트: john-caine/SWENG
  public void start(Stage primaryStage) {

    try {
      screenBounds = Screen.getPrimary().getVisualBounds();
      Group root = new Group();
      Scene scene = new Scene(root, screenBounds.getWidth(), screenBounds.getHeight());
      root.getChildren().add(new MainMenu(primaryStage).bigBox);
      scene.setFill(Color.WHITE);
      primaryStage.setScene(scene);
      primaryStage.initStyle(StageStyle.UNDECORATED);
      primaryStage.setFullScreen(true);
      primaryStage.show();
    } catch (Exception e) {
      e.printStackTrace();
    }
  }
예제 #6
0
  @Override
  public void start(Stage stage) throws Exception {

    Group group = new Group();
    Scene scene = new Scene(group);
    scene.setFill(Color.GREY);
    for (int i = 0; i <= 27; i++) {
      Sector sector = new Sector(20 * i, 20 * i, 10 * i, 20 * i);
      group.getChildren().add(sector);
    }

    stage.setTitle("Hello, SectorApplication!");
    stage.setScene(scene);
    stage.setWidth(600);
    stage.setHeight(620);
    stage.show();
  }
예제 #7
0
파일: Main.java 프로젝트: Messen/HudBuilder
  @Override
  public void start(Stage primaryStage) throws Exception {

    Example.checkExample();

    FXMLLoader fxmlLoader = new FXMLLoader();
    Parent root = fxmlLoader.load(getClass().getResource("gui.fxml").openStream());
    this.controller = fxmlLoader.getController();
    if (this.controller != null) {
      primaryStage.setTitle("Hud Builder v1.0 by C.R.Messen");
      Scene scene = new Scene(root);
      scene.setFill(null);
      primaryStage.setScene(scene);
      this.controller.load();
      primaryStage.show();
    } else {
      System.exit(0);
    }
  }
예제 #8
0
  @Override
  public void start(Stage stage) {
    configuration();

    Constants constants = Constants.getInstance();

    this.stage = stage;

    Group root = new Group();
    Scene scene = new Scene(root, constants.getWidth(), constants.getHeight());
    scene.setCamera(new PerspectiveCamera());
    scene.setFill(null);
    stage.setScene(scene);

    try {
      root.getChildren().add(new Binder(this, constants.getFactories()));
    } catch (IOException ex) {
      root.getChildren().add(new Label("IOError"));
    }

    stage.initStyle(StageStyle.TRANSPARENT);
    stage.show();
  }
예제 #9
0
  @Override
  public void start(Stage primaryStage) {
    Button btn = new Button();
    btn.setText("Say 'Hello World'");
    btn.setOnAction(
        new EventHandler<ActionEvent>() {

          @Override
          public void handle(ActionEvent event) {
            System.out.println("Hello World!");
          }
        });

    StackPane root = new StackPane();
    root.setBackground(Background.EMPTY);
    root.getChildren().add(btn);
    Scene scene = new Scene(root, 300, 250);
    scene.setFill(Color.TRANSPARENT);
    primaryStage.setTitle("Hello World!");
    primaryStage.initStyle(javafx.stage.StageStyle.TRANSPARENT);
    primaryStage.setScene(scene);
    primaryStage.show();
  }
  @Override
  public void start(Stage stage) {
    stage.setTitle("Menu Sample");
    Scene scene = new Scene(new VBox(), 400, 350);
    scene.setFill(Color.BLACK);

    MenuBar menuBar = new MenuBar();

    // --- Menu File
    Menu menuFile = new Menu("File");

    // --- Menu Edit
    Menu menuEdit = new Menu("Edit");

    // --- Menu View
    Menu menuView = new Menu("Lagersaldo för butik");

    menuBar.getMenus().addAll(menuFile, menuEdit, menuView);

    ((VBox) scene.getRoot()).getChildren().addAll(menuBar);

    stage.setScene(scene);
    stage.show();
  }
예제 #11
0
  @Override
  public void start(Stage stage) throws Exception {

    this.mainBorderPane = new BorderPane();

    FlowPane toolbar = new FlowPane();

    Button btnClear = new Button("Clear");

    btnClear.setOnAction(
        event -> {
          root.getChildren().clear();
        });
    Button btnLoadFtof = new Button("FTOF");

    btnLoadFtof.setOnAction(
        event -> {
          loadDetector("FTOF");
        });

    toolbar.getChildren().add(btnClear);
    toolbar.getChildren().add(btnLoadFtof);

    SplitPane splitPane = new SplitPane();
    StackPane treePane = new StackPane();

    root = new Group();
    BorderPane pane = new BorderPane();

    treeView = new TreeView<String>();

    treePane.getChildren().add(treeView);

    this.content = new ContentModel(800, 800, 200);
    this.content.setContent(root);

    content.getSubScene().heightProperty().bind(pane.heightProperty());
    content.getSubScene().widthProperty().bind(pane.widthProperty());

    pane.setCenter(content.getSubScene());
    mainBorderPane.setTop(toolbar);
    splitPane.getItems().addAll(treePane, pane);
    splitPane.setDividerPositions(0.2);

    // this.addDetector("FTOF");
    // this.test();
    this.testFTOF();
    // this.testDC();
    // this.testBST();
    // final Scene scene = new Scene(pane, 880, 880, true);
    this.mainBorderPane.setCenter(splitPane);
    HBox statusPane = new HBox();

    ColorPicker colorPicker = new ColorPicker();
    colorPicker.setOnAction(
        new EventHandler() {
          @Override
          public void handle(Event event) {
            content.setBackgroundColor(colorPicker.getValue());
          }
        });
    statusPane.getChildren().add(colorPicker);
    this.mainBorderPane.setBottom(statusPane);

    final Scene scene = new Scene(mainBorderPane, 1280, 880, true);

    scene.setFill(Color.ALICEBLUE);
    stage.setTitle("CLAS12 Geometry Viewer - JavaFX3D");
    stage.setScene(scene);
    stage.show();
  }
예제 #12
0
  @Override
  public void start(Stage primaryStage) throws Exception {
    Group sceneRoot = new Group();
    Scene scene = new Scene(sceneRoot, sceneWidth, sceneHeight, true, SceneAntialiasing.BALANCED);
    scene.setFill(Color.BLACK);
    camera = new PerspectiveCamera(true);
    camera.setNearClip(0.1);
    camera.setFarClip(10000.0);
    camera.setTranslateZ(-1000);
    scene.setCamera(camera);

    ArrayList<Point3D> points = new ArrayList<>();
    for (int i = -250; i < 250; i++) {
      points.add(
          new Point3D((float) i, (float) Math.sin(i) * 50 + i, (float) Math.cos(i) * 50 + i));
    }
    polyLine3D = new PolyLine3D(points, 3, Color.STEELBLUE);
    sceneRoot.getChildren().addAll(polyLine3D);

    scene.setOnKeyPressed(
        event -> {
          double change = 10.0;
          // Add shift modifier to simulate "Running Speed"
          if (event.isShiftDown()) {
            change = 50.0;
          }
          // What key did the user press?
          KeyCode keycode = event.getCode();
          // Step 2c: Add Zoom controls
          if (keycode == KeyCode.W) {
            camera.setTranslateZ(camera.getTranslateZ() + change);
          }
          if (keycode == KeyCode.S) {
            camera.setTranslateZ(camera.getTranslateZ() - change);
          }
          // Step 2d:  Add Strafe controls
          if (keycode == KeyCode.A) {
            camera.setTranslateX(camera.getTranslateX() - change);
          }
          if (keycode == KeyCode.D) {
            camera.setTranslateX(camera.getTranslateX() + change);
          }
        });

    // Add a Mouse Handler for Rotations
    Rotate xRotate = new Rotate(0, Rotate.X_AXIS);
    Rotate yRotate = new Rotate(0, Rotate.Y_AXIS);
    Rotate zRotate = new Rotate(0, Rotate.Z_AXIS);

    polyLine3D.getTransforms().addAll(xRotate, yRotate);
    // Use Binding so your rotation doesn't have to be recreated
    xRotate.angleProperty().bind(angleX);
    yRotate.angleProperty().bind(angleY);
    zRotate.angleProperty().bind(angleZ);

    // Start Tracking mouse movements only when a button is pressed
    scene.setOnMousePressed(
        event -> {
          scenex = event.getSceneX();
          sceney = event.getSceneY();
          fixedXAngle = angleX.get();
          fixedYAngle = angleY.get();
          if (event.isMiddleButtonDown()) {
            scenez = event.getSceneX();
            fixedZAngle = angleZ.get();
          }
        });
    // Angle calculation will only change when the button has been pressed
    scene.setOnMouseDragged(
        event -> {
          if (event.isMiddleButtonDown()) angleZ.set(fixedZAngle - (scenez - event.getSceneY()));
          else angleX.set(fixedXAngle - (scenex - event.getSceneY()));
          angleY.set(fixedYAngle + sceney - event.getSceneX());
        });

    primaryStage.setTitle("F(X)yz ScatterPlotTest");
    primaryStage.setScene(scene);
    primaryStage.show();
  }
예제 #13
0
파일: Main.java 프로젝트: jkwhite/caspar
  public void start(final Stage stage) {
    for (ConditionalFeature f : EnumSet.allOf(ConditionalFeature.class)) {
      System.err.println(f + ": " + Platform.isSupported(f));
    }
    Rectangle2D screen = Screen.getPrimary().getVisualBounds();
    final Random rand = new Random();

    /*
    final Group starfield = new Group();
    for(int i=0;i<66;i++) {
        int size = rand.nextInt(3)+1;
        if(size==3) {
            size = rand.nextInt(3)+1;
        }
        Circle circ = new Circle(rand.nextInt((int)screen.getWidth()), rand.nextInt(200+(int)screen.getHeight())-200,
            size);
        circ.setFill(Color.rgb(200,200,200+rand.nextInt(56)));
        circ.setTranslateZ(1+rand.nextInt(40));
        starfield.getChildren().add(circ);
    }
    */
    final List<Starfield> stars = new ArrayList<>();
    for (int i = 0; i < 10; i++) {
      int sw = (int) screen.getWidth(), sh = (int) screen.getHeight();
      Starfield sf = new Starfield(rand, -sw, -sh, 2 * sw, 2 * sh, rand.nextInt(30) + 10);
      sf.setTranslateZ(rand.nextInt(2000) + 50);
      stars.add(sf);
    }
    // final Starfield starfield2 = new Starfield(rand, -200, -200, (int)screen.getWidth(),
    // (int)screen.getHeight()+200, 40);

    final Ruleset1D rules =
        new Ruleset1D(new int[] {Colors.randomColor(rand), Colors.randomColor(rand)});
    final Ruleset rules2 = new Rulespace1D(rules);
    // Rule rule = rules.random(rand).next();
    Iterator<Rule> it = rules.iterator();
    GridPane gridp = new GridPane();
    int i = 0, j = 0;
    while (it.hasNext()) {
      Rule rule = it.next();
      CA ca = new CA(rule, new RandomInitializer(), rand, 42, 100, 100);
      Plane plane = ca.createPlane();
      ImageView imview = new ImageView(plane.toImage());
      imview.setSmooth(true);
      imview.setFitWidth(30);
      imview.setPreserveRatio(true);
      gridp.add(imview, i, j);
      if (++i == 16) {
        i = 0;
        j++;
      }
    }
    // gridp.setScaleX(0.3);
    // gridp.setScaleY(0.3);
    // gridp.setPrefSize(100*3/3, 100*3/3);
    // gridp.setMaxSize(100*3/3, 100*3/3);

    final double XTRANS = screen.getWidth() / 2 - 30 * 16 / 2;
    final double YTRANS = screen.getHeight() / 2 - 30 * 16 / 2;
    // gridp.setTranslateX((screen.getWidth()/2+100*16/2)*0.3);
    // gridp.setTranslateX(0);
    gridp.setTranslateX(XTRANS);
    gridp.setTranslateY(YTRANS);
    // gridp.setAlignment(Pos.CENTER);
    Group grid = new Group(gridp);
    // grid.setTranslateX(0);
    // grid.setTranslateY(0);

    // gridp.relocate(-400, -400);
    // gridp.setTranslateX(-300);
    // gridp.setTranslateY(-150);

    /*
    final RotateTransition rt = new RotateTransition(Duration.millis(3000), gridp);
    rt.setByAngle(180);
    rt.setCycleCount(4);
    rt.setAutoReverse(true);
    */
    // rt.setAutoReverse(false);

    /*`
    final BorderPane border = new BorderPane();
    */
    // Label title = new Label("EXPLORATIONS IN CELLULAR SPACES");
    Label title = new Label("E  X  P  L  O  R  A  T  I  O  N  S");
    title.setFont(new Font("Helvetica Neue Condensed Bold", 36));
    title.setTextFill(Color.WHITE);
    // Label title2 = new Label("IN CELLULAR SPACES");
    Label title2 = new Label("EXPLORATIONS IN CELLULAR SPACES");
    title2.setFont(new Font("Helvetica Neue Condensed Bold", 28));
    title2.setTextFill(Color.WHITE);
    /*`
    title.setAlignment(Pos.CENTER);
    title.setContentDisplay(ContentDisplay.CENTER);
    title.setTextAlignment(TextAlignment.CENTER);
    */
    final HBox toptitle = new HBox();
    toptitle.setAlignment(Pos.CENTER);
    toptitle.getChildren().add(title);
    toptitle.setTranslateX(XTRANS);
    toptitle.setTranslateY(YTRANS - 36);

    final HBox btitle = new HBox();
    btitle.setAlignment(Pos.CENTER);
    title2.setAlignment(Pos.CENTER);
    btitle.getChildren().add(title2);
    btitle.setTranslateX(XTRANS);
    // btitle.setTranslateX(screen.getWidth()/2-title2.getPrefWidth()/2);
    btitle.setTranslateY(YTRANS + 30 * 16);

    Group border = new Group();
    // border.getChildren().add(toptitle);
    for (Starfield st : stars) {
      border.getChildren().add(st);
    }
    // border.getChildren().add(starfield2);
    border.getChildren().add(btitle);
    border.getChildren().add(grid);

    final List<TranslateTransition> tts = new ArrayList<>();
    final TranslateTransition tt = new TranslateTransition(Duration.millis(6000), grid);
    tt.setByY(2000);
    tts.add(tt);
    for (Starfield sf : stars) {
      TranslateTransition st = new TranslateTransition(Duration.millis(6000), sf);
      st.setByY(200);
      st.setByZ(100 + rand.nextInt(100));
      tts.add(st);
    }
    /*
    final TranslateTransition tt2 = new TranslateTransition(Duration.millis(6000), starfield1);
    tt2.setByY(200);
    tt2.setByZ(200);
    final TranslateTransition tt3 = new TranslateTransition(Duration.millis(6000), starfield2);
    tt3.setByY(300);
    tt3.setByZ(200);
    */
    // final ParallelTransition infinite = new ParallelTransition(tt, tt2, tt3);
    final ParallelTransition infinite =
        new ParallelTransition(tts.toArray(new TranslateTransition[0]));

    final BorderPane ctrl = new BorderPane();
    // ctrl.setPrefSize(200, 100);
    // ctrl.setMaxSize(200, 100);
    Label start = new Label("Start");
    start.setTextFill(Color.WHITE);
    start.setFont(new Font("Helvetica", 28));
    start.setAlignment(Pos.CENTER_LEFT);
    start.setContentDisplay(ContentDisplay.CENTER);
    start.setTranslateX(XTRANS + 30 * 16 + 100);
    start.setTranslateY(screen.getHeight() / 2);
    // start.setTranslateX(-400);
    Circle ico = new Circle(15);
    ico.setOnMouseClicked(
        new EventHandler<MouseEvent>() {
          @Override
          public void handle(MouseEvent e) {
            FadeTransition ft = new FadeTransition(Duration.millis(500), ctrl);
            ft.setFromValue(1.0);
            ft.setToValue(0.0);
            FadeTransition tft = new FadeTransition(Duration.millis(500), btitle);
            tft.setFromValue(1.0);
            tft.setToValue(0.0);
            ParallelTransition pt = new ParallelTransition(ft, tft);
            // TranslateTransition fft = new TranslateTransition(Duration.millis(3000), border);
            // tt.setByY(2000);
            SequentialTransition st = new SequentialTransition(pt, infinite);
            st.setOnFinished(
                new EventHandler<ActionEvent>() {
                  public void handle(ActionEvent e) {
                    State state = State.state().rules(rules2).random(new Rand()).size(400);
                    Iterator<Rule> it = state.rules().random(state.random().create());
                    CA ca =
                        new CA(
                            it.next(),
                            new RandomInitializer(),
                            state.random().create(),
                            0,
                            state.size(),
                            state.size());
                    state.ca(ca);
                    // final Futures futures = new Futures(rules2, new Rand());
                    final Controls controls = new Controls(state);
                    // controls.setTranslateX(screen.getWidth()/2 -
                    // futures.getPossibilityWidth()/2);
                    // controls.setTranslateY(screen.getHeight()/2 -
                    // futures.getPossiblityHeight()/2-20);

                    // controls.setTranslateX(screen.getWidth()/2 - (3*200+2*10)/2);
                    // controls.setTranslateY(screen.getHeight()/2 - (3*200+2*10)/2-20);

                    for (Starfield sf : stars) {
                      state.addListener(sf);
                      // futures.addFutureListener(sf);
                    }
                    // futures.addFutureListener(starfield1);
                    // futures.addFutureListener(starfield2);
                    border.getChildren().remove(grid);
                    border.getChildren().remove(btitle);
                    // border.getChildren().add(futures);
                    border.getChildren().add(controls);
                    // futures.setTranslateX(screen.getWidth()/2 - futures.getPossibilityWidth()/2);
                    // futures.setTranslateY(screen.getHeight()/2 -
                    // futures.getPossiblityHeight()/2);
                    // border.setCenter(futures);
                    // border.setAlignment(futures, Pos.CENTER);
                  }
                });
            st.play();
          }
        });
    // Sphere ico = new Sphere(15);
    // ico.setDrawMode(DrawMode.LINE);
    ico.setFill(Color.rgb(10, 10, 10));
    ico.setStroke(Color.WHITE);
    ico.setStrokeWidth(3);
    ico.setTranslateX(XTRANS + 30 * 16 + 100);
    ico.setTranslateY(screen.getHeight() / 2);
    // ctrl.setTop(ico);
    ctrl.setCenter(ico);
    /*
    border.setRight(ctrl);

    border.setMaxSize(800,600);
    border.setPrefSize(800,600);
    */
    border.getChildren().add(ctrl);
    Group root = new Group();
    root.getChildren().add(border);
    // root.setAutoSizeChildren(false);
    // root.setLayoutX(-400);
    // root.setLayoutY(-400);
    // Scene scene = new Scene(root, 1200, 1000);
    Scene scene = new Scene(root, 1280, 1024, true, SceneAntialiasing.DISABLED);
    scene.setFill(Color.BLACK);
    scene.setCamera(new PerspectiveCamera());

    // set Stage boundaries to visible bounds of the main screen
    stage.setX(screen.getMinX());
    stage.setY(screen.getMinY());
    stage.setWidth(screen.getWidth());
    stage.setHeight(screen.getHeight());

    stage.setTitle("Explorations in Cellular Spaces");
    stage.setScene(scene);
    stage.setResizable(false);
    // root.autosize();
    // stage.sizeToScene();
    stage.show();
  }
예제 #14
0
  @Override
  public void start(Stage stage) {

    Group spheroidGroup = new Group();
    for (int i = 0; i < 50; i++) {
      Random r = new Random();
      // A lot of magic numbers in here that just artificially constrain the math
      float randomMajorRadius = (float) ((r.nextFloat() * 300) + 50);
      float randomMinorRadius = (float) ((r.nextFloat() * 300) + 50);
      int randomDivisions = (int) ((r.nextFloat() * 64) + 1);
      Color randomColor = new Color(r.nextDouble(), r.nextDouble(), r.nextDouble(), r.nextDouble());

      Spheroid sm =
          new Spheroid(randomDivisions, randomMajorRadius, randomMinorRadius, randomColor);
      sm.setDrawMode(DrawMode.LINE);
      double translationX = Math.random() * 1024 * 1.95;
      if (Math.random() >= 0.5) {
        translationX *= -1;
      }
      double translationY = Math.random() * 1024 * 1.95;
      if (Math.random() >= 0.5) {
        translationY *= -1;
      }
      double translationZ = Math.random() * 1024 * 1.95;
      if (Math.random() >= 0.5) {
        translationZ *= -1;
      }
      Translate translate = new Translate(translationX, translationY, translationZ);
      Rotate rotateX = new Rotate(Math.random() * 360, Rotate.X_AXIS);
      Rotate rotateY = new Rotate(Math.random() * 360, Rotate.Y_AXIS);
      Rotate rotateZ = new Rotate(Math.random() * 360, Rotate.Z_AXIS);

      sm.getTransforms().addAll(translate, rotateX, rotateY, rotateZ);

      spheroidGroup.getChildren().add(sm);
    }
    root.getChildren().add(spheroidGroup);

    System.out.println(spheroidGroup.getChildren().size());

    camera = new PerspectiveCamera(true);
    cameraTransform.setTranslate(0, 0, 0);
    cameraTransform.getChildren().addAll(camera);
    camera.setNearClip(0.1);
    camera.setFarClip(10000.0);
    camera.setFieldOfView(42);
    camera.setTranslateZ(cameraDistance);
    cameraTransform.ry.setAngle(-45.0);
    cameraTransform.rx.setAngle(-10.0);
    // add a Point Light for better viewing of the grid coordinate system
    PointLight light = new PointLight(Color.WHITE);

    cameraTransform.getChildren().add(light);
    light.setTranslateX(camera.getTranslateX());
    light.setTranslateY(camera.getTranslateY());
    light.setTranslateZ(camera.getTranslateZ());
    root.getChildren().add(cameraTransform);

    Scene scene = new Scene(new StackPane(root), 1024, 668, true, SceneAntialiasing.BALANCED);
    scene.setCamera(camera);
    scene.setFill(Color.BLACK);
    initFirstPersonControls(scene);

    stage.setTitle("Hello World!");
    stage.setScene(scene);
    stage.show();
  }
예제 #15
0
  @Override
  public void start(Stage primaryStage) throws Exception {
    Group sceneRoot = new Group();
    Scene scene = new Scene(sceneRoot, sceneWidth, sceneHeight, true, SceneAntialiasing.BALANCED);
    scene.setFill(Color.BLACK);
    camera = new PerspectiveCamera(true);

    // setup camera transform for rotational support
    cameraTransform.setTranslate(0, 0, 0);
    cameraTransform.getChildren().add(camera);
    camera.setNearClip(0.1);
    camera.setFarClip(10000.0);
    camera.setTranslateX(0);
    camera.setTranslateZ(-1000);
    cameraTransform.ry.setAngle(-25.0);
    cameraTransform.rx.setAngle(-10.0);
    // add a Point Light for better viewing of the grid coordinate system
    PointLight light = new PointLight(Color.WHITE);
    cameraTransform.getChildren().add(new AmbientLight());
    light.setTranslateX(camera.getTranslateX());
    light.setTranslateY(camera.getTranslateY());
    light.setTranslateZ(camera.getTranslateZ());
    scene.setCamera(camera);
    long time = System.currentTimeMillis();
    Group group = new Group(cameraTransform);
    List<Point3D> data = new ArrayList<>();

    //        // create some data
    //        IntStream.range(0,100000)
    //                .forEach(i->data.add(new Point3D((float)(30*Math.sin(50*i)),
    //                                    (float)(Math.sin(i)*(100+30*Math.cos(100*i))),
    //                                    (float)(Math.cos(i)*(100+30*Math.cos(200*i))),
    //                                    i))); // <-- f
    //        // and write to csv file
    //        Path out = Paths.get("output.txt");
    //
    // Files.write(out,data.stream().map(p3d->p3d.toCSV()).collect(Collectors.toList()),Charset.defaultCharset());

    // read from csv file
    Path out = getCSVFile(0);
    if (out != null) {
      Files.lines(out)
          .map(s -> s.split(";"))
          .forEach(
              s ->
                  data.add(
                      new Point3D(
                          Float.parseFloat(s[0]),
                          Float.parseFloat(s[1]),
                          Float.parseFloat(s[2]),
                          Float.parseFloat(s[3]))));
    }

    ScatterMesh scatter = new ScatterMesh(data, true, 1, 0);
    // DENSITY
    // texture is given by p.f value, don't change this!
    scatter.setTextureModeVertices3D(1530, p -> p.f);

    group.getChildren().add(scatter);
    sceneRoot.getChildren().addAll(group);

    // First person shooter keyboard movement
    scene.setOnKeyPressed(
        event -> {
          double change = 10.0;
          // Add shift modifier to simulate "Running Speed"
          if (event.isShiftDown()) {
            change = 50.0;
          }
          // What key did the user press?
          KeyCode keycode = event.getCode();
          // Step 2c: Add Zoom controls
          if (keycode == KeyCode.W) {
            camera.setTranslateZ(camera.getTranslateZ() + change);
          }
          if (keycode == KeyCode.S) {
            camera.setTranslateZ(camera.getTranslateZ() - change);
          }
          // Step 2d:  Add Strafe controls
          if (keycode == KeyCode.A) {
            camera.setTranslateX(camera.getTranslateX() - change);
          }
          if (keycode == KeyCode.D) {
            camera.setTranslateX(camera.getTranslateX() + change);
          }
        });

    scene.setOnMousePressed(
        (MouseEvent me) -> {
          mousePosX = me.getSceneX();
          mousePosY = me.getSceneY();
          mouseOldX = me.getSceneX();
          mouseOldY = me.getSceneY();
        });
    scene.setOnMouseDragged(
        (MouseEvent me) -> {
          mouseOldX = mousePosX;
          mouseOldY = mousePosY;
          mousePosX = me.getSceneX();
          mousePosY = me.getSceneY();
          mouseDeltaX = (mousePosX - mouseOldX);
          mouseDeltaY = (mousePosY - mouseOldY);

          double modifier = 10.0;
          double modifierFactor = 0.1;

          if (me.isControlDown()) {
            modifier = 0.1;
          }
          if (me.isShiftDown()) {
            modifier = 50.0;
          }
          if (me.isPrimaryButtonDown()) {
            cameraTransform.ry.setAngle(
                ((cameraTransform.ry.getAngle() + mouseDeltaX * modifierFactor * modifier * 2.0)
                                % 360
                            + 540)
                        % 360
                    - 180); // +
            cameraTransform.rx.setAngle(
                ((cameraTransform.rx.getAngle() - mouseDeltaY * modifierFactor * modifier * 2.0)
                                % 360
                            + 540)
                        % 360
                    - 180); // -
          } else if (me.isSecondaryButtonDown()) {
            double z = camera.getTranslateZ();
            double newZ = z + mouseDeltaX * modifierFactor * modifier;
            camera.setTranslateZ(newZ);
          } else if (me.isMiddleButtonDown()) {
            cameraTransform.t.setX(
                cameraTransform.t.getX() + mouseDeltaX * modifierFactor * modifier * 0.3); // -
            cameraTransform.t.setY(
                cameraTransform.t.getY() + mouseDeltaY * modifierFactor * modifier * 0.3); // -
          }
        });

    primaryStage.setTitle("F(X)yz - ScatterMesh Test");
    primaryStage.setScene(scene);
    primaryStage.show();

    final boolean constantVertices = true;
    lastEffect = System.nanoTime();
    AtomicInteger count = new AtomicInteger(0);

    List<List<Number>> fullData = new ArrayList<>();

    if (constantVertices) {
      // if possible we can cache all the data
      Stream.of(0, 1, 2, 3, 4, 3, 2, 1)
          .forEach(
              i -> {
                Path out2 = getCSVFile(i);
                if (out2 != null) {
                  try {
                    List<Number> data2 = new ArrayList<>();
                    Files.lines(out2)
                        .map(s -> s.split(";"))
                        .forEach(
                            s -> {
                              float f = Float.parseFloat(s[3]);
                              // 4 vertices tetrahedra
                              data2.add(f);
                              data2.add(f);
                              data2.add(f);
                              data2.add(f);
                            });
                    fullData.add(data2);
                  } catch (IOException ex) {
                  }
                }
              });
    }

    AnimationTimer timerEffect =
        new AnimationTimer() {

          @Override
          public void handle(long now) {
            if (now > lastEffect + 50_000_000l) {
              try {
                //                        long t=System.currentTimeMillis();
                if (constantVertices && fullData != null) {
                  // Vertices coordinates are always the same: mesh is tha same, we only
                  // need to update F on each element
                  scatter.setFunctionData(fullData.get(count.get() % 8));
                  //                            System.out.println("t
                  // "+(System.currentTimeMillis()-t));
                } else {
                  // vertices coordinates may change in time, we need to create them all over again
                  // reading the files:
                  Path out2 =
                      getCSVFile(
                          (int) (Stream.of(0, 1, 2, 3, 4, 3, 2, 1).toArray()[count.get() % 8]));
                  if (out2 != null) {
                    List<Point3D> data2 = new ArrayList<>();
                    Files.lines(out2)
                        .map(s -> s.split(";"))
                        .forEach(
                            s ->
                                data2.add(
                                    new Point3D(
                                        Float.parseFloat(s[0]),
                                        Float.parseFloat(s[1]),
                                        Float.parseFloat(s[2]),
                                        Float.parseFloat(s[3]))));
                    scatter.setScatterData(data2);
                    scatter.setTextureModeVertices1D(1530, p -> p);
                  }
                  //                            System.out.println("t
                  // "+(System.currentTimeMillis()-t));
                }
              } catch (IOException ex) {
              }

              count.getAndIncrement();
              lastEffect = now;
            }
          }
        };
    timerEffect.start();
  }
  @Override
  public void start(Stage stage) {
    stage.setTitle("TitledPane");

    // --- Simple grid test
    TitledPane gridTitlePane = new TitledPane();
    GridPane grid = new GridPane();
    grid.setVgap(4);
    grid.setPadding(new Insets(5, 5, 5, 5));
    grid.add(new Label("First Name: "), 0, 0);
    grid.add(new TextField(), 1, 0);
    grid.add(new Label("Last Name: "), 0, 1);
    grid.add(new TextField(), 1, 1);
    grid.add(new Label("Email: "), 0, 2);
    grid.add(new TextField(), 1, 2);
    gridTitlePane.setText("Hello World!");
    gridTitlePane.setContent(grid);

    // --- Label test
    TitledPane normalText = new TitledPane();
    Label lbl =
        new Label(
            "This is a collapsible TitledPane\nthat allows for text to be wrapped.\n\nIt should be the perfect height to fit all text provided.\n\nIs it?");
    normalText.setText("Hello World!");
    normalText.setFont(Font.font(20));
    normalText.setContent(lbl);

    // --- Big button test
    TitledPane normal = new TitledPane();
    Button bn = new Button("Button");
    bn.setPrefSize(75, 50);
    StackPane pane = new StackPane(bn);
    pane.setPadding(new Insets(5));
    normal.setText("Hello World!");
    normal.setFont(Font.font(5));
    normal.setContent(pane);

    TitledPane unanimated = new TitledPane();
    unanimated.setAnimated(false);
    unanimated.setText("Not Animated");
    Button bs = new Button("Button");
    bs.setPrefSize(75, 50);
    unanimated.setContent(bs);

    TitledPane uncollapsible = new TitledPane();
    uncollapsible.setCollapsible(false);
    uncollapsible.setText("Not Collapsible");
    Button bf = new Button("Button");
    bf.setPrefSize(75, 50);
    uncollapsible.setContent(bf);

    // -- Content is a ScrollPane
    Image image = new Image("hello/duke.jpg", 200f, 200f, true, true, false);
    ImageView imageView = new ImageView();
    imageView.setImage(image);

    ScrollPane scrollPane = new ScrollPane(imageView);
    scrollPane.setPannable(true);

    TitledPane scrollableImage = new TitledPane();
    scrollableImage.setPrefHeight(100);
    scrollableImage.setText("ScrollPane content");
    scrollableImage.setContent(scrollPane);

    VBox hbox = new VBox(10);
    hbox.setPadding(new Insets(20, 0, 0, 20));
    hbox.getChildren()
        .setAll(normal, gridTitlePane, normalText, unanimated, uncollapsible, scrollableImage);

    Scene scene = new Scene(hbox);
    scene.setFill(Color.GHOSTWHITE);
    stage.setScene(scene);
    stage.show();
  }
  @Override
  public void start(Stage stage) {
    // stage.initStyle(StageStyle.UNDECORATED);
    stage.setTitle("Hello Image Clipboard");
    Scene scene = new Scene(new Group(), 1024, 768);
    scene.setFill(Color.LIGHTGREEN);

    Rectangle overlay = new Rectangle();
    overlay.setWidth(800);
    overlay.setHeight(600);
    overlay.setFill(Color.TRANSPARENT);
    EventHandler<DragEvent> drop = de -> checkBoard(de.getDragboard(), de);

    EventHandler<DragEvent> enter =
        de -> {
          if (de != null && de.getDragboard() != null && de.getDragboard().hasImage()) {
            de.acceptTransferModes(TransferMode.ANY);
          }
        };

    EventHandler<DragEvent> dragged =
        de -> {
          if (de != null && de.getDragboard() != null && de.getDragboard().hasImage()) {
            de.acceptTransferModes(TransferMode.ANY);
          }
        };

    overlay.setOnDragDropped(drop);
    overlay.setOnDragEntered(enter);
    overlay.setOnDragOver(dragged);

    clearBtn = new Button("Clear");
    clearBtn.setTranslateX(50);
    clearBtn.setTranslateY(30);

    copyBtn = new Button("Copy");
    copyBtn.setTranslateX(125);
    copyBtn.setTranslateY(30);

    pasteBtn = new Button("Paste");
    pasteBtn.setTranslateX(200);
    pasteBtn.setTranslateY(30);

    clearBtn.setOnAction(e -> clear());
    copyBtn.setOnAction(
        e -> {
          ClipboardContent content = new ClipboardContent();
          content.putImage(imageView.getImage());
          Clipboard.getSystemClipboard().setContent(content);
        });
    pasteBtn.setOnAction(e -> checkBoard(Clipboard.getSystemClipboard(), null));

    Group root = (Group) scene.getRoot();
    root.getChildren().add(overlay);
    root.getChildren().add(imageView);
    root.getChildren().add(clearBtn);
    root.getChildren().add(copyBtn);
    root.getChildren().add(pasteBtn);

    stage.setScene(scene);
    stage.show();
  }