Mercurial > jdk8-mips64-public > nashorn / file revision

 /*

  * Copyright (c) 2013, Oracle and/or its affiliates. All rights reserved.

  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

  * 

  * This code is free software; you can redistribute it and/or modify it

  * under the terms of the GNU General Public License version 2 only, as

  * published by the Free Software Foundation.

  * 

  * This code is distributed in the hope that it will be useful, but WITHOUT

  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

  * version 2 for more details (a copy is included in the LICENSE file that

  * accompanied this code).

  * 

  * You should have received a copy of the GNU General Public License version

  * 2 along with this work; if not, write to the Free Software Foundation,

  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

  * 

  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

  * or visit www.oracle.com if you need additional information or have any

  * questions.

  */

 /**

  * Testing JavaFX canvas run by Nashorn.

  *

  * @test/nocompare

  * @run

  * @fork

  */

 TESTNAME = "spread";

 var WIDTH = 800;

 var HEIGHT = 600;

 var canvas = new Canvas(WIDTH, HEIGHT);

 var context = canvas.graphicsContext2D;

 /* "Spread" tech demo of canvas by Tom Theisen

  *

  * This will animate a sequence of branch structures in a canvas element.

  * Each frame, a new direction is calculated, similar to the last frame.

  */

 var start_width = 20;           // starting width of each branch

 var frame_time = 30;            // milliseconds per frame

 var straighten_factor = 0.95;   // value from 0 to 1, factor applied to direction_offset every frame

 var curviness = 0.2;            // amount of random direction change each frame

 var color_speed = 0.03;     // speed at which colors change when cycling is enabled

 var branch_shrink = 0.95;   // factor by which branches shrink every frame

 var min_width = 1;          // minimum WIDTH for branch, after which they are discontinued

 var branch_opacity = 0.4;   // opacity of lines drawn

 var branch_count = 3;       // branch count per tree

 var branch_bud_size = 0.5;  // ratio of original branch size at which branch will split

 var branch_bud_angle = 1;   // angle offset for split branch;

 var paper;                  // reference to graphics context

 var branches = Object();    // linked list of active branches

 var color_styles = [];      // pre-computed list of colors as styles. format: (r,g,b,a)    

 var direction_offset = 0;   // current direction offset in radians.  this is applied to all branches.

 var frame = 0;              // frame counter

 var timespent = 0;          // total time spent so far, used to calculate average frame render duration

 var frameratespan;          // html span element for updating performance number

 // preferences object, contains an attribute for each user setting

 var prefs = {

     wrap: true,             // causes branches reaching edge of viewable area to appear on opposite side

     fade: false,             // fade existing graphics on each frame

     cycle: true,            // gradually change colors each frame

     new_branch_frames: 20    // number of frames elapsed between each auto-generated tree

 };

 // create tree at the specified position with number of branches

 function create_tree(branches, start_width, position, branch_count) {

     var angle_offset = Math.PI * 2 / branch_count;

     for (var i = 0; i < branch_count; ++i) {

         branch_add(branches, new Branch(position, angle_offset * i, start_width));

     }

 }

 // add branch to collection

 function branch_add(branches, branch) {

     branch.next = branches.next;

     branches.next = branch;

 }

 // get the coordinates for the position of a new tree

 // use the center of the canvas

 function get_new_tree_center(width, height) {

     return {

         x: 0.5 * width, 

         y: 0.5 * height 

     };

 }

 // Branch constructor

 // position has x and y properties

 // direction is in radians

 function Branch(position, direction, width) {

     this.x = position.x;

     this.y = position.y;

     this.width = width;

     this.original_width = width;

     this.direction = direction;

 }

 // update position, direction and width of a particular branch

 function branch_update(branches, branch, paper) {

     paper.beginPath();

     paper.lineWidth = branch.width;

     paper.moveTo(branch.x, branch.y);

     branch.width *= branch_shrink;

     branch.direction += direction_offset;

     branch.x += Math.cos(branch.direction) * branch.width;

     branch.y += Math.sin(branch.direction) * branch.width;

     paper.lineTo(branch.x, branch.y);

     paper.stroke();

     if (prefs.wrap) wrap_branch(branch, WIDTH, HEIGHT);

     if (branch.width < branch.original_width * branch_bud_size) {

         branch.original_width *= branch_bud_size;

         branch_add(branches, new Branch(branch, branch.direction + 1, branch.original_width));

     }

 }

 function draw_frame() {

     if (prefs.fade) {

         paper.fillRect(0, 0, WIDTH, HEIGHT);

     }

     if (prefs.cycle) {

         paper.setStroke(Paint.valueOf(color_styles[frame % color_styles.length]));

     }

     if (frame++ % prefs.new_branch_frames == 0) {

         create_tree(branches, start_width, get_new_tree_center(WIDTH, HEIGHT), branch_count);

     }

     direction_offset += (0.35 + (frame % 200) * 0.0015) * curviness - curviness / 2;

     direction_offset *= straighten_factor;

     var branch = branches;

     var prev_branch = branches;

     while (branch = branch.next) {

         branch_update(branches, branch, paper);

         if (branch.width < min_width) {

             // remove branch from list

             prev_branch.next = branch.next;

         }

         prev_branch = branch;

     }

 }

 // constrain branch position to visible area by "wrapping" from edge to edge

 function wrap_branch(branch, WIDTH, HEIGHT) {

     branch.x = positive_mod(branch.x, WIDTH);

     branch.y = positive_mod(branch.y, HEIGHT);

 }

 // for a < 0, b > 0, javascript returns a negative number for a % b

 // this is a variant of the % operator that adds b to the result in this case

 function positive_mod(a, b) {

     // ECMA 262 11.5.3: Applying the % Operator 

     // remainder operator does not convert operands to integers,

     // although negative results are possible

     return ((a % b) + b) % b;

 }

 // pre-compute color styles that will be used for color cycling

 function populate_colors(color_speed, color_styles, branch_opacity) {

     // used in calculation of RGB values

     var two_thirds_pi = Math.PI * 2 / 3;

     var four_thirds_pi = Math.PI * 4 / 3;

     var two_pi = Math.PI * 2;

     // hue does represent hue, but not in the conventional HSL scheme

     for(var hue = 0; hue < two_pi; hue += color_speed) {

         var r = Math.floor(Math.sin(hue) * 128 + 128);

         var g = Math.floor(Math.sin(hue + two_thirds_pi) * 128 + 128);

         var b = Math.floor(Math.sin(hue + four_thirds_pi) * 128 + 128);

         color = "rgba(" + [r, g, b, branch_opacity].join() + ")";

         color_styles.push(color);

     }

 }

 // apply initial settings to canvas object

 function setup_canvas() {

     paper = canvas.graphicsContext2D;

     paper.setFill(Paint.valueOf('rgb(0, 0, 0)'));

     paper.fillRect(0, 0, WIDTH, HEIGHT);

     paper.setFill(Paint.valueOf("rgba(0, 0, 0, 0.005)"));

     paper.setStroke(Paint.valueOf("rgba(128, 128, 64, " + String(branch_opacity) + ")"));

 }

 populate_colors(color_speed, color_styles, branch_opacity);

 setup_canvas();

 var stack = new StackPane();

 var pane = new BorderPane();

 pane.setCenter(canvas);

 stack.getChildren().add(pane);

 $STAGE.scene = new Scene(stack);

 var timer = new AnimationTimerExtend() {

     handle: function handle(now) {

         if (frame < 200) {

             draw_frame();

         } else {

             checkImageAndExit();

             timer.stop();

         }

     }

 };

 timer.start();