Mixing 2D and 3D

[Chien Yang]

Hi August,

    John Yoon, Richard and I have a private discussion on the 
possibility of avoiding "cloning" for your use case. We wonder do you 
ever need to interact with the 3D scene via the various sub views? Or 
these sub views are purely for viewing the 3d scene with different 
cameras? If  this is your use case scenario, have you thought of using 
Node.snapshot()?

     public WritableImage snapshot(SnapshotParameters params, 
WritableImage image) {

Where you can call snapshot on the node with a specified camera (in the 
snapshot params).  It will then render the node from that camera's 
viewpoint and put the result in an WritableImage. You can then add it 
into the scenegraph using an ImageView.  I have attached a very simple 
example on how snapshot can be used with an ancillary camera. Please let 
us know of your progress in this work. We would hope to learn from this 
work so that we can evaluate it to see if there are any performance / 
semantic problems. You will likely ended up with a one frame behind 
rendering in those sub views, but do let us know for your finding.

Thanks,
- Chien



On 7/26/2013 10:53 AM, Chien Yang wrote:
> Yes, that is still the approach. The challenge isn't just strictly on 
> rendering. Let's take picking a "shared" node as an example. Imagine 
> this node is in a scenegraph viewed by more than 1 camera. The 
> question is where do we hang the set picked information. There is some 
> level of "cloning" needed within JavaFX if we want to free application 
> developer from doing it.
>
> - Chien
>
> On 7/25/2013 7:31 PM, Richard Bair wrote:
>> I thought the approach was not to have multiple parents, but to 
>> render into an image.
>>
>> On Jul 25, 2013, at 5:26 PM, Chien Yang<chien.yang at oracle.com>  wrote:
>>
>>> We don't support sharable Node. Some one will have to do the cloning 
>>> of the scenegraph, either the application or JavaFX. Now I may have 
>>> opened a can of worms. ;-)
>>>
>>> - Chien
>>>
>>> On 7/25/2013 5:20 PM, Richard Bair wrote:
>>>> Having to clone the nodes hardly seems like simultaneous viewing 
>>>> from different points of view?
>>>>
>>>> On Jul 25, 2013, at 5:17 PM, Chien Yang<chien.yang at oracle.com>  wrote:
>>>>
>>>>> Hi August,
>>>>>
>>>>>       We did talk through some use cases such as PIP and rear view 
>>>>> mirror. You can do simultaneous viewing from different points of 
>>>>> view into a single 3D scene via the use of SubScenes. The key 
>>>>> point, as you have clearly stated, is the need to clone the scene 
>>>>> graph nodes per SubScene.
>>>>>
>>>>> - Chien
>>>>>
>>>>> On 7/25/2013 10:37 AM, Richard Bair wrote:
>>>>>> Hi August,
>>>>>>
>>>>>>>> "I think we already do multiple active cameras?"
>>>>>>>>
>>>>>>>> More precisely: simultaneous viewing from different points of 
>>>>>>>> view into a single 3D scene graph was meant, i.e. several 
>>>>>>>> cameras are attached to one scene graph.
>>>>>>>> A SubScene has exactly one camera attached which renders the 
>>>>>>>> associated scene graph into the corresponding SubScene's 
>>>>>>>> rectangle. Implementing simultaneous viewing requires a cloned 
>>>>>>>> 3D scene graph for the second, third, and so on 
>>>>>>>> SubScene/Camera. Material, Mesh, and Image objects can be 
>>>>>>>> re-used because they are shareable. Animations of Nodes' 
>>>>>>>> Transforms seem to be shareable as well. But Transitions 
>>>>>>>> (Rotate, Scale, Translate) have to be cloned because they 
>>>>>>>> operate on a Node's methods directly. So, simultaneous viewing 
>>>>>>>> seems practicable.
>>>>>> Jasper or Kevin will have to comment, but I know this scenario 
>>>>>> was talked about extensively in the design for the renderToImage 
>>>>>> and cameras, and I thought this was possible today.
>>>>>>
>

-------------- next part --------------
/*
 * Copyright (c) 2013, Oracle and/or its affiliates. All rights reserved.
 */
package helloworld;

import javafx.application.Application;
import javafx.geometry.Rectangle2D;
import javafx.scene.Group;
import javafx.scene.PerspectiveCamera;
import javafx.scene.Scene;
import javafx.scene.SnapshotParameters;
import javafx.scene.image.Image;
import javafx.scene.image.ImageView;
import javafx.scene.paint.Color;
import javafx.scene.shape.Rectangle;
import javafx.scene.transform.Rotate;
import javafx.stage.Stage;

public class HelloSnapshotPerspective extends Application {

    @Override
    public void start(Stage stage) {
        stage.setTitle("HelloSnapshotPerspective");

        Group g = new Group();
        Rectangle rect = new Rectangle(300, 200);
        rect.setTranslateX(25);
        rect.setTranslateY(25);
        rect.setRotate(-40);
        rect.setRotationAxis(Rotate.Y_AXIS);
        rect.setFill(Color.PALEGREEN);
        g.getChildren().add(rect);
        final Group root = new Group(g);

        Scene scene = new Scene(root, 800, 300);
        scene.setCamera(new PerspectiveCamera());
        scene.setFill(Color.BROWN);

        SnapshotParameters params = new SnapshotParameters();
        params.setCamera(new PerspectiveCamera());
        params.setFill(Color.DARKBLUE);
        params.setViewport(new Rectangle2D(0, 0, 800, 300));

        final Image image = rect.snapshot(params, null);
        ImageView iv = new ImageView(image);
        iv.setLayoutX(400);
        root.getChildren().add(iv);

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

    }

    public static void main(String[] args) {
        javafx.application.Application.launch(args);
    }

}