Creating Groups of specific types - javafx

Question

I've created a simple 3D viewer using a SubScene and adding 3D objects to a top level root item.
public class Viewer extends AnchorPane {
private final PerspectiveCamera camera = new PerspectiveCamera(true);
private final Group root = new Group(camera)
public Viewer() {
SubScene scene = new SubScene(root, 300, 300, true, SceneAntialiasing.BALANCED);
}
public Group getRoot() {
return root;
}
Calling code that users the Viewer can then get the root, create 3D objects and add them to the root. This works nicely.
However, I realised I need to logically separate out the root into three separate areas due to requirements. The root turned into:
private final Group cameraGroup = new Group(camera);
private final Group lightGroup = new Group();
private final Group objectsGroup = new Group();
private final Group root = new Group(cameraGroup, lightGroup, objectsGroup);
Calling code can add multiple cameras, lights, 3D objects via getters for the above groups.
Question:
If I provide calling code with getters to each group, then calling code also needs to constantly cast the Nodes in the group to the given types (e.g. Cameras in cameraGroup). Calling code could also add non-camera types to the Group, as a lot of things in JavaFX inherit from the common Node base type and that's what Group works with.
Providing individual getters, setters, removers etc that cast groups to lists/observablelists of each type complicates the interface.
Is there a way to have a Group? i.e. a Group of a specific type? Or is there a different way to go about my design?

Answer 1

Group is not generic, so there is no direct way to do what you want.
However, you could keep separate ObservableLists and expose them (instead of the Groups), and register listeners with them to keep the groups' child node lists in sync:
public class Viewer {
private final PerspectiveCamera camera = new PerspectiveCamera();
private final ObservableList<Camera> cameras = FXCollections.observableArrayList();
private final Group cameraGroup = new Group();
// etc
public Viewer() {
cameras.addListener((Change<? extends Camera> c) -> {
while (c.next()) {
if (c.wasAdded()) {
cameraGroup.getChildren().addAll(c.getAddedSubList());
}
if (c.wasRemoved()) {
cameraGroup.getChildren().removeAll(c.getRemoved());
}
}
});
cameras.add(camera);
// etc
}
public ObservableList<Camera> getCameras() {
return cameras ;
}
}
An alternative solution (basically the one you describe) is to define specific addCamera() and removeCamera() , etc, methods, and only expose unmodifiable lists:
public class Viewer {
public final PerspectiveCamera camera = new PerspectiveCamera();
public final Group cameraGroup = new Group(camera);
public final void addCamera(Camera camera) {
cameraGroup.getChildren().add(camera);
}
public boolean removeCamera(Camera camera) {
return cameraGroup.getChildren().remove(camera);
}
public List<Camera> getCameras() {
List<Camera> cameras = new ArrayList<>();
for (Node n : cameraGroup.getChildren()) {
cameras.add((Camera)n);
}
return Collections.unmodifiableList(cameras);
}
// etc...
}