-
-
Save Birdasaur/bf8ad77d052f42aaf943933fdaf1496e to your computer and use it in GitHub Desktop.
package edu.jhuapl.trinity.javafx; | |
import java.util.ArrayList; | |
import java.util.List; | |
import javafx.application.Application; | |
import javafx.geometry.Insets; | |
import javafx.geometry.Point3D; | |
import javafx.scene.Group; | |
import javafx.scene.PerspectiveCamera; | |
import javafx.scene.Scene; | |
import javafx.scene.SceneAntialiasing; | |
import javafx.scene.SpotLight; | |
import javafx.scene.SubScene; | |
import javafx.scene.input.MouseEvent; | |
import javafx.scene.input.ScrollEvent; | |
import javafx.scene.layout.Background; | |
import javafx.scene.layout.BackgroundFill; | |
import javafx.scene.layout.BorderPane; | |
import javafx.scene.layout.CornerRadii; | |
import javafx.scene.layout.StackPane; | |
import javafx.scene.paint.Color; | |
import javafx.scene.paint.PhongMaterial; | |
import javafx.scene.shape.Box; | |
import javafx.scene.shape.CullFace; | |
import javafx.scene.shape.DrawMode; | |
import javafx.stage.Stage; | |
import org.fxyz3d.geometry.MathUtils; | |
import org.fxyz3d.utils.CameraTransformer; | |
public class SpotLightTest extends Application { | |
protected Box box; | |
PerspectiveCamera camera = new PerspectiveCamera(true); | |
public Group sceneRoot = new Group(); | |
public SubScene subScene; | |
public CameraTransformer cameraTransform = new CameraTransformer(); | |
private double cameraDistance = -4000; | |
private final double sceneWidth = 10000; | |
private final double sceneHeight = 4000; | |
private double mousePosX; | |
private double mousePosY; | |
private double mouseOldX; | |
private double mouseOldY; | |
private double mouseDeltaX; | |
private double mouseDeltaY; | |
@Override | |
public void start(Stage primaryStage) throws Exception { | |
subScene = new SubScene(sceneRoot, sceneWidth, sceneHeight, true, SceneAntialiasing.BALANCED); | |
//Start Tracking mouse movements only when a button is pressed | |
subScene.setOnMouseDragged((MouseEvent me) -> mouseDragCamera(me)); | |
subScene.setOnScroll((ScrollEvent event) -> { | |
double modifier = 50.0; | |
double modifierFactor = 0.1; | |
if (event.isControlDown()) { | |
modifier = 1; | |
} | |
if (event.isShiftDown()) { | |
modifier = 100.0; | |
} | |
double z = camera.getTranslateZ(); | |
double newZ = z + event.getDeltaY() * modifierFactor * modifier; | |
camera.setTranslateZ(newZ); | |
}); | |
StackPane stackPane = new StackPane(subScene); | |
subScene.widthProperty().bind(stackPane.widthProperty()); | |
subScene.heightProperty().bind(stackPane.heightProperty()); | |
subScene.setFill(Color.LIGHTGREY); | |
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(100000.0); | |
camera.setTranslateZ(cameraDistance); | |
cameraTransform.ry.setAngle(-45.0); | |
cameraTransform.rx.setAngle(-10.0); | |
subScene.setCamera(camera); | |
//create multiple spot lights | |
List<SpotLight> lights = new ArrayList<>(); | |
lights.add(new SpotLight(Color.WHITE)); | |
lights.add(new SpotLight(Color.GREEN)); | |
lights.add(new SpotLight(Color.RED)); | |
for(int i=0; i< lights.size(); i++) { | |
SpotLight spotLight = lights.get(i); | |
spotLight.setDirection(new Point3D(0, 1, 0)); | |
spotLight.setInnerAngle(120); | |
spotLight.setOuterAngle(30); | |
spotLight.setFalloff(-0.4); | |
spotLight.setTranslateZ(2000 * i); | |
spotLight.setTranslateY(-200); | |
} | |
box = new Box(sceneWidth, 50, sceneWidth); | |
box.setDrawMode(DrawMode.FILL); | |
box.setCullFace(CullFace.BACK); | |
box.setMaterial(new PhongMaterial(Color.CYAN)); | |
sceneRoot.getChildren().addAll(cameraTransform, box); | |
sceneRoot.getChildren().addAll(lights); | |
BorderPane bpOilSpill = new BorderPane(subScene); | |
stackPane.getChildren().clear(); | |
stackPane.getChildren().addAll(bpOilSpill); | |
stackPane.setPadding(new Insets(10)); | |
stackPane.setBackground(new Background(new BackgroundFill(Color.rgb(255, 255, 255), CornerRadii.EMPTY, Insets.EMPTY))); | |
Scene scene = new Scene(stackPane, 1000, 1000); | |
scene.setOnMouseEntered(event -> subScene.requestFocus()); | |
primaryStage.setTitle("Multiple SpotLight Test"); | |
primaryStage.setScene(scene); | |
primaryStage.show(); | |
} | |
private void mouseDragCamera(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 = 1; | |
} | |
if (me.isShiftDown()) { | |
modifier = 50.0; | |
} | |
if (me.isPrimaryButtonDown()) { | |
if(me.isAltDown()) { //roll | |
cameraTransform.rz.setAngle(((cameraTransform.rz.getAngle() + mouseDeltaX * modifierFactor * modifier * 2.0) % 360 + 540) % 360 - 180); // + | |
} else { | |
cameraTransform.ry.setAngle(((cameraTransform.ry.getAngle() + mouseDeltaX * modifierFactor * modifier * 2.0) % 360 + 540) % 360 - 180); // + | |
cameraTransform.rx.setAngle( | |
MathUtils.clamp(-60, | |
(((cameraTransform.rx.getAngle() - mouseDeltaY * modifierFactor * modifier * 2.0) % 360 + 540) % 360 - 180), | |
60)); // - | |
} | |
} 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); // - | |
} | |
} | |
public static void main(String[] args){launch(args);} | |
} |
There is already a lighting test sample similar to yours, only more comprehensive, in the JavaFX codebase: https://github.com/openjdk/jfx/tree/master/tests/performance/3DLighting/attenuation. I suggest you give it a try.
JavaFX currently limits to 3 lights per mesh (not including AmbientLight
s, which are free, so 3 total from PointLight
s, SpotLight
s and DirectionalLight
s). There is no limitation per scene. The limitation is for both the D3D and OpenGL pipelines. I'm working on removing this limitation under JDK-8091256, which is blocked by openjdk/jfx#789, which is under review. Removing this limitation will incur a performance cost depending on the approach we take with varying shaders.
Adding a 4th light will be ignored, only the first 3 are taken into account. You can remove and re-add a light to change their order. If you have the default camera light then you can use only 2 spot lights in addition.
There shouldn't be a difference between 18 and 19, I don't remember that anything changed in that area of the code.
By the way, here are 3 SpotLight
s together: openjdk/jfx#334 (comment)
I took a quick look at the code
spotLight.setInnerAngle(120);
spotLight.setOuterAngle(30);
spotLight.setFalloff(-0.4);
This is all "illegal". As per the docs, the inner angle needs to be smaller than the outer angle, and the falloff needs to be >=0. You can use illegal values like these to achieve all sorts of effects, like a ring light, shadow caster, and so on, but you need to know what you're doing.
Actually those values are exactly what I wanted to create a focused spot beam on a 3D object. If the outer angle is less than the inner angle that requires the falloff to be negative to get the focused circle effect I was looking for.
Doing it the way the docs says creates too much attenuation and not enough... "light density"? not sure what the correct term is here.
If there is a more proper way to get the effect that I want shown here then I'm open to suggestions:
like a ring light,
Now that would be interesting... creating a ring of light. I could totally use that as a special effect
Not sure what you mean by "too much attenuation". You can control the attenuation directly with the attenuation parameters. If you want a more focused beam then make the inner and outer angle close and the falloff small.
As you can see I built a bunch of controls to play with the parameters... but I must not have tried that combination. I'll try it and report back!
Yes I see how the parameters work. I was also able to create a "shadow cast" effect which was super cool. I can smell a fun game mechanic in that somehow. Wasn't able to create a perfect ring of light... although I suppose you could just create a literal eclipse with another 3D object in front of the object yes?
There are no shadows, so a 3D object will not block the light and cast a shadow.
If you want a ring of light set the outer angle to be larger than the inner angle (with a positive falloff):
You can also use 2 spot lights where one is smaller and has a negative attenuation so that it subtracts light from the second one:
This is pretty cool dude
So have all issues been resolved?
well actually I never did manage to get the third light to show up but Jose was able to by changing the material colors. (must be due to underlying calculations that certain color combinations are diminished at the third light? You did say that order matters .
regardless please don't think I still have an issue. Your contribution to Javafx 3D is great!!
I would LOVE to have more lights but I understand that for now I will have 3 to work with.
If you're using a CYAN (00FFFF) material color and a RED (FF0000) light you will not see the light because the contribution from these is 0. This is explained in the PhongMaterial
docs.
Gotcha. So practically speaking its a sort of AND operation. This makes sense. Thanks!
Last question... is there some way/method for knowing how much total light contribution is being applied to a given node programmatically?
I can think of some cool game ideas if you could programmatically determine the amount of light contribution (even better if its known by RGB channel) on a node.
The amount of light is per pixel, not per node. There is no way to determine it per pixel programatically, otherwise no one would need shaders. At best you can take a snapshot and sample that specific pixel for its RGB. Remember that it depends also on the location of the camera because of the way the light reflects. If you want some sort of approximation per node then use the formula in PhongMaterial
.
If you want some sort of approximation per node then use the formula in
PhongMaterial
.
Oh good idea. An approximation would be fine. I suddenly have an idea for a game mechanic where you must use spot lights to shine light on "adversaries" or other targets. Each target would require different amounts of light/color to be "defeated".
By using the lighting I can play games with visibility... certain nodes would be difficult to see in bright lights so you may have to invert the light to be a shadow cast.
I can see a flat plane with 3D shapes moving around on the plane either towards you or towards a goal and you are using light/shadow to manipulate the playing field.
oooo different colors could put spin and velocity effects on the 3D shapes. Oh this could be really cool.
It works the same with 18.0.1
It seems that adding a fourth spotlight doesn't work.