8234920: Add SpotLight to the selection of 3D light types

Reviewed-by: kcr, arapte

Author: nlisker

modules/javafx.graphics/src/main/docs/javafx/scene/doc-files/spotlight.png

@@ -0,0 +1,77 @@
+/*
+ * Copyright (c) 2020, 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.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * 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.
+ */
+
+package com.sun.javafx.scene;
+
+import com.sun.javafx.sg.prism.NGNode;
+import com.sun.javafx.util.Utils;
+import javafx.scene.SpotLight;
+import javafx.scene.Node;
+
+/**
+ * Used to access internal methods of SpotLight.
+ */
+public class SpotLightHelper extends PointLightHelper {
+
+    private static final SpotLightHelper theInstance;
+    private static SpotLightAccessor spotLightAccessor;
+
+    static {
+        theInstance = new SpotLightHelper();
+        Utils.forceInit(SpotLight.class);
+    }
+
+    private static SpotLightHelper getInstance() {
+        return theInstance;
+    }
+
+    public static void initHelper(SpotLight spotLight) {
+        setHelper(spotLight, getInstance());
+    }
+
+    @Override
+    protected NGNode createPeerImpl(Node node) {
+        return spotLightAccessor.doCreatePeer(node);
+    }
+
+    @Override
+    protected void updatePeerImpl(Node node) {
+        super.updatePeerImpl(node);
+        spotLightAccessor.doUpdatePeer(node);
+    }
+
+    public static void setSpotLightAccessor(final SpotLightAccessor newAccessor) {
+        if (spotLightAccessor != null) {
+            throw new IllegalStateException("Accessor already exists");
+        }
+
+        spotLightAccessor = newAccessor;
+    }
+
+    public interface SpotLightAccessor {
+        NGNode doCreatePeer(Node node);
+        void doUpdatePeer(Node node);
+    }
+}

modules/javafx.graphics/src/main/java/com/sun/javafx/scene/SpotLightHelper.java

@@ -25,6 +25,8 @@
 
 package com.sun.javafx.sg.prism;
 
+import javafx.geometry.Point3D;
+
 /**
  * The peer of the {@code PointLight} class. Holds the default values of {@code PointLight}'s
  * properties and updates the visuals via {@link NGNode#visualsChanged} when one of the current
@@ -41,6 +43,18 @@ public class NGPointLight extends NGLightBase {
     /** Max range default value */
     private static final float DEFAULT_MAX_RANGE = Float.POSITIVE_INFINITY;
 
+    /**
+     * The direction of a {@code SpotLight} that simulates a {@code PointLight}.
+     * Since the light radiates equally in all directions, this value is meaningless.
+     **/
+    private static final Point3D SIMULATED_DIRECTION = new Point3D(0, 0, 1);
+    /** The inner angle value of a {@code SpotLight} that simulates a {@code PointLight} */
+    private static final float SIMULATED_INNER_ANGLE = 0;
+    /** The outer angle value of a {@code SpotLight} that simulates a {@code PointLight} */
+    private static final float SIMULATED_OUTER_ANGLE = 180;
+    /** The falloff value of a {@code SpotLight} that simulates a {@code PointLight} */
+    private static final float SIMULATED_FALLOFF = 0;
+
     public NGPointLight() {
     }
 
@@ -60,6 +74,38 @@ public static float getDefaultMaxRange() {
         return DEFAULT_MAX_RANGE;
     }
 
+    public static Point3D getSimulatedDirection() {
+        return SIMULATED_DIRECTION;
+    }
+
+    public static float getSimulatedInnerAngle() {
+        return SIMULATED_INNER_ANGLE;
+    }
+
+    public static float getSimulatedOuterAngle() {
+        return SIMULATED_OUTER_ANGLE;
+    }
+
+    public static float getSimulatedFalloff() {
+        return SIMULATED_FALLOFF;
+    }
+
+    public Point3D getDirection() {
+        return SIMULATED_DIRECTION;
+    }
+
+    public float getInnerAngle() {
+        return SIMULATED_INNER_ANGLE;
+    }
+
+    public float getOuterAngle() {
+        return SIMULATED_OUTER_ANGLE;
+    }
+
+    public float getFalloff() {
+        return SIMULATED_FALLOFF;
+    }
+
 
     private float ca = DEFAULT_CA;
 

modules/javafx.graphics/src/main/java/com/sun/javafx/sg/prism/NGPointLight.java

@@ -31,6 +31,7 @@
 import javafx.scene.shape.DrawMode;
 import com.sun.javafx.geom.Vec3d;
 import com.sun.javafx.geom.transform.Affine3D;
+import com.sun.javafx.util.Utils;
 import com.sun.prism.Graphics;
 import com.sun.prism.Material;
 import com.sun.prism.MeshView;
@@ -115,95 +116,109 @@ private void renderMeshView(Graphics g) {
         }
 
         // Setup lights
-        int pointLightIdx = 0;
+        int lightIndex = 0;
         if (g.getLights() == null || g.getLights()[0] == null) {
             // If no lights are in scene apply default light. Default light
             // is a single white point light at camera eye position.
             meshView.setAmbientLight(0.0f, 0.0f, 0.0f);
             Vec3d cameraPos = g.getCameraNoClone().getPositionInWorld(null);
-            meshView.setPointLight(pointLightIdx++,
-                                   (float)cameraPos.x,
-                                   (float)cameraPos.y,
-                                   (float)cameraPos.z,
-                                   1.0f, 1.0f, 1.0f, 1.0f,
-                                   NGPointLight.getDefaultCa(),
-                                   NGPointLight.getDefaultLa(),
-                                   NGPointLight.getDefaultQa(),
-                                   NGPointLight.getDefaultMaxRange());
+            meshView.setLight(lightIndex++,
+                    (float) cameraPos.x,
+                    (float) cameraPos.y,
+                    (float) cameraPos.z,
+                    1.0f, 1.0f, 1.0f, 1.0f,
+                    NGPointLight.getDefaultCa(),
+                    NGPointLight.getDefaultLa(),
+                    NGPointLight.getDefaultQa(),
+                    NGPointLight.getDefaultMaxRange(),
+                    (float) NGPointLight.getSimulatedDirection().getX(),
+                    (float) NGPointLight.getSimulatedDirection().getY(),
+                    (float) NGPointLight.getSimulatedDirection().getZ(),
+                    NGPointLight.getSimulatedInnerAngle(),
+                    NGPointLight.getSimulatedOuterAngle(),
+                    NGPointLight.getSimulatedFalloff());
         } else {
             float ambientRed = 0.0f;
             float ambientBlue = 0.0f;
             float ambientGreen = 0.0f;
 
-            for (int i = 0; i < g.getLights().length; i++) {
-                NGLightBase lightBase = g.getLights()[i];
+            for (NGLightBase lightBase : g.getLights()) {
                 if (lightBase == null) {
                     // The array of lights can have nulls
                     break;
-                } else if (lightBase.affects(this)) {
-                    float rL = lightBase.getColor().getRed();
-                    float gL = lightBase.getColor().getGreen();
-                    float bL = lightBase.getColor().getBlue();
-                    /* TODO: 3D
-                     * There is a limit on the number of point lights that can affect
-                     * a 3D shape. (Currently we simply select the first 3)
-                     * Thus it is important to select the most relevant lights.
-                     *
-                     * One such way would be to sort lights according to
-                     * intensity, which becomes especially relevant when lights
-                     * are attenuated. Only the most intense set of lights
-                     * would be set.
-                     * The approximate intesity a light will have on a given
-                     * shape, could be defined by:
-                     */
-//                    // Where d is distance from point light
-//                    float attenuationFactor = 1/(c + cL * d + cQ * d * d);
-//                    float intensity = rL * 0.299f + gL * 0.587f + bL * 0.114f;
-//                    intensity *= attenuationFactor;
-                    if (lightBase instanceof NGPointLight) {
-                        NGPointLight light = (NGPointLight)lightBase;
-                        if (rL != 0.0f || gL != 0.0f || bL != 0.0f) {
-                            Affine3D lightWT = light.getWorldTransform();
-                            meshView.setPointLight(pointLightIdx++,
-                                    (float)lightWT.getMxt(),
-                                    (float)lightWT.getMyt(),
-                                    (float)lightWT.getMzt(),
-                                    rL, gL, bL, 1.0f,
-                                    light.getCa(),
-                                    light.getLa(),
-                                    light.getQa(),
-                                    light.getMaxRange());
-                        }
-                    } else if (lightBase instanceof NGAmbientLight) {
-                        // Accumulate ambient lights
-                        ambientRed   += rL;
-                        ambientGreen += gL;
-                        ambientBlue  += bL;
-                    }
+                }
+                if (!lightBase.affects(this)) {
+                    continue;
+                }
+                // Transparent component is ignored
+                float rL = lightBase.getColor().getRed();
+                float gL = lightBase.getColor().getGreen();
+                float bL = lightBase.getColor().getBlue();
+                // Black color is ignored
+                if (rL == 0.0f && gL == 0.0f && bL == 0.0f) {
+                    continue;
+                }
+                /* TODO: 3D
+                 * There is a limit on the number of point lights that can affect
+                 * a 3D shape. (Currently we simply select the first 3)
+                 * Thus it is important to select the most relevant lights.
+                 *
+                 * One such way would be to sort lights according to
+                 * intensity, which becomes especially relevant when lights
+                 * are attenuated. Only the most intense set of lights
+                 * would be set.
+                 * The approximate intensity a light will have on a given
+                 * shape, could be defined by:
+                 *
+                 * Where d is distance from point light
+                 * float attenuationFactor = 1/(c + cL * d + cQ * d * d);
+                 * float intensity = rL * 0.299f + gL * 0.587f + bL * 0.114f;
+                 * intensity *= attenuationFactor;
+                */
+                if (lightBase instanceof NGPointLight) {
+                    var light = (NGPointLight) lightBase;
+                    Affine3D lightWT = light.getWorldTransform();
+                    meshView.setLight(lightIndex++,
+                            (float) lightWT.getMxt(),
+                            (float) lightWT.getMyt(),
+                            (float) lightWT.getMzt(),
+                            rL, gL, bL, 1.0f,
+                            light.getCa(),
+                            light.getLa(),
+                            light.getQa(),
+                            light.getMaxRange(),
+                            (float) light.getDirection().getX(),
+                            (float) light.getDirection().getY(),
+                            (float) light.getDirection().getZ(),
+                            light.getInnerAngle(),
+                            light.getOuterAngle(),
+                            light.getFalloff());
+                } else if (lightBase instanceof NGAmbientLight) {
+                    // Accumulate ambient lights
+                    ambientRed   += rL;
+                    ambientGreen += gL;
+                    ambientBlue  += bL;
                 }
             }
-            ambientRed = saturate(ambientRed);
-            ambientGreen = saturate(ambientGreen);
-            ambientBlue = saturate(ambientBlue);
+            ambientRed = Utils.clamp(0, ambientRed, 1);
+            ambientGreen = Utils.clamp(0, ambientGreen, 1);
+            ambientBlue = Utils.clamp(0, ambientBlue, 1);
             meshView.setAmbientLight(ambientRed, ambientGreen, ambientBlue);
         }
         // TODO: 3D Required for D3D implementation of lights, which is limited to 3
-        while (pointLightIdx < 3) {
-                // Reset any previously set lights
-                meshView.setPointLight(pointLightIdx++,
-                        0, 0, 0, // x y z
-                        0, 0, 0, 0, // r g b w
-                        1, 0, 0, 0); // ca la qa maxRange
+
+        while (lightIndex < 3) { // Reset any previously set lights
+            meshView.setLight(lightIndex++,
+                    0, 0, 0,    // x y z
+                    0, 0, 0, 0, // r g b w
+                    1, 0, 0, 0, // ca la qa maxRange
+                    0, 0, 0,    // dirX Y Z
+                    0, 0, 0);   // inner outer falloff
         }
 
         meshView.render(g);
     }
 
-    // Clamp between [0, 1]
-    private static float saturate(float value) {
-        return value < 1.0f ? ((value < 0.0f) ? 0.0f : value) : 1.0f;
-    }
-
     public void setMesh(NGTriangleMesh triangleMesh) {
         this.mesh = triangleMesh;
         meshView = null;

modules/javafx.graphics/src/main/java/com/sun/javafx/sg/prism/NGShape3D.java

@@ -0,0 +1,129 @@
+/*
+ * Copyright (c) 2020, 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.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * 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.
+ */
+
+package com.sun.javafx.sg.prism;
+
+import com.sun.javafx.geom.Vec3d;
+
+import javafx.geometry.Point3D;
+
+/**
+ * The peer of the {@code SpotLight} class. Holds the default values of {@code SpotLight}'s
+ * properties and updates the visuals via {@link NGNode#visualsChanged} when one of the current
+ * values changes. The peer receives its changes by {@link javafx.scene.SpotLight#doUpdatePeer} calls.
+ */
+public class NGSpotLight extends NGPointLight {
+
+    /** Direction default value */
+    private static final Point3D DEFAULT_DIRECTION = new Point3D(0, 0, 1);
+    /** Inner angle default value */
+    private static final float DEFAULT_INNER_ANGLE = 0;
+    /** Outer angle default value */
+    private static final float DEFAULT_OUTER_ANGLE = 30;
+    /** Falloff default value */
+    private static final float DEFAULT_FALLOFF = 1;
+
+    public NGSpotLight() {
+    }
+
+    public static Point3D getDefaultDirection() {
+        return DEFAULT_DIRECTION;
+    }
+
+    public static float getDefaultInnerAngle() {
+        return DEFAULT_INNER_ANGLE;
+    }
+
+    public static float getDefaultOuterAngle() {
+        return DEFAULT_OUTER_ANGLE;
+    }
+
+    public static float getDefaultFalloff() {
+        return DEFAULT_FALLOFF;
+    }
+
+
+    private Point3D direction = DEFAULT_DIRECTION;
+    private final Vec3d effectiveDir = new Vec3d();
+
+    @Override
+    public Point3D getDirection() {
+        var dir = new Vec3d(direction.getX(), direction.getY(), direction.getZ());
+        getWorldTransform().deltaTransform(dir, effectiveDir);
+        return new Point3D(effectiveDir.x, effectiveDir.y, effectiveDir.z);
+    }
+
+    public void setDirection(Point3D direction) {
+        if (!this.direction.equals(direction)) {
+            this.direction = direction;
+            visualsChanged();
+        }
+    }
+
+
+    private float innerAngle = DEFAULT_INNER_ANGLE;
+
+    @Override
+    public float getInnerAngle() {
+        return innerAngle;
+    }
+
+    public void setInnerAngle(float innerAngle) {
+        if (this.innerAngle != innerAngle) {
+            this.innerAngle = innerAngle;
+            visualsChanged();
+        }
+    }
+
+
+    private float outerAngle = DEFAULT_OUTER_ANGLE;
+
+    @Override
+    public float getOuterAngle() {
+        return outerAngle;
+    }
+
+    public void setOuterAngle(float outerAngle) {
+        if (this.outerAngle != outerAngle) {
+            this.outerAngle = outerAngle;
+            visualsChanged();
+        }
+    }
+
+
+    private float falloff = DEFAULT_FALLOFF;
+
+    @Override
+    public float getFalloff() {
+        return falloff;
+    }
+
+    public void setFalloff(float falloff) {
+        if (this.falloff != falloff) {
+            this.falloff = falloff;
+            visualsChanged();
+        }
+    }
+}

modules/javafx.graphics/src/main/java/com/sun/javafx/sg/prism/NGSpotLight.java

@@ -46,10 +46,9 @@ public interface MeshView extends GraphicsResource {
 
     public void setAmbientLight(float r, float g, float b);
 
-    public void setPointLight(int index,
-            float x, float y, float z,
-            float r, float g, float b, float w,
-            float ca, float la, float qa, float maxRange);
+    public void setLight(int index, float x, float y, float z, float r, float g, float b, float w,
+            float ca, float la, float qa, float maxRange, float dirX, float dirY, float dirZ,
+            float innerAngle, float outerAngle, float falloff);
 
     public void render(Graphics g);
 

modules/javafx.graphics/src/main/java/com/sun/prism/MeshView.java

@@ -473,9 +473,9 @@ private static native void nSetWireframe(long pContext, long nativeMeshView,
             boolean wireframe);
     private static native void nSetAmbientLight(long pContext, long nativeMeshView,
             float r, float g, float b);
-    private static native void nSetPointLight(long pContext, long nativeMeshView,
-            int index, float x, float y, float z, float r, float g, float b, float w,
-            float ca, float la, float qa, float maxRange);
+    private static native void nSetLight(long pContext, long nativeMeshView,
+            int index, float x, float y, float z, float r, float g, float b, float w, float ca, float la, float qa,
+            float maxRange, float dirX, float dirY, float dirZ, float innerAngle, float outerAngle, float falloff);
     private static native void nRenderMeshView(long pContext, long nativeMeshView);
     private static native int nDrawIndexedQuads(long pContext,
             float coords[], byte colors[], int numVertices);
@@ -610,9 +610,11 @@ void setAmbientLight(long nativeMeshView, float r, float g, float b) {
         nSetAmbientLight(pContext, nativeMeshView, r, g, b);
     }
 
-    void setPointLight(long nativeMeshView, int index, float x, float y, float z,
-            float r, float g, float b, float w, float ca, float la, float qa, float maxRange) {
-        nSetPointLight(pContext, nativeMeshView, index, x, y, z, r, g, b, w, ca, la, qa, maxRange);
+    void setLight(long nativeMeshView, int index, float x, float y, float z, float r, float g, float b, float w,
+            float ca, float la, float qa, float maxRange, float dirX, float dirY, float dirZ,
+            float innerAngle, float outerAngle, float falloff) {
+        nSetLight(pContext, nativeMeshView, index, x, y, z, r, g, b, w,  ca, la, qa, maxRange,
+                dirX, dirY, dirZ, innerAngle, outerAngle, falloff);
     }
 
     @Override

modules/javafx.graphics/src/main/java/com/sun/prism/d3d/D3DContext.java

@@ -82,11 +82,13 @@ public void setAmbientLight(float r, float g, float b) {
     }
 
     @Override
-    public void setPointLight(int index, float x, float y, float z, float r, float g, float b, float w,
-            float ca, float la, float qa, float maxRange) {
+    public void setLight(int index, float x, float y, float z, float r, float g, float b, float w,
+            float ca, float la, float qa, float maxRange, float dirX, float dirY, float dirZ,
+            float innerAngle, float outerAngle, float falloff) {
         // NOTE: We only support up to 3 point lights at the present
         if (index >= 0 && index <= 2) {
-            context.setPointLight(nativeHandle, index, x, y, z, r, g, b, w, ca, la, qa, maxRange);
+            context.setLight(nativeHandle, index, x, y, z, r, g, b, w, ca, la, qa, maxRange,
+                    dirX, dirY, dirZ, innerAngle, outerAngle, falloff);
         }
     }
 

modules/javafx.graphics/src/main/java/com/sun/prism/d3d/D3DMeshView.java

@@ -449,9 +449,11 @@ void setAmbientLight(long nativeHandle, float r, float g, float b) {
         glContext.setAmbientLight(nativeHandle, r, g, b);
     }
 
-    void setPointLight(long nativeHandle, int index, float x, float y, float z, float r, float g, float b, float w,
-            float ca, float la, float qa, float maxRange) {
-        glContext.setPointLight(nativeHandle, index, x, y, z, r, g, b, w, ca, la, qa, maxRange);
+    void setLight(long nativeHandle, int index, float x, float y, float z, float r, float g, float b, float w,
+            float ca, float la, float qa, float maxRange, float dirX, float dirY, float dirZ,
+            float innerAngle, float outerAngle, float falloff) {
+        glContext.setLight(nativeHandle, index, x, y, z, r, g, b, w, ca, la, qa, maxRange, dirX, dirY, dirZ,
+                innerAngle, outerAngle, falloff);
     }
 
     @Override

modules/javafx.graphics/src/main/java/com/sun/prism/es2/ES2Context.java

@@ -33,18 +33,31 @@ class ES2Light {
     float x, y, z = 0;
     float r, g, b, w = 1;
     float ca, la, qa, maxRange;
+    float dirX, dirY, dirZ;
+    float innerAngle, outerAngle, falloff;
 
-    ES2Light(float ix, float iy, float iz, float ir, float ig, float ib, float iw, float ca, float la, float qa, float maxRange) {
-        x = ix;
-        y = iy;
-        z = iz;
-        r = ir;
-        g = ig;
-        b = ib;
-        w = iw;
+    ES2Light(float x, float y, float z, float r, float g, float b, float w, float ca, float la, float qa,
+            float maxRange, float dirX, float dirY, float dirZ, float innerAngle, float outerAngle, float falloff) {
+        this.x = x;
+        this.y = y;
+        this.z = z;
+        this.r = r;
+        this.g = g;
+        this.b = b;
+        this.w = w;
         this.ca = ca;
         this.la = la;
         this.qa = qa;
         this.maxRange = maxRange;
+        this.dirX = dirX;
+        this.dirY = dirY;
+        this.dirZ = dirZ;
+        this.innerAngle = innerAngle;
+        this.outerAngle = outerAngle;
+        this.falloff = falloff;
+    }
+
+    boolean isPointLight() {
+        return falloff == 0 && outerAngle == 180;
     }
 }

modules/javafx.graphics/src/main/java/com/sun/prism/es2/ES2Light.java

@@ -101,16 +101,19 @@ float getAmbientLightBlue() {
     }
 
     @Override
-    public void setPointLight(int index, float x, float y, float z, float r, float g, float b, float w,
-            float ca, float la, float qa, float maxRange) {
+    public void setLight(int index, float x, float y, float z, float r, float g, float b, float w,
+            float ca, float la, float qa, float maxRange, float dirX, float dirY, float dirZ,
+            float innerAngle, float outerAngle, float falloff) {
         // NOTE: We only support up to 3 point lights at the present
         if (index >= 0 && index <= 2) {
-            lights[index] = new ES2Light(x, y, z, r, g, b, w, ca, la, qa, maxRange);
-            context.setPointLight(nativeHandle, index, x, y, z, r, g, b, w, ca, la, qa, maxRange);
+            lights[index] = new ES2Light(x, y, z, r, g, b, w, ca, la, qa, maxRange, dirX, dirY, dirZ, innerAngle,
+                        outerAngle, falloff);
+            context.setLight(nativeHandle, index, x, y, z, r, g, b, w, ca, la, qa, maxRange, dirX, dirY, dirZ,
+                    innerAngle, outerAngle, falloff);
         }
     }
 
-    ES2Light[] getPointLights() {
+    ES2Light[] getLights() {
         return lights;
     }
 

modules/javafx.graphics/src/main/java/com/sun/prism/es2/ES2MeshView.java

@@ -146,7 +146,7 @@ static ES2Shader getShader(ES2MeshView meshView, ES2Context context) {
         }
 
         int numLights = 0;
-        for (ES2Light light : meshView.getPointLights()) {
+        for (ES2Light light : meshView.getLights()) {
             if (light != null && light.w > 0) { numLights++; }
         }
 
@@ -203,15 +203,36 @@ static void setShaderParamaters(ES2Shader shader, ES2MeshView meshView, ES2Conte
         shader.setConstant("ambientColor", meshView.getAmbientLightRed(),
                 meshView.getAmbientLightGreen(), meshView.getAmbientLightBlue());
 
-        int i = 0;
-        for (ES2Light light : meshView.getPointLights()) {
+        for (int i = 0; i < meshView.getLights().length; i++) {
+            ES2Light light = meshView.getLights()[i];
             if (light != null && light.w > 0) {
-                shader.setConstant("lights[" + i + "].pos", light.x, light.y, light.z, light.w);
-                shader.setConstant("lights[" + i + "].color", light.r, light.g, light.b);
-                shader.setConstant("lights[" + i + "].attn", light.ca, light.la, light.qa);
-                shader.setConstant("lights[" + i + "].range", light.maxRange);
-                i++;
+                setLightConstants(i, shader, light);
             }
         }
     }
+
+    private static void setLightConstants(int i, ES2Shader shader, ES2Light light) {
+        shader.setConstant("lights[" + i + "].pos", light.x, light.y, light.z, light.w);
+        shader.setConstant("lights[" + i + "].color", light.r, light.g, light.b);
+        shader.setConstant("lights[" + i + "].attn", light.ca, light.la, light.qa);
+        shader.setConstant("lights[" + i + "].range", light.maxRange);
+        if (light.isPointLight()) {
+            shader.setConstant("lights[" + i + "].dir", 0f, 0f, 1f);
+            shader.setConstant("lights[" + i + "].cosOuter", -1f); // cos(180)
+            shader.setConstant("lights[" + i + "].denom", 2f);     // cos(0) - cos(180)
+            shader.setConstant("lights[" + i + "].falloff", 0f);
+        } else {
+            float dirX = light.dirX;
+            float dirY = light.dirY;
+            float dirZ = light.dirZ;
+            float length = (float) Math.sqrt(dirX * dirX + dirY * dirY + dirZ * dirZ);
+            shader.setConstant("lights[" + i + "].dir", dirX / length, dirY / length, dirZ / length);
+            // preparing for: I = pow((cosAngle - cosOuter) / (cosInner - cosOuter), falloff);
+            float cosOuter = (float) Math.cos(Math.toRadians(light.outerAngle));
+            float cosInner = (float) Math.cos(Math.toRadians(light.innerAngle));
+            shader.setConstant("lights[" + i + "].cosOuter", cosOuter);
+            shader.setConstant("lights[" + i + "].denom", cosInner - cosOuter);
+            shader.setConstant("lights[" + i + "].falloff", light.falloff);
+        }
+    }
 }

modules/javafx.graphics/src/main/java/com/sun/prism/es2/ES2PhongShader.java

@@ -251,9 +251,9 @@ private static native void nSetWireframe(long nativeCtxInfo, long nativeMeshView
             boolean wireframe);
     private static native void nSetAmbientLight(long nativeCtxInfo, long nativeMeshViewInfo,
             float r, float g, float b);
-    private static native void nSetPointLight(long nativeCtxInfo, long nativeMeshViewInfo,
-            int index, float x, float y, float z, float r, float g, float b, float w,
-            float ca, float la, float qa, float maxRange);
+    private static native void nSetLight(long nativeCtxInfo, long nativeMeshViewInfo,
+            int index, float x, float y, float z, float r, float g, float b, float w, float ca, float la, float qa,
+            float maxRange, float dirX, float dirY, float dirZ, float innerAngle, float outerAngle, float falloff);
     private static native void nRenderMeshView(long nativeCtxInfo, long nativeMeshViewInfo);
     private static native void nBlit(long nativeCtxInfo, int srcFBO, int dstFBO,
             int srcX0, int srcY0, int srcX1, int srcY1,
@@ -809,9 +809,11 @@ void setAmbientLight(long nativeMeshViewInfo, float r, float g, float b) {
         nSetAmbientLight(nativeCtxInfo, nativeMeshViewInfo, r, g, b);
     }
 
-    void setPointLight(long nativeMeshViewInfo, int index, float x, float y, float z, float r, float g, float b, float w,
-            float ca, float la, float qa, float maxRange) {
-        nSetPointLight(nativeCtxInfo, nativeMeshViewInfo, index, x, y, z, r, g, b, w, ca, la, qa, maxRange);
+    void setLight(long nativeMeshViewInfo, int index, float x, float y, float z, float r, float g, float b, float w,
+            float ca, float la, float qa, float maxRange, float dirX, float dirY, float dirZ,
+            float innerAngle, float outerAngle, float falloff) {
+        nSetLight(nativeCtxInfo, nativeMeshViewInfo, index, x, y, z, r, g, b, w, ca, la, qa, maxRange,
+                dirX, dirY, dirZ, innerAngle, outerAngle, falloff);
     }
 
     void renderMeshView(long nativeMeshViewInfo) {

modules/javafx.graphics/src/main/java/com/sun/prism/es2/GLContext.java

@@ -0,0 +1,251 @@
+/*
+ * Copyright (c) 2020, 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.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * 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.
+ */
+
+package javafx.scene;
+
+import com.sun.javafx.scene.DirtyBits;
+import com.sun.javafx.scene.NodeHelper;
+import com.sun.javafx.scene.SpotLightHelper;
+import com.sun.javafx.sg.prism.NGNode;
+import com.sun.javafx.sg.prism.NGSpotLight;
+
+import javafx.beans.property.DoubleProperty;
+import javafx.beans.property.ObjectProperty;
+import javafx.beans.property.SimpleObjectProperty;
+import javafx.geometry.Point3D;
+import javafx.scene.paint.Color;
+import javafx.scene.paint.PhongMaterial;
+
+/**
+ * A {@code SpotLight} is a {@code PointLight} that radiates light in a cone in a specific direction.
+ * The direction is defined by the {@link #directionProperty() direction} vector property of the light. The direction
+ * can be rotated by setting a rotation transform on the {@code SpotLight}. For example, if the direction vector is
+ * {@code (1, 1, 1)} and the light is not rotated, it will point in the {@code (1, 1, 1)} direction, and if the light is
+ * rotated 90 degrees on the y axis, it will point in the {@code (1, 1, -1)} direction.
+ * <p>
+ * In addition to the factors that control the light intensity of a {@code PointLight}, a {@code SpotLight} has a
+ * light-cone attenuation factor, {@code spot}, that is determined by 3 properties:
+ * <ul>
+ * <li> {@link #innerAngleProperty() innerAngle}: the angle of the inner cone (see image below)
+ * <li> {@link #outerAngleProperty() outerAngle}: the angle of the outer cone (see image below)
+ * <li> {@link #falloffProperty() falloff}: the factor that controls the light's intensity drop inside the outer cone
+ * </ul>
+ * The valid ranges for these properties are {@code 0 <= innerAngle <= outerAngle <= 180} and {@code falloff >= 0};
+ * values outside either of these ranges can produce unexpected results.
+ * <p>
+ * The angle of a point to the light is defined as the angle between its vector to the light's position and the
+ * direction of the light. For such an angle {@code theta}, if
+ * <ul>
+ * <li>{@code theta < innerAngle} then {@code spot = 1}
+ * <li>{@code theta > outerAngle} then {@code spot = 0}
+ * <li>{@code innerAngle <= theta <= outerAngle} then
+ *
+ * <pre>spot = pow((cos(theta) - cos(outer)) / (cos(inner) - cos(outer)), falloff)</pre>
+ *
+ * which represents a drop in intensity from the inner angle to the outer angle.
+ * </ul>
+ * As a result, {@code 0 <= spot <= 1}. The overall intensity of the light is {@code I = lambert * atten * spot}.
+ * <p>
+ * <img src="doc-files/spotlight.png" alt="Image of the Spotlight">
+ *
+ * @since 17
+ * @see PhongMaterial
+ */
+public class SpotLight extends PointLight {
+    static {
+        SpotLightHelper.setSpotLightAccessor(new SpotLightHelper.SpotLightAccessor() {
+            @Override
+            public NGNode doCreatePeer(Node node) {
+                return ((SpotLight) node).doCreatePeer();
+            }
+
+            @Override
+            public void doUpdatePeer(Node node) {
+                ((SpotLight) node).doUpdatePeer();
+            }
+        });
+    }
+
+    {
+        // To initialize the class helper at the beginning of each constructor of this class
+        SpotLightHelper.initHelper(this);
+    }
+
+    /**
+     * Creates a new instance of {@code SpotLight} class with a default {@code Color.WHITE} light source.
+     */
+    public SpotLight() {
+        super();
+    }
+
+    /**
+     * Creates a new instance of {@code SpotLight} class using the specified color.
+     *
+     * @param color the color of the light source
+     */
+    public SpotLight(Color color) {
+        super(color);
+    }
+
+
+    /**
+     * The direction vector of the spotlight. It can be rotated by setting a rotation transform on the
+     * {@code SpotLight}. The vector need not be normalized.
+     *
+     * @defaultValue {@code Point3D(0, 0, 1)}
+     */
+    private ObjectProperty<Point3D> direction;
+
+    public final void setDirection(Point3D value) {
+        directionProperty().set(value);
+    }
+
+    private static final Point3D DEFAULT_DIRECTION = NGSpotLight.getDefaultDirection();
+
+    public final Point3D getDirection() {
+        return direction == null ? DEFAULT_DIRECTION : direction.get();
+    }
+
+    public final ObjectProperty<Point3D> directionProperty() {
+        if (direction == null) {
+            direction = new SimpleObjectProperty<>(this, "direction", DEFAULT_DIRECTION) {
+                @Override
+                protected void invalidated() {
+                    NodeHelper.markDirty(SpotLight.this, DirtyBits.NODE_LIGHT);
+                }
+            };
+        }
+        return direction;
+    }
+
+
+    /**
+     * The angle of the spotlight's inner cone, in degrees. A point whose angle to the light is less than this angle is
+     * not attenuated by the spotlight factor ({@code spot = 1}). At larger angles, the light intensity starts to drop.
+     * See the class doc for more information.
+     * <p>
+     * The valid range is {@code 0 <= innerAngle <= outerAngle}; values outside of this range can produce unexpected
+     * results.
+     *
+     * @defaultValue 0
+     */
+    private DoubleProperty innerAngle;
+
+    public final void setInnerAngle(double value) {
+        innerAngleProperty().set(value);
+    }
+
+    private static final double DEFAULT_INNER_ANGLE = NGSpotLight.getDefaultInnerAngle();
+
+    public final double getInnerAngle() {
+        return innerAngle == null ? DEFAULT_INNER_ANGLE : innerAngle.get();
+    }
+
+    public final DoubleProperty innerAngleProperty() {
+        if (innerAngle == null) {
+            innerAngle = getLightDoubleProperty("innerAngle", DEFAULT_INNER_ANGLE);
+        }
+        return innerAngle;
+    }
+
+
+    /**
+     * The angle of the spotlight's outer cone, in degrees (as shown in the class doc image). A point whose angle to the
+     * light is greater than this angle receives no light ({@code spot = 0}). A point whose angle to the light is less
+     * than the outer angle but greater than the inner angle receives partial intensity governed by the falloff factor.
+     * See the class doc for more information.
+     * <p>
+     * The valid range is {@code innerAngle <= outerAngle <= 180}; values outside of this range can produce unexpected
+     * results.
+     *
+     * @defaultValue 30
+     */
+    private DoubleProperty outerAngle;
+
+    public final void setOuterAngle(double value) {
+        outerAngleProperty().set(value);
+    }
+
+    private static final double DEFAULT_OUTER_ANGLE = NGSpotLight.getDefaultOuterAngle();
+
+    public final double getOuterAngle() {
+        return outerAngle == null ? DEFAULT_OUTER_ANGLE : outerAngle.get();
+    }
+
+    public final DoubleProperty outerAngleProperty() {
+        if (outerAngle == null) {
+            outerAngle = getLightDoubleProperty("outerAngle", DEFAULT_OUTER_ANGLE);
+        }
+        return outerAngle;
+    }
+
+
+    /**
+     * The intensity falloff factor of the spotlight's outer cone. A point whose angle to the light is
+     * greater than the inner angle but less than the outer angle receives partial intensity governed by this factor.
+     * The larger the falloff, the sharper the drop in intensity from the inner cone. A falloff factor of 1 gives a
+     * linear drop in intensity, values greater than 1 give a convex drop, and values smaller than 1 give a concave
+     * drop. See the class doc for more information.
+     * <p>
+     * The valid range is {@code 0 <= falloff}; values outside of this range can produce unexpected results.
+     *
+     * @defaultValue 1
+     */
+    private DoubleProperty falloff;
+
+    public final void setFalloff(double value) {
+        falloffProperty().set(value);
+    }
+
+    private static final double DEFAULT_FALLOFF = NGSpotLight.getDefaultFalloff();
+
+    public final double getFalloff() {
+        return falloff == null ? DEFAULT_FALLOFF : falloff.get();
+    }
+
+    public final DoubleProperty falloffProperty() {
+        if (falloff == null) {
+            falloff = getLightDoubleProperty("falloff", DEFAULT_FALLOFF);
+        }
+        return falloff;
+    }
+
+    /*
+     * Note: This method MUST only be called via its accessor method.
+     */
+    private NGNode doCreatePeer() {
+        return new NGSpotLight();
+    }
+
+    private void doUpdatePeer() {
+        if (isDirty(DirtyBits.NODE_LIGHT)) {
+            NGSpotLight peer = getPeer();
+            peer.setDirection(getDirection());
+            peer.setInnerAngle((float) getInnerAngle());
+            peer.setOuterAngle((float) getOuterAngle());
+            peer.setFalloff((float) getFalloff());
+        }
+    }
+}

modules/javafx.graphics/src/main/java/javafx/scene/SpotLight.java

@@ -511,18 +511,19 @@ JNIEXPORT void JNICALL Java_com_sun_prism_d3d_D3DContext_nSetAmbientLight
 
 /*
  * Class:     com_sun_prism_d3d_D3DContext
- * Method:    nSetPointLight
- * Signature: (JJIFFFFFFF)V
+ * Method:    nSetLight
+ * Signature: (JJIFFFFFFFFFFFFFFFFF)V
  */
-JNIEXPORT void JNICALL Java_com_sun_prism_d3d_D3DContext_nSetPointLight
+JNIEXPORT void JNICALL Java_com_sun_prism_d3d_D3DContext_nSetLight
   (JNIEnv *env, jclass, jlong ctx, jlong nativeMeshView, jint index,
         jfloat x, jfloat y, jfloat z, jfloat r, jfloat g, jfloat b, jfloat w,
-        jfloat ca, jfloat la, jfloat qa, jfloat range)
+        jfloat ca, jfloat la, jfloat qa, jfloat range,
+        jfloat dirX, jfloat dirY, jfloat dirZ, jfloat innerAngle, jfloat outerAngle, jfloat falloff)
 {
-    TraceLn(NWT_TRACE_INFO, "D3DContext_nSetPointLight");
+    TraceLn(NWT_TRACE_INFO, "D3DContext_nSetLight");
     D3DMeshView *meshView = (D3DMeshView *) jlong_to_ptr(nativeMeshView);
     RETURN_IF_NULL(meshView);
-    meshView->setPointLight(index, x, y, z, r, g, b, w, ca, la, qa, range);
+    meshView->setLight(index, x, y, z, r, g, b, w, ca, la, qa, range, dirX, dirY, dirZ, innerAngle, outerAngle, falloff);
 }
 
 /*

modules/javafx.graphics/src/main/native-prism-d3d/D3DContext.cc

@@ -34,19 +34,20 @@ using std::endl;
 D3DLight::~D3DLight() {
 }
 
-D3DLight::D3DLight() {
-    color[0] = 0;
-    color[1] = 0;
-    color[2] = 0;
-    position[0] = 0;
-    position[1] = 0;
-    position[2] = 0;
-    position[3] = 0; // padding since SetPixelShaderConstantF only takes vec4f; position[3] is unused
-    w = 0;
-    attenuation[0] = 1;
-    attenuation[1] = 0;
-    attenuation[2] = 0;
-    maxRange = 0;
+D3DLight::D3DLight() :
+    color(),
+    position(),
+    w(0),
+    attenuation(),
+    maxRange(0),
+    direction(),
+    innerAngle(0),
+    outerAngle(0),
+    falloff(0)
+    {}
+
+bool D3DLight::isPointLight() {
+    return falloff == 0 && outerAngle == 180;
 }
 
 void D3DLight::setColor(float r, float g, float b) {

modules/javafx.graphics/src/main/native-prism-d3d/D3DLight.cc

@@ -34,18 +34,22 @@ class D3DLight {
 public:
     D3DLight();
     virtual ~D3DLight();
+    bool isPointLight();
     void setColor(float r, float g, float b);
     void setPosition(float x, float y, float z);
-//  void setRange(float r);
-    float position[4]; // Only need x, y, z. The last float is needed for padding when upload to shader.
+
+    float position[3];
     float color[3];
     float w;
     float attenuation[3]; // ca, la, qa
     float maxRange;
+    float direction[3];
+    float innerAngle;
+    float outerAngle;
+    float falloff;
 
 private:
 
 };
 
 #endif  /* D3DLIGHT_H */
-

modules/javafx.graphics/src/main/native-prism-d3d/D3DLight.h

@@ -24,6 +24,8 @@
  */
 
 #include <iostream>
+#define _USE_MATH_DEFINES
+#include <math.h>
 #include "D3DMeshView.h"
 #include "D3DPhongShader.h"
 
@@ -37,7 +39,6 @@ D3DMeshView::~D3DMeshView() {
     // The freeing of native resources is handled by its Java layer.
     mesh = NULL;
     material = NULL;
-
 }
 
 D3DMeshView::D3DMeshView(D3DContext *ctx, D3DMesh *pMesh) {
@@ -72,22 +73,29 @@ void D3DMeshView::setAmbientLight(float r, float g, float b) {
     ambientLightColor[2] = b;
 }
 
-void D3DMeshView::setPointLight(int index, float x, float y, float z,
-        float r, float g, float b, float w,
-        float ca, float la, float qa, float maxRange) {
+void D3DMeshView::setLight(int index, float x, float y, float z, float r, float g, float b, float w,
+        float ca, float la, float qa, float maxRange,
+        float dirX, float dirY, float dirZ, float innerAngle, float outerAngle, float falloff) {
     // NOTE: We only support up to 3 point lights at the present
-    if (index >= 0 && index <= 2) {
-        lights[index].position[0] = x;
-        lights[index].position[1] = y;
-        lights[index].position[2] = z;
-        lights[index].color[0] = r;
-        lights[index].color[1] = g;
-        lights[index].color[2] = b;
-        lights[index].w = w;
-        lights[index].attenuation[0] = ca;
-        lights[index].attenuation[1] = la;
-        lights[index].attenuation[2] = qa;
-        lights[index].maxRange = maxRange;
+    if (index >= 0 && index <= MAX_NUM_LIGHTS - 1) {
+        D3DLight& light = lights[index];
+        light.position[0] = x;
+        light.position[1] = y;
+        light.position[2] = z;
+        light.color[0] = r;
+        light.color[1] = g;
+        light.color[2] = b;
+        light.w = w;
+        light.attenuation[0] = ca;
+        light.attenuation[1] = la;
+        light.attenuation[2] = qa;
+        light.maxRange = maxRange;
+        light.direction[0] = dirX;
+        light.direction[1] = dirY;
+        light.direction[2] = dirZ;
+        light.innerAngle = innerAngle;
+        light.outerAngle = outerAngle;
+        light.falloff = falloff;
         lightsDirty = TRUE;
     }
 }
@@ -98,7 +106,7 @@ void D3DMeshView::computeNumLights() {
     lightsDirty = false;
 
     int n = 0;
-    for (int i = 0; i != 3; ++i)
+    for (int i = 0; i != MAX_NUM_LIGHTS; ++i)
         n += lights[i].w ? 1 : 0;
 
     numLights = n;
@@ -137,10 +145,35 @@ void D3DMeshView::render() {
 
     computeNumLights();
     // We only support up to 3 point lights at the present
-    for (int i = 0; i < 3; i++) {
+    for (int i = 0; i < MAX_NUM_LIGHTS; i++) {
         status = SUCCEEDED(device->SetVertexShaderConstantF(VSR_LIGHTS + i*2, lights[i].position, 1));
     }
 
+    float lightsNormDirection[MAX_NUM_LIGHTS * 4]; // 3 lights x (3 coords + 1 padding)
+    for (int i = 0, d = 0; i < MAX_NUM_LIGHTS; i++) {
+        if (lights[i].isPointLight()) {
+            lightsNormDirection[d++] = 0;
+            lightsNormDirection[d++] = 0;
+            lightsNormDirection[d++] = 1;
+            lightsNormDirection[d++] = 0;
+        } else {
+            float dirX = lights[i].direction[0];
+            float dirY = lights[i].direction[1];
+            float dirZ = lights[i].direction[2];
+            float length = sqrt(dirX * dirX + dirY * dirY + dirZ * dirZ);
+            lightsNormDirection[d++] = dirX / length;
+            lightsNormDirection[d++] = dirY / length;
+            lightsNormDirection[d++] = dirZ / length;
+            lightsNormDirection[d++] = 0;
+        }
+    }
+
+    status = SUCCEEDED(device->SetVertexShaderConstantF(VSR_DIRS, lightsNormDirection, MAX_NUM_LIGHTS));
+    if (!status) {
+        cout << "D3DMeshView.render() - SetVertexShaderConstantF (VSR_DIRS) failed !!!" << endl;
+        return;
+    }
+
     status = SUCCEEDED(device->SetVertexShaderConstantF(VSR_AMBIENTCOLOR, ambientLightColor, 1));
     if (!status) {
         cout << "D3DMeshView.render() - SetVertexShaderConstantF (VSR_AMBIENTCOLOR) failed !!!" << endl;
@@ -159,10 +192,11 @@ void D3DMeshView::render() {
         return;
     }
 
-    float lightsColor[12];       // 3 lights x (3 color + 1 padding)
-    float lightsAttenuation[12]; // 3 lights x (3 attenuation factors + 1 padding)
-    float lightsRange[12];       // 3 lights x (1 maxRange + 3 padding)
-    for (int i = 0, c = 0, a = 0, r = 0; i < 3; i++) {
+    float lightsColor[MAX_NUM_LIGHTS * 4];        // 3 lights x (3 color + 1 padding)
+    float lightsAttenuation[MAX_NUM_LIGHTS * 4];  // 3 lights x (3 attenuation factors + 1 padding)
+    float lightsRange[MAX_NUM_LIGHTS * 4];        // 3 lights x (1 maxRange + 3 padding)
+    float spotLightsFactors[MAX_NUM_LIGHTS * 4];  // 3 lights x (2 angles + 1 falloff + 1 padding)
+    for (int i = 0, c = 0, a = 0, r = 0, s = 0; i < MAX_NUM_LIGHTS; i++) {
         float w = lights[i].w;
         lightsColor[c++] = lights[i].color[0] * w;
         lightsColor[c++] = lights[i].color[1] * w;
@@ -178,20 +212,44 @@ void D3DMeshView::render() {
         lightsRange[r++] = 0;
         lightsRange[r++] = 0;
         lightsRange[r++] = 0;
+
+        if (lights[i].isPointLight()) {
+            spotLightsFactors[s++] = -1; // cos(180)
+            spotLightsFactors[s++] = 2;  // cos(0) - cos(180)
+            spotLightsFactors[s++] = 0;
+            spotLightsFactors[s++] = 0;
+        } else {
+            // preparing for: I = pow((cosAngle - cosOuter) / (cosInner - cosOuter), falloff)
+            float cosInner = cos(lights[i].innerAngle * M_PI / 180);
+            float cosOuter = cos(lights[i].outerAngle * M_PI / 180);
+            spotLightsFactors[s++] = cosOuter;
+            spotLightsFactors[s++] = cosInner - cosOuter;
+            spotLightsFactors[s++] = lights[i].falloff;
+            spotLightsFactors[s++] = 0;
+        }
     }
-    status = SUCCEEDED(device->SetPixelShaderConstantF(PSR_LIGHTCOLOR, lightsColor, 3));
+
+    status = SUCCEEDED(device->SetPixelShaderConstantF(PSR_LIGHTCOLOR, lightsColor, MAX_NUM_LIGHTS));
     if (!status) {
-        cout << "D3DMeshView.render() - SetPixelShaderConstantF (PSR_LIGHTCOLOR) failed !!!" << endl;
+        cout << "D3DMeshView.render() - SetPixelShaderConstantF(PSR_LIGHTCOLOR) failed !!!" << endl;
         return;
     }
-    status = SUCCEEDED(device->SetPixelShaderConstantF(PSR_LIGHT_ATTENUATION, lightsAttenuation, 3));
+
+    status = SUCCEEDED(device->SetPixelShaderConstantF(PSR_LIGHT_ATTENUATION, lightsAttenuation, MAX_NUM_LIGHTS));
     if (!status) {
-        cout << "D3DMeshView.render() - SetPixelShaderConstantF (PSR_LIGHT_ATTENUATION) failed !!!" << endl;
+        cout << "D3DMeshView.render() - SetPixelShaderConstantF(PSR_LIGHT_ATTENUATION) failed !!!" << endl;
         return;
     }
-    status = SUCCEEDED(device->SetPixelShaderConstantF(PSR_LIGHT_RANGE, lightsRange, 3));
+
+    status = SUCCEEDED(device->SetPixelShaderConstantF(PSR_LIGHT_RANGE, lightsRange, MAX_NUM_LIGHTS));
     if (!status) {
-        cout << "D3DMeshView.render() - SetPixelShaderConstantF (PSR_LIGHT_RANGE) failed !!!" << endl;
+        cout << "D3DMeshView.render() - SetPixelShaderConstantF(PSR_LIGHT_RANGE) failed !!!" << endl;
+        return;
+    }
+
+    status = SUCCEEDED(device->SetPixelShaderConstantF(PSR_SPOTLIGHT_FACTORS, spotLightsFactors, MAX_NUM_LIGHTS));
+    if (!status) {
+        cout << "D3DMeshView.render() - SetPixelShaderConstantF(PSR_SPOTLIGHT_FACTORS) failed !!!" << endl;
         return;
     }
 
@@ -234,5 +292,4 @@ void D3DMeshView::render() {
     SUCCEEDED(device->SetIndices(mesh->getIndexBuffer()));
     SUCCEEDED(device->DrawIndexedPrimitive(D3DPT_TRIANGLELIST, 0, 0,
             mesh->getNumVertices(), 0, (mesh->getNumIndices()/3)));
-
 }

modules/javafx.graphics/src/main/native-prism-d3d/D3DMeshView.cc

@@ -31,6 +31,8 @@
 #include "D3DMesh.h"
 #include "D3DPhongMaterial.h"
 
+#define MAX_NUM_LIGHTS 3
+
 class D3DMeshView {
 public:
     D3DMeshView(D3DContext *pCtx, D3DMesh *pMesh);
@@ -39,17 +41,19 @@ class D3DMeshView {
     void setMaterial(D3DPhongMaterial *pMaterial);
     void setWireframe(bool wf);
     void setAmbientLight(float r, float g, float b);
-    void setPointLight(int index, float x, float y, float z,
+    void setLight(int index, float x, float y, float z,
         float r, float g, float b, float w,
-        float ca, float la, float qa, float maxRange);
+        float ca, float la, float qa, float maxRange,
+        float dirX, float dirY, float dirZ,
+        float innerAngle, float outerAngle, float falloff);
     void computeNumLights();
     void render();
 
 private:
     D3DContext *context;
     D3DMesh *mesh;
     D3DPhongMaterial *material;
-    D3DLight lights[3];
+    D3DLight lights[MAX_NUM_LIGHTS];
     float ambientLightColor[3];
     int numLights;
     bool lightsDirty;
@@ -58,4 +62,3 @@ class D3DMeshView {
 };
 
 #endif  /* D3DMESHVIEW_H */
-

modules/javafx.graphics/src/main/native-prism-d3d/D3DMeshView.h

@@ -26,25 +26,38 @@
 #ifndef D3DPHONGSHADER_H
 #define D3DPHONGSHADER_H
 
-// VSR implies Vertex Shader Registers
-#define VSR_VIEWPROJMATRIX  0  // 4 total
-#define VSR_CAMERAPOS 4        // 1 total
-// lighting
-// 5 lights (3 in use, 2 reserved)
-// with 2 registers = 10 registers
-#define VSR_LIGHTS 10
-// 8 ambient points + 2 coords : 10 registers
-#define VSR_AMBIENTCOLOR 20
-// world
-#define VSR_WORLDMATRIX 30
-
-// PSR implies Pixel Shader Registers
-// we have 224 float constants for ps 3.0
-#define PSR_DIFFUSECOLOR 0
-#define PSR_SPECULARCOLOR 1
-#define PSR_LIGHTCOLOR 4        // 3 lights + 2 reserve
-#define PSR_LIGHT_ATTENUATION 9 // 3 lights + 2 reserve
-#define PSR_LIGHT_RANGE 14      // 3 lights + 2 reserve
+// Register assignments. Each register can hold 1 float4 vector.
+// See https://docs.microsoft.com/en-us/windows/win32/direct3dhlsl/dx9-graphics-reference-asm-vs-registers-constant-float
+
+// VSR implies Vertex Shader Registers. Assignments happen in vsConstants.h
+// We have at least 256 constant float registers for vs 3.0
+// See https://docs.microsoft.com/en-us/windows/win32/direct3dhlsl/dx9-graphics-reference-asm-vs-registers-vs-3-0
+#define VSR_VIEWPROJMATRIX 0  // 4x4 matrix = 4: c0-3
+#define VSR_CAMERAPOS 4       // 1 position: c4
+// Registers 5-9 (inclusive) are reserved
+
+// Lights: 5 lights (3 in use, 2 reserved)
+#define VSR_LIGHTS 10  // 1 position + 1 color = 5 * 2 = 10: c10-19
+#define VSR_DIRS 20    // 1 direction = 5 * 1 = 5: c20-24
+
+#define VSR_AMBIENTCOLOR 25 // 8 ambient points + 2 coords = 10 (only 1 is used): c25-34
+
+#define VSR_WORLDMATRIX 35 // 4x3 matrix = 3: c35-37
+
+// PSR implies Pixel Shader Registers. Assignments happen in psConstants.h
+// We have 224 constant float registers for ps 3.0
+// See https://docs.microsoft.com/en-us/windows/win32/direct3dhlsl/dx9-graphics-reference-asm-ps-registers-ps-3-0
+
+// Material
+#define PSR_DIFFUSECOLOR 0       // 1 color: c0
+#define PSR_SPECULARCOLOR 1      // 1 color (including the specular power): c1
+// Registers 2-3 (inclusive) are reserved
+
+// Lights: 5 lights (3 in use, 2 reserved)
+#define PSR_LIGHTCOLOR 4         // 1 color: c4-8
+#define PSR_LIGHT_ATTENUATION 9  // 1 attenuation: c9-13
+#define PSR_LIGHT_RANGE 14       // 1 range (max range at [0], reserved min range at [1], [2] and [3] unused): c14-18
+#define PSR_SPOTLIGHT_FACTORS 19 // 1 spotlight: c19-23
 
 // SR implies Sampler Registers
 #define SR_DIFFUSEMAP 0
@@ -109,4 +122,3 @@ static const int maxLights = 3;
 };
 
 #endif  /* D3DPHONGSHADER_H */
-

modules/javafx.graphics/src/main/native-prism-d3d/D3DPhongShader.h

@@ -88,7 +88,7 @@ float4 main(ObjectPsIn objAttr, LocalBump  lSpace) : color {
     float3 diff = 0;
     float3 spec = 0;
 
-    phong(n, nEye, sPower, lSpace.lights, diff, spec, 0, nSpecular);
+    phong(n, nEye, sPower, lSpace.lights, lSpace.lightDirs, diff, spec, 0, nSpecular);
 
     float3 rez = (ambColor.xyz+diff)*tDiff.xyz + spec*tSpec.rgb;
 

modules/javafx.graphics/src/main/native-prism-d3d/hlsl/Mtl1PS.hlsl

@@ -23,14 +23,15 @@
  * questions.
  */
 
-// see D3DPhongShader.h
+// see D3DPhongShader.h for register assignments
 
 static const int numMaxLights = 5;
 
 float4 gDiffuseColor : register(c0);
 float4 gSpecularColor : register(c1); // specular power is in the alpha
-float4 gLightColor[numMaxLights] : register(c4); // [c4 .. c8]
-float4 gLightAttenuation[numMaxLights] : register(c9); // [c9 .. c13]
-float4 gLightRange[numMaxLights] : register(c14); // [c14 .. c18]
+float4 gLightColor[numMaxLights] : register(c4);
+float4 gLightAttenuation[numMaxLights] : register(c9);
+float4 gLightRange[numMaxLights] : register(c14);       // {max range, reserved min range, _, _}
+float4 gSpotLightFactors[numMaxLights] : register(c19); // {cos(outer), cos(inner) - cos(outer), falloff, _}
 
-float4 gSomethingElse : register(c19);
+float4 gSomethingElse : register(c24);

modules/javafx.graphics/src/main/native-prism-d3d/hlsl/psConstants.h

@@ -58,22 +58,76 @@ float4 retNormal(float3 n) { return float4( n*0.5+0.5,1); }
 
 float4 retr(float x) { return float4(x.xxx,1); }
 
-void phong(
-    float3 n, float3 e, float power, in float4 L[LocalBump::nLights],
-    in out float3 d, in out float3 s, int _s, int _e)
-{
+// Because pow(0, 0) is undefined (https://docs.microsoft.com/en-us/windows/win32/direct3dhlsl/dx-graphics-hlsl-pow),
+// we need special treatment for falloff == 0 cases
+
+/*
+ * The methods 'computeSpotlightFactor' and 'computeSpotlightFactor2' are alternatives to the 'computeSpotlightFactor3'
+ * method that was chosen for its better performance. They are kept for the case that a future changes will make them
+ * more performant.
+ *
+float computeSpotlightFactor(float3 l, float3 lightDir, float cosOuter, float denom, float falloff) {
+    if (falloff == 0 && cosOuter == -1) { // point light optimization (cosOuter == -1 is outerAngle == 180)
+        return 1;
+    }
+    float cosAngle = dot(normalize(-lightDir), l);
+    float cutoff = cosAngle - cosOuter;
+    if (falloff != 0) {
+        return pow(saturate(cutoff / denom), falloff);
+    }
+    return cutoff >= 0 ? 1 : 0;
+}
+
+float computeSpotlightFactor2(float3 l, float3 lightDir, float cosOuter, float denom, float falloff) {
+    if (falloff != 0) {
+        float cosAngle = dot(normalize(-lightDir), l);
+        float cutoff = cosAngle - cosOuter;
+        return pow(saturate(cutoff / denom), falloff);
+    }
+    if (cosOuter == -1) {  // point light optimization (cosOuter == -1 is outerAngle == 180)
+        return 1;
+    }
+    float cosAngle = dot(normalize(-lightDir), l);
+    float cutoff = cosAngle - cosOuter;
+    return cutoff >= 0 ? 1 : 0;
+}
+*/
+
+float computeSpotlightFactor3(float3 l, float3 lightDir, float cosOuter, float denom, float falloff) {
+    float cosAngle = dot(normalize(-lightDir), l);
+    float cutoff = cosAngle - cosOuter;
+    if (falloff != 0) {
+        return pow(saturate(cutoff / denom), falloff);
+    }
+    return cutoff >= 0 ? 1 : 0;
+}
+
+void computeLight(float i, float3 n, float3 refl, float specPower, float3 L, float3 lightDir, in out float3 d, in out float3 s) {
+    float dist = length(L);
+    if (dist > gLightRange[i].x) {
+        return;
+    }
+    float3 l = normalize(L);
+
+    float cosOuter = gSpotLightFactors[i].x;
+    float denom = gSpotLightFactors[i].y;
+    float falloff = gSpotLightFactors[i].z;
+    float spotlightFactor = computeSpotlightFactor3(l, lightDir, cosOuter, denom, falloff);
+
+    float ca = gLightAttenuation[i].x;
+    float la = gLightAttenuation[i].y;
+    float qa = gLightAttenuation[i].z;
+    float invAttnFactor = ca + la * dist + qa * dist * dist;
+
+    float3 attenuatedColor = gLightColor[i].xyz * spotlightFactor / invAttnFactor;
+    d += saturate(dot(n, l)) * attenuatedColor;
+    s += pow(saturate(dot(-refl, l)), specPower) * attenuatedColor;
+}
+
+void phong(float3 n, float3 e, float specPower, in float4 L[LocalBump::nLights], in float4 lightDirs[LocalBump::nLights],
+        in out float3 d, in out float3 s, int _s, int _e) {
     float3 refl = reflect(e, n);
     for (int i = _s; i < _e; i++) {
-        float dist = length(L[i].xyz);
-        if (dist <= gLightRange[i].x) {
-            float ca = gLightAttenuation[i].x;
-            float la = gLightAttenuation[i].y;
-            float qa = gLightAttenuation[i].z;
-            float3 attenuatedColor = gLightColor[i].xyz / (ca + la * dist + qa * dist * dist);
-
-            float3 l = normalize(L[i].xyz);
-            d += saturate(dot(n, l)) * attenuatedColor;
-            s += pow(saturate(dot(-refl, l)), power) * attenuatedColor;
-        }
+        computeLight(i, n, refl, specPower, L[i].xyz, lightDirs[i].xyz, d, s);
     }
 }

modules/javafx.graphics/src/main/native-prism-d3d/hlsl/psMath.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2013, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2013, 2020 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
@@ -32,14 +32,15 @@ struct LocalBump {
 
     static const float nLights = 3;
 
-    float3  eye             : texcoord2;
-    float4  lights[nLights] : texcoord3; // 3, 4,5 [6]
-    float3  debug           : texcoord7;
+    float3 eye                : texcoord2;
+    float4 lights[nLights]    : texcoord3; // 3, 4, 5 [6]
+    float4 lightDirs[nLights] : texcoord7; // 7, 8, 9 [10]
+//  float3 debug              : texcoord11;
 };
 
 struct LocalBumpOut {
     float4  pos  : position;
-    float   oFog  : fog;
+    float   oFog : fog;
 
     LocalBump lBump;
 };
@@ -49,4 +50,3 @@ struct ObjVsOutput {
     LocalBumpOut light;
     ObjectPsIn   objAttr;
 };
-

modules/javafx.graphics/src/main/native-prism-d3d/hlsl/vs2ps.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2013, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2013, 2020, 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
@@ -38,20 +38,23 @@ struct Light {
     float4 color;
 };
 
+// See D3DPhongShader.h for register assignments
+
 // camera
-float4x4    mViewProj   : register (c0);
+float4x4    mViewProj   : register(c0);
 float4      gCameraPos  : register(c4);
 
 
 float4      gReserved5[5] : register(c5);
 
 // lighting
-Light       sLights[5]   : register(c10);
-float4      gAmbinet         : register (c20);
-float4      gAmbinetData[10] : register (c20);
+Light       sLights[5]        : register(c10);
+float4      gLightsNormDir[5] : register(c20);
+float4      gAmbinet          : register(c25);
+float4      gAmbinetData[10]  : register(c25);
 
 // world
-float4x3    mWorld                : register (c30);
-float4x3    mBones[MAX_BONES]     : register (c30);
+float4x3    mWorld            : register(c35);
+float4x3    mBones[MAX_BONES] : register(c35);
 
-float4      gReserved240[16] : register(c240);
+float4      gReserved245[11] : register(c245);

modules/javafx.graphics/src/main/native-prism-d3d/hlsl/vsConstants.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2013, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2013, 2020, 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
@@ -74,19 +74,19 @@ void calcLocalBump(float4 ipos, float4 iTn, in float4x3 mW, out LocalBumpOut r)
 
     for (int k=0; k<LocalBump::nLights; ++k) {
         float3 L = sLights[k].pos.xyz - pos;
+        float3 D = gLightsNormDir[k].xyz;
         r.lBump.lights[k] = float4(getLocalVector(L, n), 1);
+        r.lBump.lightDirs[k] = float4(getLocalVector(D, n), 1);
     }
 
     r.pos  = mul(float4(pos,1), mViewProj);
 
-    // r.Debug = r.Pos;
+//    r.Debug = r.Pos;
 
-    r.lBump.debug = n[0];
+//    r.lBump.debug = n[0];
 
     r.oFog  = 1; // getFogExp2(pos);
 
 }
 
 float4 retFloat(float x) { return float4(x.xxx,1); }
-
-

modules/javafx.graphics/src/main/native-prism-d3d/hlsl/vsMath.h

@@ -2114,18 +2114,24 @@ JNIEXPORT jlong JNICALL Java_com_sun_prism_es2_GLContext_nCreateES2MeshView
     meshViewInfo->ambientLightColor[0] = 0;
     meshViewInfo->ambientLightColor[1] = 0;
     meshViewInfo->ambientLightColor[2] = 0;
-    meshViewInfo->pointLightIndex = 0;
-    meshViewInfo->pointLightColor[0] = 0;
-    meshViewInfo->pointLightColor[1] = 0;
-    meshViewInfo->pointLightColor[2] = 0;
-    meshViewInfo->pointLightPosition[0] = 0;
-    meshViewInfo->pointLightPosition[1] = 0;
-    meshViewInfo->pointLightPosition[2] = 0;
-    meshViewInfo->pointLightWeight = 0;
-    meshViewInfo->pointLightAttenuation[0] = 1;
-    meshViewInfo->pointLightAttenuation[1] = 0;
-    meshViewInfo->pointLightAttenuation[2] = 0;
-    meshViewInfo->pointLightMaxRange = 0;
+    meshViewInfo->lightIndex = 0;
+    meshViewInfo->lightColor[0] = 0;
+    meshViewInfo->lightColor[1] = 0;
+    meshViewInfo->lightColor[2] = 0;
+    meshViewInfo->lightPosition[0] = 0;
+    meshViewInfo->lightPosition[1] = 0;
+    meshViewInfo->lightPosition[2] = 0;
+    meshViewInfo->lightWeight = 0;
+    meshViewInfo->lightAttenuation[0] = 1;
+    meshViewInfo->lightAttenuation[1] = 0;
+    meshViewInfo->lightAttenuation[2] = 0;
+    meshViewInfo->lightMaxRange = 0;
+    meshViewInfo->lightDir[0] = 1;
+    meshViewInfo->lightDir[1] = 0;
+    meshViewInfo->lightDir[2] = 0;
+    meshViewInfo->lightInnerAngle = 0;
+    meshViewInfo->lightOuterAngle = 0;
+    meshViewInfo->lightFalloff = 0;
 
     return ptr_to_jlong(meshViewInfo);
 }
@@ -2264,32 +2270,39 @@ JNIEXPORT void JNICALL Java_com_sun_prism_es2_GLContext_nSetAmbientLight
 
 /*
  * Class:     com_sun_prism_es2_GLContext
- * Method:    nSetPointLight
- * Signature: (JJIFFFFFFF)V
+ * Method:    nSetLight
+ * Signature: (JJIFFFFFFFFFFFFFFFFF)V
  */
-JNIEXPORT void JNICALL Java_com_sun_prism_es2_GLContext_nSetPointLight
+JNIEXPORT void JNICALL Java_com_sun_prism_es2_GLContext_nSetLight
   (JNIEnv *env, jclass class, jlong nativeCtxInfo, jlong nativeMeshViewInfo,
         jint index, jfloat x, jfloat y, jfloat z, jfloat r, jfloat g, jfloat b, jfloat w,
-        jfloat ca, jfloat la, jfloat qa, jfloat maxRange)
+        jfloat ca, jfloat la, jfloat qa, jfloat maxRange, jfloat dirX, jfloat dirY, jfloat dirZ,
+        jfloat innerAngle, jfloat outerAngle, jfloat falloff)
 {
     ContextInfo *ctxInfo = (ContextInfo *) jlong_to_ptr(nativeCtxInfo);
     MeshViewInfo *meshViewInfo = (MeshViewInfo *) jlong_to_ptr(nativeMeshViewInfo);
     // NOTE: We only support up to 3 point lights at the present
     if ((ctxInfo == NULL) || (meshViewInfo == NULL) || (index < 0) || (index > 2)) {
         return;
     }
-    meshViewInfo->pointLightIndex = index;
-    meshViewInfo->pointLightPosition[0] = x;
-    meshViewInfo->pointLightPosition[1] = y;
-    meshViewInfo->pointLightPosition[2] = z;
-    meshViewInfo->pointLightColor[0] = r;
-    meshViewInfo->pointLightColor[1] = g;
-    meshViewInfo->pointLightColor[2] = b;
-    meshViewInfo->pointLightWeight = w;
-    meshViewInfo->pointLightAttenuation[0] = ca;
-    meshViewInfo->pointLightAttenuation[1] = la;
-    meshViewInfo->pointLightAttenuation[2] = qa;
-    meshViewInfo->pointLightMaxRange = maxRange;
+    meshViewInfo->lightIndex = index;
+    meshViewInfo->lightPosition[0] = x;
+    meshViewInfo->lightPosition[1] = y;
+    meshViewInfo->lightPosition[2] = z;
+    meshViewInfo->lightColor[0] = r;
+    meshViewInfo->lightColor[1] = g;
+    meshViewInfo->lightColor[2] = b;
+    meshViewInfo->lightWeight = w;
+    meshViewInfo->lightAttenuation[0] = ca;
+    meshViewInfo->lightAttenuation[1] = la;
+    meshViewInfo->lightAttenuation[2] = qa;
+    meshViewInfo->lightMaxRange = maxRange;
+    meshViewInfo->lightDir[0] = dirX;
+    meshViewInfo->lightDir[1] = dirY;
+    meshViewInfo->lightDir[2] = dirZ;
+    meshViewInfo->lightInnerAngle = innerAngle;
+    meshViewInfo->lightOuterAngle = outerAngle;
+    meshViewInfo->lightFalloff = falloff;
 }
 
 /*

modules/javafx.graphics/src/main/native-prism-es2/GLContext.c

@@ -376,12 +376,16 @@ struct MeshViewInfoRec {
     MeshInfo *meshInfo;
     PhongMaterialInfo *phongMaterialInfo;
     GLfloat ambientLightColor[3];
-    GLuint pointLightIndex;
-    GLfloat pointLightWeight;
-    GLfloat pointLightPosition[3];
-    GLfloat pointLightColor[3];
-    GLfloat pointLightAttenuation[3];
-    GLfloat pointLightMaxRange;
+    GLuint lightIndex;
+    GLfloat lightColor[3];
+    GLfloat lightPosition[3];
+    GLfloat lightWeight;
+    GLfloat lightAttenuation[3];
+    GLfloat lightMaxRange;
+    GLfloat lightDir[3];
+    GLfloat lightInnerAngle;
+    GLfloat lightOuterAngle;
+    GLfloat lightFalloff;
     GLboolean cullEnable;
     GLenum cullMode;
     GLenum fillMode;

modules/javafx.graphics/src/main/native-prism-es2/PrismES2Defs.h

@@ -36,13 +36,18 @@ struct Light {
     vec4 pos;
     vec3 color;
     vec3 attn;
+    vec3 dir;
     float range;
+    float cosOuter;
+    float denom; // cosInner - cosOuter
+    float falloff;
 };
 
 //3 lights used
 uniform Light lights[3];
 
 varying vec4 lightTangentSpacePositions[3];
+varying vec4 lightTangentSpaceDirections[3];
 varying vec2 oTexCoords;
 varying vec3 eyePos;
 
@@ -97,6 +102,15 @@ void main()
     L = lights[2].pos.xyz - worldPos.xyz;
     lightTangentSpacePositions[2] = vec4( getLocalVector(L,tangentFrame)*lights[2].pos.w, 1.0);
 
+    vec3 D = lights[0].dir.xyz;
+    lightTangentSpaceDirections[0] = vec4( getLocalVector(D,tangentFrame), 1.0);
+
+    D = lights[1].dir.xyz;
+    lightTangentSpaceDirections[1] = vec4( getLocalVector(D,tangentFrame), 1.0);
+
+    D = lights[2].dir.xyz;
+    lightTangentSpaceDirections[2] = vec4( getLocalVector(D,tangentFrame), 1.0);
+
     mat4 mvpMatrix = viewProjectionMatrix * worldMatrix;
 
     //Send texcoords to Pixel Shader and calculate vertex position.

modules/javafx.graphics/src/main/resources/com/sun/prism/es2/glsl/main.vert

@@ -59,39 +59,99 @@ struct Light {
     vec4 pos;
     vec3 color;
     vec3 attn;
+    vec3 dir;
     float range;
+    float cosOuter;
+    float denom; // cosInner - cosOuter
+    float falloff;
 };
 
 uniform vec3 ambientColor;
 uniform Light lights[3];
 
 varying vec3 eyePos;
 varying vec4 lightTangentSpacePositions[3];
+varying vec4 lightTangentSpaceDirections[3];
+
+// Because pow(0, 0) is undefined (https://www.khronos.org/registry/OpenGL-Refpages/es3.0/html/pow.xhtml),
+// we need special treatment for falloff == 0 cases
+float computeSpotlightFactor(vec3 l, vec3 lightDir, float cosOuter, float denom, float falloff) {
+    if (falloff == 0.0 && cosOuter == -1.0) { // point light optimization (cosOuter == -1 is outerAngle == 180)
+        return 1.0;
+    }
+    float cosAngle = dot(normalize(-lightDir), l);
+    float cutoff = cosAngle - cosOuter;
+    if (falloff != 0.0) {
+        return pow(clamp(cutoff / denom, 0.0, 1.0), falloff);
+    }
+    return cutoff >= 0.0 ? 1.0 : 0.0;
+}
+
+/*
+ * The methods 'computeSpotlightFactor2' and 'computeSpotlightFactor3' are alternatives to the 'computeSpotlightFactor'
+ * method that was chosen for its better performance. They are kept for the case that a future changes will make them
+ * more performant.
+ *
+float computeSpotlightFactor2(vec3 l, vec3 lightDir, float cosOuter, float denom, float falloff) {
+    if (falloff != 0.0) {
+        float cosAngle = dot(normalize(-lightDir), l);
+        float cutoff = cosAngle - cosOuter;
+        return pow(clamp(cutoff / denom, 0.0, 1.0), falloff);
+    }
+    if (cosOuter == -1.0) {  // point light optimization (cosOuter == -1 is outerAngle == 180)
+        return 1.0;
+    }
+    float cosAngle = dot(normalize(-lightDir), l);
+    float cutoff = cosAngle - cosOuter;
+    return cutoff >= 0.0 ? 1.0 : 0.0;
+}
+
+float computeSpotlightFactor3(vec3 l, vec3 lightDir, float cosOuter, float denom, float falloff) {
+    float cosAngle = dot(normalize(-lightDir), l);
+    float cutoff = cosAngle - cosOuter;
+    if (falloff != 0.0) {
+        return pow(clamp(cutoff / denom, 0.0, 1.0), falloff);
+    }
+    return cutoff >= 0.0 ? 1.0 : 0.0;
+}
+*/
+
+void computeLight(int i, vec3 n, vec3 refl, float specPower, inout vec3 d, inout vec3 s) {
+    Light light = lights[i];
+    vec3 pos = lightTangentSpacePositions[i].xyz;
+    float dist = length(pos);
+    if (dist > light.range) {
+        return;
+    }
+    vec3 l = normalize(pos);
+
+    vec3 lightDir = lightTangentSpaceDirections[i].xyz;
+    float spotlightFactor = computeSpotlightFactor(l, lightDir, light.cosOuter, light.denom, light.falloff);
+
+    float invAttnFactor = light.attn.x + light.attn.y * dist + light.attn.z * dist * dist;
+
+    vec3 attenuatedColor = light.color.rgb * spotlightFactor / invAttnFactor;
+    d += clamp(dot(n,l), 0.0, 1.0) * attenuatedColor;
+    s += pow(clamp(dot(-refl, l), 0.0, 1.0), specPower) * attenuatedColor;
+}
 
 void main()
 {
     vec4 diffuse = apply_diffuse();
 
     if (diffuse.a == 0.0) discard;
 
+    vec3 n = apply_normal();
+    vec3 refl = reflect(normalize(eyePos), n);
+
     vec3 d = vec3(0.0);
     vec3 s = vec3(0.0);
 
     vec4 specular = apply_specular();
+    float power = specular.a;
 
-    float maxRange = lights[0].range;
-    float dist = length(lightTangentSpacePositions[0].xyz);
-    if (dist <= maxRange) {
-        vec3 n = apply_normal();
-        vec3 refl = reflect(normalize(eyePos), n);
-        vec3 l = normalize(lightTangentSpacePositions[0].xyz);
+    computeLight(0, n, refl, power, d, s);
 
-        float power = specular.a;
-
-        vec3 attenuatedColor = (lights[0].color).rgb / (lights[0].attn.x + lights[0].attn.y * dist + lights[0].attn.z * dist * dist);
-        d = clamp(dot(n, l), 0.0, 1.0) * attenuatedColor;
-        s = pow(clamp(dot(-refl, l), 0.0, 1.0), power) * attenuatedColor;
-    }
     vec3 rez = (ambientColor + d) * diffuse.xyz + s * specular.rgb;
     rez += apply_selfIllum().xyz;
 

modules/javafx.graphics/src/main/resources/com/sun/prism/es2/glsl/main1Light.frag

@@ -59,14 +59,81 @@ struct Light {
     vec4 pos;
     vec3 color;
     vec3 attn;
+    vec3 dir;
     float range;
+    float cosOuter;
+    float denom; // cosInner - cosOuter
+    float falloff;
 };
 
 uniform vec3 ambientColor;
 uniform Light lights[3];
 
 varying vec3 eyePos;
 varying vec4 lightTangentSpacePositions[3];
+varying vec4 lightTangentSpaceDirections[3];
+
+// Because pow(0, 0) is undefined (https://www.khronos.org/registry/OpenGL-Refpages/es3.0/html/pow.xhtml),
+// we need special treatment for falloff == 0 cases
+float computeSpotlightFactor(vec3 l, vec3 lightDir, float cosOuter, float denom, float falloff) {
+    if (falloff == 0.0 && cosOuter == -1.0) { // point light optimization (cosOuter == -1 is outerAngle == 180)
+        return 1.0;
+    }
+    float cosAngle = dot(normalize(-lightDir), l);
+    float cutoff = cosAngle - cosOuter;
+    if (falloff != 0.0) {
+        return pow(clamp(cutoff / denom, 0.0, 1.0), falloff);
+    }
+    return cutoff >= 0.0 ? 1.0 : 0.0;
+}
+
+/*
+ * The methods 'computeSpotlightFactor2' and 'computeSpotlightFactor3' are alternatives to the 'computeSpotlightFactor'
+ * method that was chosen for its better performance. They are kept for the case that a future changes will make them
+ * more performant.
+ *
+float computeSpotlightFactor2(vec3 l, vec3 lightDir, float cosOuter, float denom, float falloff) {
+    if (falloff != 0.0) {
+        float cosAngle = dot(normalize(-lightDir), l);
+        float cutoff = cosAngle - cosOuter;
+        return pow(clamp(cutoff / denom, 0.0, 1.0), falloff);
+    }
+    if (cosOuter == -1.0) {  // point light optimization (cosOuter == -1 is outerAngle == 180)
+        return 1.0;
+    }
+    float cosAngle = dot(normalize(-lightDir), l);
+    float cutoff = cosAngle - cosOuter;
+    return cutoff >= 0.0 ? 1.0 : 0.0;
+}
+
+float computeSpotlightFactor3(vec3 l, vec3 lightDir, float cosOuter, float denom, float falloff) {
+    float cosAngle = dot(normalize(-lightDir), l);
+    float cutoff = cosAngle - cosOuter;
+    if (falloff != 0.0) {
+        return pow(clamp(cutoff / denom, 0.0, 1.0), falloff);
+    }
+    return cutoff >= 0.0 ? 1.0 : 0.0;
+}
+*/
+
+void computeLight(int i, vec3 n, vec3 refl, float specPower, inout vec3 d, inout vec3 s) {
+    Light light = lights[i];
+    vec3 pos = lightTangentSpacePositions[i].xyz;
+    float dist = length(pos);
+    if (dist > light.range) {
+        return;
+    }
+    vec3 l = normalize(pos);
+
+    vec3 lightDir = lightTangentSpaceDirections[i].xyz;
+    float spotlightFactor = computeSpotlightFactor(l, lightDir, light.cosOuter, light.denom, light.falloff);
+
+    float invAttnFactor = light.attn.x + light.attn.y * dist + light.attn.z * dist * dist;
+
+    vec3 attenuatedColor = light.color.rgb * spotlightFactor / invAttnFactor;
+    d += clamp(dot(n,l), 0.0, 1.0) * attenuatedColor;
+    s += pow(clamp(dot(-refl, l), 0.0, 1.0), specPower) * attenuatedColor;
+}
 
 void main()
 {
@@ -83,23 +150,9 @@ void main()
     vec4 specular = apply_specular();
     float power = specular.a;
 
-    float maxRange = lights[0].range;
-    float dist = length(lightTangentSpacePositions[0].xyz);
-    if (dist <= maxRange) {
-        vec3 l = normalize(lightTangentSpacePositions[0].xyz);
-        vec3 attenuatedColor = (lights[0].color).rgb / (lights[0].attn.x + lights[0].attn.y * dist + lights[0].attn.z * dist * dist);
-        d += clamp(dot(n,l), 0.0, 1.0) * attenuatedColor;
-        s += pow(clamp(dot(-refl, l), 0.0, 1.0), power) * attenuatedColor;
-    }
+    computeLight(0, n, refl, power, d, s);
+    computeLight(1, n, refl, power, d, s);
 
-    maxRange = lights[1].range;
-    dist = length(lightTangentSpacePositions[1].xyz);
-    if (dist <= maxRange) {
-        vec3 l = normalize(lightTangentSpacePositions[1].xyz);
-        vec3 attenuatedColor = (lights[1].color).rgb / (lights[1].attn.x + lights[1].attn.y * dist + lights[1].attn.z * dist * dist);
-        d += clamp(dot(n,l), 0.0, 1.0) * attenuatedColor;
-        s += pow(clamp(dot(-refl, l), 0.0, 1.0), power) * attenuatedColor;
-    }
     vec3 rez = (ambientColor + d) * diffuse.xyz + s * specular.rgb;
     rez += apply_selfIllum().xyz;
 

modules/javafx.graphics/src/main/resources/com/sun/prism/es2/glsl/main2Lights.frag

@@ -59,14 +59,81 @@ struct Light {
     vec4 pos;
     vec3 color;
     vec3 attn;
+    vec3 dir;
     float range;
+    float cosOuter;
+    float denom; // cosInner - cosOuter
+    float falloff;
 };
 
 uniform vec3 ambientColor;
 uniform Light lights[3];
 
 varying vec3 eyePos;
 varying vec4 lightTangentSpacePositions[3];
+varying vec4 lightTangentSpaceDirections[3];
+
+// Because pow(0, 0) is undefined (https://www.khronos.org/registry/OpenGL-Refpages/es3.0/html/pow.xhtml),
+// we need special treatment for falloff == 0 cases
+float computeSpotlightFactor(vec3 l, vec3 lightDir, float cosOuter, float denom, float falloff) {
+    if (falloff == 0.0 && cosOuter == -1.0) { // point light optimization (cosOuter == -1 is outerAngle == 180)
+        return 1.0;
+    }
+    float cosAngle = dot(normalize(-lightDir), l);
+    float cutoff = cosAngle - cosOuter;
+    if (falloff != 0.0) {
+        return pow(clamp(cutoff / denom, 0.0, 1.0), falloff);
+    }
+    return cutoff >= 0.0 ? 1.0 : 0.0;
+}
+
+/*
+ * The methods 'computeSpotlightFactor2' and 'computeSpotlightFactor3' are alternatives to the 'computeSpotlightFactor'
+ * method that was chosen for its better performance. They are kept for the case that a future changes will make them
+ * more performant.
+ *
+float computeSpotlightFactor2(vec3 l, vec3 lightDir, float cosOuter, float denom, float falloff) {
+    if (falloff != 0.0) {
+        float cosAngle = dot(normalize(-lightDir), l);
+        float cutoff = cosAngle - cosOuter;
+        return pow(clamp(cutoff / denom, 0.0, 1.0), falloff);
+    }
+    if (cosOuter == -1.0) {  // point light optimization (cosOuter == -1 is outerAngle == 180)
+        return 1.0;
+    }
+    float cosAngle = dot(normalize(-lightDir), l);
+    float cutoff = cosAngle - cosOuter;
+    return cutoff >= 0.0 ? 1.0 : 0.0;
+}
+
+float computeSpotlightFactor3(vec3 l, vec3 lightDir, float cosOuter, float denom, float falloff) {
+    float cosAngle = dot(normalize(-lightDir), l);
+    float cutoff = cosAngle - cosOuter;
+    if (falloff != 0.0) {
+        return pow(clamp(cutoff / denom, 0.0, 1.0), falloff);
+    }
+    return cutoff >= 0.0 ? 1.0 : 0.0;
+}
+*/
+
+void computeLight(int i, vec3 n, vec3 refl, float specPower, inout vec3 d, inout vec3 s) {
+    Light light = lights[i];
+    vec3 pos = lightTangentSpacePositions[i].xyz;
+    float dist = length(pos);
+    if (dist > light.range) {
+        return;
+    }
+    vec3 l = normalize(pos);
+
+    vec3 lightDir = lightTangentSpaceDirections[i].xyz;
+    float spotlightFactor = computeSpotlightFactor(l, lightDir, light.cosOuter, light.denom, light.falloff);
+
+    float invAttnFactor = light.attn.x + light.attn.y * dist + light.attn.z * dist * dist;
+
+    vec3 attenuatedColor = light.color.rgb * spotlightFactor / invAttnFactor;
+    d += clamp(dot(n,l), 0.0, 1.0) * attenuatedColor;
+    s += pow(clamp(dot(-refl, l), 0.0, 1.0), specPower) * attenuatedColor;
+}
 
 void main()
 {
@@ -83,32 +150,9 @@ void main()
     vec4 specular = apply_specular();
     float power = specular.a;
 
-    float maxRange = lights[0].range;
-    float dist = length(lightTangentSpacePositions[0].xyz);
-    if (dist <= maxRange) {
-        vec3 l = normalize(lightTangentSpacePositions[0].xyz);
-        vec3 attenuatedColor = (lights[0].color).rgb / (lights[0].attn.x + lights[0].attn.y * dist + lights[0].attn.z * dist * dist);
-        d += clamp(dot(n,l), 0.0, 1.0) * attenuatedColor;
-        s += pow(clamp(dot(-refl, l), 0.0, 1.0), power) * attenuatedColor;
-    }
-
-    maxRange = lights[1].range;
-    dist = length(lightTangentSpacePositions[1].xyz);
-    if (dist <= maxRange) {
-        vec3 l = normalize(lightTangentSpacePositions[1].xyz);
-        vec3 attenuatedColor = (lights[1].color).rgb / (lights[1].attn.x + lights[1].attn.y * dist + lights[1].attn.z * dist * dist);
-        d += clamp(dot(n,l), 0.0, 1.0) * attenuatedColor;
-        s += pow(clamp(dot(-refl, l), 0.0, 1.0), power) * attenuatedColor;
-    }
-
-    maxRange = lights[2].range;
-    dist = length(lightTangentSpacePositions[2].xyz);
-    if (dist <= maxRange) {
-        vec3 l = normalize(lightTangentSpacePositions[2].xyz);
-        vec3 attenuatedColor = (lights[2].color).rgb / (lights[2].attn.x + lights[2].attn.y * dist + lights[2].attn.z * dist * dist);
-        d += clamp(dot(n,l), 0.0, 1.0) * attenuatedColor;
-        s += pow(clamp(dot(-refl, l), 0.0, 1.0), power) * attenuatedColor;
-    }
+    computeLight(0, n, refl, power, d, s);
+    computeLight(1, n, refl, power, d, s);
+    computeLight(2, n, refl, power, d, s);
 
     vec3 rez = (ambientColor + d) * diffuse.xyz + s * specular.rgb;
     rez += apply_selfIllum().xyz;

modules/javafx.graphics/src/main/resources/com/sun/prism/es2/glsl/main3Lights.frag

@@ -25,13 +25,17 @@
 
 package attenuation;
 
+import javafx.beans.binding.Bindings;
 import javafx.beans.property.DoubleProperty;
+import javafx.geometry.Point3D;
 import javafx.scene.PointLight;
+import javafx.scene.SpotLight;
 import javafx.scene.control.Label;
 import javafx.scene.control.Slider;
 import javafx.scene.control.TextField;
 import javafx.scene.layout.HBox;
 import javafx.scene.layout.VBox;
+import javafx.scene.transform.Rotate;
 import javafx.util.converter.NumberStringConverter;
 
 /**
@@ -40,25 +44,68 @@
 public class AttenLightingSample extends LightingSample {
 
     @Override
-    protected VBox addLightControls(PointLight light) {
+    protected VBox addPointLightControls(PointLight light) {
         var vbox = super.addLightControls(light);
-        var range = createSliderControl("range", light.maxRangeProperty(), 0, 100, light.getMaxRange());
+        var range = createSliderControl("range", light.maxRangeProperty(), 0, 500, 150);
         var c = createSliderControl("constant", light.constantAttenuationProperty(), -1, 1, light.getConstantAttenuation());
-        var lc = createSliderControl("linear", light.linearAttenuationProperty(), -1, 1, light.getLinearAttenuation());
-        var qc = createSliderControl("quadratic", light.quadraticAttenuationProperty(), -1, 1, light.getQuadraticAttenuation());
+        var lc = createSliderControl("linear", light.linearAttenuationProperty(), -0.1, 0.1, light.getLinearAttenuation());
+        var qc = createSliderControl("quadratic", light.quadraticAttenuationProperty(), -0.01, 0.01, light.getQuadraticAttenuation());
         vbox.getChildren().addAll(range, c, lc, qc);
         return vbox;
     }
 
+    @Override
+    protected VBox addSpotLightControls(SpotLight light) {
+        var vbox = addPointLightControls(light);
+        var ia = createSliderControl("inner", light.innerAngleProperty(), 0, 180, light.getInnerAngle());
+        var oa = createSliderControl("outer", light.outerAngleProperty(), 0, 180, light.getOuterAngle());
+        var fo = createSliderControl("falloff", light.falloffProperty(), -5, 5, light.getFalloff());
+
+        var transX = new Rotate(0, Rotate.X_AXIS);
+        var transY = new Rotate(0, Rotate.Y_AXIS);
+        var transZ = new Rotate(0, Rotate.Z_AXIS);
+        light.getTransforms().addAll(transX, transY, transZ);
+        var rotX = createSliderControl("rot x", transX.angleProperty(), -180, 180, 0);
+        var rotY = createSliderControl("rot y", transY.angleProperty(), -180, 180, 0);
+        var rotZ = createSliderControl("rot z", transZ.angleProperty(), -180, 180, 0);
+
+        var sliderX = createSlider(-5, 5, light.getDirection().getX());
+        var sliderY = createSlider(-5, 5, light.getDirection().getY());
+        var sliderZ = createSlider(-5, 5, light.getDirection().getZ());
+        light.directionProperty().bind(Bindings.createObjectBinding(() ->
+            new Point3D(sliderX.getValue(), sliderY.getValue(), sliderZ.getValue()),
+            sliderX.valueProperty(), sliderY.valueProperty(), sliderZ.valueProperty()));
+        var dirX = createSliderControl("dir x", sliderX);
+        var dirY = createSliderControl("dir y", sliderY);
+        var dirZ = createSliderControl("dir z", sliderZ);
+
+        vbox.getChildren().addAll(ia, oa, fo, rotX, rotY, rotZ, dirX, dirY, dirZ);
+        return vbox;
+    }
+
     private HBox createSliderControl(String name, DoubleProperty property, double min, double max, double start) {
-        var slider = new Slider(min, max, start);
-        slider.setShowTickMarks(true);
-        slider.setShowTickLabels(true);
-        property.bindBidirectional(slider.valueProperty());
+        var slider = createSlider(min, max, start);
+        property.bind(slider.valueProperty());
+        return createSliderControl(name, slider);
+    }
+
+    private HBox createSliderControl(String name, Slider slider) {
+        var tf = createTextField(slider);
+        return new HBox(5, new Label(name), slider, tf);
+    }
+
+    private TextField createTextField(Slider slider) {
         var tf = new TextField();
         tf.textProperty().bindBidirectional(slider.valueProperty(), new NumberStringConverter());
         tf.setMaxWidth(50);
-        return new HBox(5, new Label(name), slider, tf);
+        return tf;
+    }
+
+    private Slider createSlider(double min, double max, double start) {
+        var slider = new Slider(min, max, start);
+        slider.setShowTickMarks(true);
+        slider.setShowTickLabels(true);
+        return slider;
     }
 
     public static void main(String[] args) {

tests/performance/3DLighting/attenuation/AttenLightingSample.java

@@ -43,14 +43,15 @@
 class CameraScene3D extends Pane {
 
     public DoubleProperty xPan = new SimpleDoubleProperty();
-    public DoubleProperty yPan = new SimpleDoubleProperty(-10);
+    public DoubleProperty yPan = new SimpleDoubleProperty();
     public DoubleProperty zoom = new SimpleDoubleProperty();
     public DoubleProperty zAngle = new SimpleDoubleProperty();
     public DoubleProperty isometricAngle = new SimpleDoubleProperty();
 
     public DoubleProperty panSensitivity = new SimpleDoubleProperty(1);
     public DoubleProperty zoomSensitivity = new SimpleDoubleProperty(1);
     public DoubleProperty zRotationSensitivity = new SimpleDoubleProperty(1);
+    public DoubleProperty isoRotationSensitivity = new SimpleDoubleProperty(1);
     public BooleanProperty isZoomTotal = new SimpleBooleanProperty();
 
     protected PerspectiveCamera camera = new PerspectiveCamera(true);
@@ -144,6 +145,8 @@ private final void setUIBindings() {
                 deltaX = positiveY ? -deltaX : deltaX;
                 deltaY = positiveX ? deltaY : -deltaY;
                 rotate((deltaX + deltaY)/2);
+            } else if (e.getButton() == MouseButton.MIDDLE) {
+                swivle(deltaY);
             }
         });
     }
@@ -170,4 +173,8 @@ private void zoom(double amount) {
     private void rotate(double amount) {
         zAngle.set(zAngle.get() - amount * zRotationSensitivity.get());
     }
+
+    private void swivle(double amount) {
+        isometricAngle.set(isometricAngle.get() - amount * isoRotationSensitivity.get());
+    }
 }

tests/performance/3DLighting/attenuation/CameraScene3D.java

@@ -29,22 +29,33 @@
 import java.util.List;
 
 import javafx.scene.AmbientLight;
+import javafx.scene.Group;
+import javafx.scene.LightBase;
+import javafx.scene.Node;
 import javafx.scene.PointLight;
+import javafx.scene.SpotLight;
 import javafx.scene.paint.Color;
 import javafx.scene.paint.PhongMaterial;
+import javafx.scene.shape.Box;
 import javafx.scene.shape.MeshView;
-import javafx.scene.shape.Shape3D;
 import javafx.scene.shape.Sphere;
 import javafx.scene.shape.TriangleMesh;
+import javafx.scene.transform.Rotate;
 
 class Environment extends CameraScene3D {
 
-    private final PointLight light1 = new PointLight(Color.RED);
-    private final PointLight light2 = new PointLight(Color.BLUE);
-    private final PointLight light3 = new PointLight(Color.MAGENTA);
-    final PointLight[] lights = {light1, light2, light3};
+    private final static double LIGHT_Z_DIST = 50;
+    private final static double LIGHT_X_DIST = 50;
 
-    private Shape3D currentShape;
+    private final PointLight pointLight1 = new PointLight(Color.RED);
+    private final PointLight pointLight2 = new PointLight(Color.BLUE);
+    private final PointLight pointLight3 = new PointLight(Color.MAGENTA);
+    private final SpotLight spotLight1 = new SpotLight(Color.RED);
+    private final SpotLight spotLight2 = new SpotLight(Color.BLUE);
+    private final SpotLight spotLight3 = new SpotLight(Color.MAGENTA);
+    final LightBase[] lights = {pointLight1, pointLight2, pointLight3, spotLight1, spotLight2, spotLight3};
+
+    private Node currentShape;
 
     private final AmbientLight worldLight = new AmbientLight();
 
@@ -53,24 +64,44 @@ class Environment extends CameraScene3D {
         zoom.set(-350);
 
         for (var light : lights) {
-            light.setTranslateZ(-50);
+            light.setTranslateZ(-LIGHT_Z_DIST);
             var lightRep = new Sphere(2);
             lightRep.setMaterial(new PhongMaterial(light.getColor()));
             lightRep.translateXProperty().bind(light.translateXProperty());
             lightRep.translateYProperty().bind(light.translateYProperty());
             lightRep.translateZProperty().bind(light.translateZProperty());
-            rootGroup.getChildren().addAll(light, lightRep);
+            rootGroup.getChildren().addAll(light , lightRep);
         }
-        light1.setTranslateX(40);
-        light2.setTranslateX(-40);
-        light1.setUserData("RED");
-        light2.setUserData("BLUE");
-        light3.setUserData("MAGENTA");
+
+        pointLight1.setTranslateX(LIGHT_X_DIST);
+        spotLight1.setTranslateX(LIGHT_X_DIST);
+        pointLight2.setTranslateX(-LIGHT_X_DIST);
+        spotLight2.setTranslateX(-LIGHT_X_DIST);
+
+        pointLight1.setUserData("RED");
+        pointLight2.setUserData("BLUE");
+        pointLight3.setUserData("MAGENTA");
+        spotLight1.setUserData("RED");
+        spotLight2.setUserData("BLUE");
+        spotLight3.setUserData("MAGENTA");
 
         rootGroup.getChildren().add(worldLight);
         rootGroup.setMouseTransparent(true);
     }
 
+    Group createBoxes() {
+        var front = new Box(200, 200, 1);
+        var back = new Box(200, 200, 1);
+        var side = new Box(200, 200, 1);
+        side.setRotationAxis(Rotate.Y_AXIS);
+        side.setRotate(90);
+        side.setTranslateX(LIGHT_Z_DIST * 2);
+        side.setTranslateZ(-LIGHT_Z_DIST);
+        front.setTranslateZ(LIGHT_Z_DIST);
+        back.setTranslateZ(-LIGHT_Z_DIST * 3);
+        return new Group(front, back, side);
+    }
+
     Sphere createSphere(int subdivisions) {
         return new Sphere(50, subdivisions);
     }
@@ -112,7 +143,7 @@ MeshView createMeshView(int quadNum) {
         return mv;
     }
 
-    void switchTo(Shape3D node) {
+    void switchTo(Node node) {
         worldLight.getExclusionScope().remove(currentShape);
         worldLight.getExclusionScope().add(node);
         rootGroup.getChildren().remove(currentShape);

tests/performance/3DLighting/attenuation/Environment.java

@@ -58,8 +58,8 @@ public void handle(long now) {
         totalElapsedTime += currTime - lastTime;
         totalElapsedFrames += 1;
 
-        double elapsedSeconds = (double) elapsedTime / 1e9;
-        double totalElapsedSeconds = (double) totalElapsedTime / 1e9;
+        double elapsedSeconds = elapsedTime / 1e9;
+        double totalElapsedSeconds = totalElapsedTime / 1e9;
         if (elapsedSeconds >= 5.0) {
             double fps = elapsedFrames / elapsedSeconds;
             System.out.println();

tests/performance/3DLighting/attenuation/FPSCounter.java

@@ -28,17 +28,25 @@
 import javafx.animation.Animation;
 import javafx.animation.TranslateTransition;
 import javafx.application.Application;
+import javafx.beans.binding.When;
+import javafx.scene.Group;
+import javafx.scene.LightBase;
+import javafx.scene.Node;
 import javafx.scene.PointLight;
 import javafx.scene.Scene;
+import javafx.scene.SpotLight;
 import javafx.scene.control.Button;
 import javafx.scene.control.CheckBox;
 import javafx.scene.control.Label;
-import javafx.scene.control.Separator;
+import javafx.scene.control.ScrollPane;
 import javafx.scene.control.Slider;
+import javafx.scene.control.TitledPane;
 import javafx.scene.layout.HBox;
 import javafx.scene.layout.Priority;
 import javafx.scene.layout.VBox;
-import javafx.scene.shape.Shape3D;
+import javafx.scene.paint.Color;
+import javafx.scene.paint.PhongMaterial;
+import javafx.scene.shape.Box;
 import javafx.stage.Stage;
 import javafx.util.Duration;
 import javafx.util.converter.NumberStringConverter;
@@ -59,18 +67,38 @@ public class LightingSample extends Application {
     public void start(Stage stage) throws Exception {
         environment.setStyle("-fx-background-color: teal");
 
-        var subdivisionSlider = new Slider(10, 200, 60);
-        subdivisionSlider.setMajorTickUnit(10);
-        setupSlier(subdivisionSlider);
+        var sphereControls = createSphereControls();
+        var meshControls = createMeshControls();
+        var boxesControls = createBoxesControls();
 
-        var subdivisionLabel = new Label();
-        subdivisionLabel.textProperty().bindBidirectional(subdivisionSlider.valueProperty(), new NumberStringConverter("#"));
+        var playButton = new Button("Start");
+        playButton.setOnAction(e -> startMeasurement());
 
-        var sphere = new Button("Sphere");
-        sphere.setOnAction(e -> switchTo(environment.createSphere((int) subdivisionSlider.getValue())));
+        var stopButton = new Button("Stop");
+        stopButton.setOnAction(e -> stopMeasurement());
+
+        var controls = new VBox(3, sphereControls, meshControls, boxesControls, new HBox(5, playButton, stopButton));
+        for (var light : environment.lights) {
+            VBox vBox = null;
+            if (light instanceof SpotLight) {
+                vBox = addSpotLightControls((SpotLight) light);
+            } else if (light instanceof PointLight) {
+                vBox = addPointLightControls((PointLight) light);
+            }
+            controls.getChildren().add(new TitledPane(light.getUserData() + " " + light.getClass().getSimpleName(), vBox));
+        }
 
-        var quadSlider = new Slider(500, 10_000, 1000);
-        quadSlider.setMajorTickUnit(500);
+        var hBox = new HBox(new ScrollPane(controls), environment);
+        HBox.setHgrow(environment, Priority.ALWAYS);
+        stage.setScene(new Scene(hBox));
+        stage.setWidth(1100);
+        stage.setHeight(735);
+        stage.show();
+    }
+
+    private HBox createMeshControls() {
+        var quadSlider = new Slider(100, 5000, 1000);
+        quadSlider.setMajorTickUnit(100);
         setupSlier(quadSlider);
 
         var quadLabel = new Label();
@@ -79,20 +107,37 @@ public void start(Stage stage) throws Exception {
         var mesh = new Button("Mesh");
         mesh.setOnAction(e -> switchTo(environment.createMeshView((int) quadSlider.getValue())));
 
-        var sphereBox = new HBox(sphere, subdivisionSlider, subdivisionLabel);
         var meshBox = new HBox(mesh, quadSlider, quadLabel);
+        return meshBox;
+    }
 
-        var controls = new VBox(sphereBox, meshBox);
-        for (var light : environment.lights) {
-            controls.getChildren().add(addLightControls(light));
-        }
+    private HBox createSphereControls() {
+        var subdivisionSlider = new Slider(10, 1000, 60);
+        subdivisionSlider.setMajorTickUnit(50);
+        setupSlier(subdivisionSlider);
 
-        var hBox = new HBox(controls, environment);
-        HBox.setHgrow(environment, Priority.ALWAYS);
-        stage.setScene(new Scene(hBox));
-        stage.setWidth(1100);
-        stage.setHeight(735);
-        stage.show();
+        var subdivisionLabel = new Label();
+        subdivisionLabel.textProperty().bindBidirectional(subdivisionSlider.valueProperty(), new NumberStringConverter("#"));
+
+        var sphere = new Button("Sphere");
+        sphere.setOnAction(e -> switchTo(environment.createSphere((int) subdivisionSlider.getValue())));
+
+        var sphereBox = new HBox(sphere, subdivisionSlider, subdivisionLabel);
+        return sphereBox;
+    }
+
+    private HBox createBoxesControls() {
+        var box = new Button("Boxes (static)");
+        var specular = new CheckBox("Specular");
+        var specularBinding = new When(specular.selectedProperty()).then(Color.WHITE).otherwise(Color.BLACK);
+        var mat = new PhongMaterial(Color.WHITE);
+        mat.specularColorProperty().bind(specularBinding);
+        box.setOnAction(e -> {
+            Group boxes = environment.createBoxes();
+            boxes.getChildren().forEach(n -> ((Box) n).setMaterial(mat));
+            switchTo(boxes);
+        });
+        return new HBox(5, box, specular);
     }
 
     private void setupSlier(Slider slider) {
@@ -102,11 +147,18 @@ private void setupSlier(Slider slider) {
         slider.setSnapToTicks(true);
     }
 
-    protected VBox addLightControls(PointLight light) {
+    protected VBox addPointLightControls(PointLight light) {
+        return addLightControls(light);
+    }
+
+    protected VBox addSpotLightControls(SpotLight light) {
+        return addLightControls(light);
+    }
+
+    protected VBox addLightControls(LightBase light) {
         var lightOn = new CheckBox("On/Off");
-        lightOn.setSelected(true);
         light.lightOnProperty().bind(lightOn.selectedProperty());
-        return new VBox(new Separator(), new Label(light.getUserData() + " light"), lightOn);
+        return new VBox(lightOn);
     }
 
    private TranslateTransition createAnimation() {
@@ -118,15 +170,23 @@ private TranslateTransition createAnimation() {
         return anim;
     }
 
-    private void switchTo(Shape3D node) {
-        fpsCouner.stop();
-        fpsCouner.reset();
+    private void switchTo(Node node) {
+        stopMeasurement();
         environment.switchTo(node);
         animation.setNode(node);
+    }
+
+    private void startMeasurement() {
         animation.playFromStart();
         fpsCouner.start();
     }
 
+    private void stopMeasurement() {
+        fpsCouner.stop();
+        fpsCouner.reset();
+        animation.stop();
+    }
+
     public static void main(String[] args) {
         launch(args);
     }

tests/performance/3DLighting/attenuation/LightingSample.java

@@ -0,0 +1,101 @@
+/*
+ * Copyright (c) 2021, 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.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * 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.
+ */
+
+package test.javafx.scene.lighting3D;
+
+import java.util.concurrent.CountDownLatch;
+
+import org.junit.AfterClass;
+
+import javafx.application.Application;
+import javafx.application.Platform;
+import javafx.scene.Group;
+import javafx.scene.LightBase;
+import javafx.scene.Scene;
+import javafx.scene.image.WritableImage;
+import javafx.scene.shape.Box;
+import javafx.stage.Stage;
+import javafx.stage.WindowEvent;
+
+// Since there appears to be a bug in snapshot with subscene, we are taking a snapshot of the scene and not
+// the box, so the center of the box will be at the top left, (0, 0), of the image, and the light is
+// straight in front. Without attenuation, at (0, 0) it will give its full color.
+//
+//       x
+//  -----------
+//  |         /
+//  |        /     d - the distance of the light from the object
+//  |       /      x - the horizontal distance of the sample point on the object
+//  |      /       a - the angle to the sample point
+// d|     /
+//  |    /         tan(a) = x/d
+//  |   /          cos(a) = cos(atan(x/d)) = 1 / sqrt((x/d)^2 + 1)
+//  |a /
+//  | /
+//  |/
+//
+public abstract class LightingTest {
+
+    // 1d/255 is the smallest color resolution, but we use 10d/255 to avoid precision problems
+    protected static final double DELTA = 10d/255;
+    protected static final String FAIL_MESSAGE = "Wrong color value";
+
+    protected static final int LIGHT_DIST = 60;
+
+    protected static LightBase light;
+
+    private static final Box BOX = new Box(150, 150, 1);
+
+    protected static CountDownLatch startupLatch;
+    private static Stage stage;
+
+    public static class TestApp extends Application {
+
+        @Override
+        public void start(Stage mainStage) {
+            stage = mainStage;
+            light.setTranslateZ(-LIGHT_DIST);
+            stage.setScene(new Scene(new Group(light, BOX)));
+            stage.addEventHandler(WindowEvent.WINDOW_SHOWN, e -> Platform.runLater(startupLatch::countDown));
+            stage.show();
+        }
+    }
+
+    protected WritableImage snapshot() {
+        return BOX.getScene().snapshot(null);
+    }
+
+    protected double calculateLambertTerm(double x) {
+        return Math.cos(Math.atan(x/LIGHT_DIST));
+    }
+
+    @AfterClass
+    public static void teardown() {
+        Platform.runLater(() -> {
+            stage.hide();
+            Platform.exit();
+        });
+    }
+}

tests/system/src/test/java/test/javafx/scene/lighting3D/LightingTest.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2020, 2021, 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
@@ -25,41 +25,33 @@
 
 package test.javafx.scene.lighting3D;
 
+import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertTrue;
 import static org.junit.Assume.assumeTrue;
-import static org.junit.Assert.assertEquals;
 
 import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.TimeUnit;
 
-import org.junit.AfterClass;
 import org.junit.Before;
 import org.junit.BeforeClass;
 import org.junit.Test;
 
 import javafx.application.Application;
 import javafx.application.ConditionalFeature;
 import javafx.application.Platform;
-import javafx.scene.Group;
 import javafx.scene.PointLight;
-import javafx.scene.Scene;
 import javafx.scene.paint.Color;
-import javafx.scene.shape.Box;
-import javafx.stage.Stage;
-import javafx.stage.WindowEvent;
 import test.util.Util;
 
-public class PointLightAttenuationTest {
+public class PointLightAttenuationTest extends LightingTest {
+
+    // X coordinates for the point used in Lambert tests
+    private static final int[] LAMBERT_SAMPLE_DISTS = new int[] {0, 30, 60};
 
-    // 1d/255 is the smallest color resolution, but we use 10d/255 to avoid precision problems
-    private static final double DELTA = 10d/255;
-    private static final int LIGTH_DIST = 60;
-    private static final int SAMPLE_DIST = 60;
+    // X coordinate for the point used in attenuation tests
+    private static final int ATTN_SAMPLE_DIST = LIGHT_DIST;
 
-    private static CountDownLatch startupLatch;
-    private static Stage stage;
-    private static PointLight light = new PointLight(Color.BLUE);
-    private static Box box = new Box(150, 150, 1);
+    private static final PointLight LIGHT = new PointLight(Color.BLUE);
 
     public static void main(String[] args) throws Exception {
         initFX();
@@ -68,78 +60,76 @@ public static void main(String[] args) throws Exception {
     @BeforeClass
     public static void initFX() throws Exception {
         startupLatch = new CountDownLatch(1);
-        new Thread(() -> Application.launch(TestApp.class, (String[])null)).start();
+        LightingTest.light = LIGHT;
+        new Thread(() -> Application.launch(TestApp.class, (String[]) null)).start();
         assertTrue("Timeout waiting for FX runtime to start", startupLatch.await(15, TimeUnit.SECONDS));
     }
 
     @Before
     public void setupEach() {
         assumeTrue(Platform.isSupported(ConditionalFeature.SCENE3D));
+        LIGHT.setLinearAttenuation(0);
+        LIGHT.setQuadraticAttenuation(0);
+        LIGHT.setMaxRange(Double.POSITIVE_INFINITY);
     }
 
-    public static class TestApp extends Application {
-
-        @Override
-        public void start(Stage mainStage) {
-            stage = mainStage;
-            light.setTranslateZ(-LIGTH_DIST);
-            var root = new Group(light, box);
-            var scene = new Scene(root);
-            stage.setScene(scene);
-            stage.addEventHandler(WindowEvent.WINDOW_SHOWN, e -> Platform.runLater(startupLatch::countDown));
-            stage.show();
-        }
+    // The Lambert term is dot(N,L) = cos(a)
+    @Test
+    public void testLambert() {
+        Util.runAndWait(() -> {
+            var snapshot = snapshot();
+            for (int x : LAMBERT_SAMPLE_DISTS) {
+                double sampledBlue = snapshot.getPixelReader().getColor(x, 0).getBlue();
+                assertEquals(FAIL_MESSAGE + " for " + x, calculateLambertTerm(x), sampledBlue, DELTA);
+            }
+        });
     }
 
     @Test
     public void testAttenuation() {
         Util.runAndWait(() -> {
-            // Since there appears to be a bug in snapshot with subscene, we are taking a snapshot of the scene and not
-            // the box, so the center of the box will be at the top left, (0, 0), of the image, and the light is
-            // straight in front. Without attenuation, at (0, 0) it will give its full color. At (SAMPLE_DIST, 0) and
-            // LIGTH_DIST == SAMPLE_DIST, it will give cos(45) = 1/sqrt(2) of its color.
-            var snapshot = box.getScene().snapshot(null);
-            double nonAttenBlueCenter = snapshot.getPixelReader().getColor(0, 0).getBlue();
-            double nonAttenBlueDiag = snapshot.getPixelReader().getColor(SAMPLE_DIST, 0).getBlue();
-            assertEquals("Wrong color value", 1, nonAttenBlueCenter, DELTA);
-            assertEquals("Wrong color value", 1/Math.sqrt(2), nonAttenBlueDiag, DELTA);
-
-            double diagDist = Math.sqrt(LIGTH_DIST * LIGTH_DIST + SAMPLE_DIST * SAMPLE_DIST);
-
-            light.setLinearAttenuation(0.01);
-            double attnCenter = 1 / (1 + 0.01 * LIGTH_DIST);
-            double attnDiag = 1 / (1 + 0.01 * diagDist);
-            snapshot = box.getScene().snapshot(null);
-            double attenBlueCenter = snapshot.getPixelReader().getColor(0, 0).getBlue();
-            double attenBlueDiag = snapshot.getPixelReader().getColor(SAMPLE_DIST, 0).getBlue();
-            assertEquals("Wrong color value", nonAttenBlueCenter * attnCenter, attenBlueCenter, DELTA);
-            assertEquals("Wrong color value", nonAttenBlueDiag * attnDiag, attenBlueDiag, DELTA);
-
-            light.setLinearAttenuation(0);
-            light.setQuadraticAttenuation(0.01);
-            attnCenter = 1 / (1 + 0.01 * LIGTH_DIST * LIGTH_DIST);
-            attnDiag = 1 / (1 + 0.01 * diagDist * diagDist);
-            snapshot = box.getScene().snapshot(null);
-            attenBlueCenter = snapshot.getPixelReader().getColor(0, 0).getBlue();
-            attenBlueDiag = snapshot.getPixelReader().getColor(SAMPLE_DIST, 0).getBlue();
-            assertEquals("Wrong color value", nonAttenBlueCenter * attnCenter, attenBlueCenter, DELTA);
-            assertEquals("Wrong color value", nonAttenBlueDiag * attnDiag, attenBlueDiag, DELTA);
-
-            light.setQuadraticAttenuation(0);
-            light.setMaxRange((LIGTH_DIST + diagDist) / 2);
-            snapshot = box.getScene().snapshot(null);
-            nonAttenBlueCenter = snapshot.getPixelReader().getColor(0, 0).getBlue();
-            nonAttenBlueDiag = snapshot.getPixelReader().getColor(SAMPLE_DIST, 0).getBlue();
-            assertEquals("Wrong color value, should be in range", 1, nonAttenBlueCenter, DELTA);
-            assertEquals("Wrong color value, should be out of range", 0, nonAttenBlueDiag, DELTA);
+            double diagDist = Math.sqrt(LIGHT_DIST * LIGHT_DIST + ATTN_SAMPLE_DIST * ATTN_SAMPLE_DIST);
+            double lambertCenter = calculateLambertTerm(0);
+            double lambertSample = calculateLambertTerm(ATTN_SAMPLE_DIST);
+
+            LIGHT.setLinearAttenuation(0.01);
+            doAttenuationTest(diagDist, lambertCenter, lambertSample);
+
+            LIGHT.setLinearAttenuation(0);
+            LIGHT.setQuadraticAttenuation(0.01);
+            doAttenuationTest(diagDist, lambertCenter, lambertSample);
         });
     }
 
-    @AfterClass
-    public static void teardown() {
-        Platform.runLater(() -> {
-            stage.hide();
-            Platform.exit();
+    private void doAttenuationTest(double diagDist, double lambertCenter, double lambertSample) {
+        var snapshot = snapshot();
+
+        var attn = calculateAttenuationFactor(LIGHT_DIST);
+        var sampledBlue = snapshot.getPixelReader().getColor(0, 0).getBlue();
+        assertEquals(FAIL_MESSAGE, lambertCenter * attn, sampledBlue, DELTA);
+
+        attn = calculateAttenuationFactor(diagDist);
+        sampledBlue = snapshot.getPixelReader().getColor(ATTN_SAMPLE_DIST, 0).getBlue();
+        assertEquals(FAIL_MESSAGE, lambertSample * attn, sampledBlue, DELTA);
+    }
+
+    @Test
+    public void testRange() {
+        Util.runAndWait(() -> {
+            double diagDist = Math.sqrt(LIGHT_DIST * LIGHT_DIST + ATTN_SAMPLE_DIST * ATTN_SAMPLE_DIST);
+            LIGHT.setMaxRange((LIGHT_DIST + diagDist) / 2);
+            var snapshot = snapshot();
+
+            double sampledBlue = snapshot.getPixelReader().getColor(0, 0).getBlue();
+            assertEquals(FAIL_MESSAGE + ", should be in range", 1, sampledBlue, DELTA);
+
+            sampledBlue = snapshot.getPixelReader().getColor(ATTN_SAMPLE_DIST, 0).getBlue();
+            assertEquals(FAIL_MESSAGE + ", should be out of range", 0, sampledBlue, DELTA);
         });
     }
+
+    private double calculateAttenuationFactor(double dist) {
+        return 1 / (LIGHT.getConstantAttenuation() + LIGHT.getLinearAttenuation() * dist
+                      + LIGHT.getQuadraticAttenuation() * dist * dist);
+    }
 }

tests/system/src/test/java/test/javafx/scene/lighting3D/PointLightAttenuationTest.java

@@ -0,0 +1,117 @@
+/*
+ * Copyright (c) 2021, 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.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * 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.
+ */
+
+package test.javafx.scene.lighting3D;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assume.assumeTrue;
+
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
+
+import org.junit.Before;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import javafx.application.Application;
+import javafx.application.ConditionalFeature;
+import javafx.application.Platform;
+import javafx.scene.SpotLight;
+import javafx.scene.paint.Color;
+import test.util.Util;
+
+public class SpotLightAttenuationTest extends LightingTest {
+
+    // Angles for points used in spotlight factor tests
+    private static final double INNER_ANGLE = 20;
+    private static final double OUTER_ANGLE = 40;
+    private static final int INSIDE_ANGLE_SAMPLE = 18;
+    private static final int MIDDLE_ANGLE_SAMPLE = 30;
+    private static final int OUTSIDE_ANGLE_SAMPLE = 42;
+
+    private static final double[] FALLOFF_FACTORS = new double[] {0.5, 1, 1.5};
+
+    private static final SpotLight LIGHT = new SpotLight(Color.BLUE);
+
+    public static void main(String[] args) throws Exception {
+        initFX();
+    }
+
+    @BeforeClass
+    public static void initFX() throws Exception {
+        startupLatch = new CountDownLatch(1);
+        LightingTest.light = LIGHT;
+        new Thread(() -> Application.launch(TestApp.class, (String[]) null)).start();
+        assertTrue("Timeout waiting for FX runtime to start", startupLatch.await(15, TimeUnit.SECONDS));
+    }
+
+    @Before
+    public void setupEach() {
+        assumeTrue(Platform.isSupported(ConditionalFeature.SCENE3D));
+    }
+
+    @Test
+    public void testSpotlightAttenuation() {
+        Util.runAndWait(() -> {
+            LIGHT.setInnerAngle(INNER_ANGLE);
+            LIGHT.setOuterAngle(OUTER_ANGLE);
+            for (double falloff : FALLOFF_FACTORS) {
+                LIGHT.setFalloff(falloff);
+                var snapshot = snapshot();
+
+                int innerX = angleToDist(INSIDE_ANGLE_SAMPLE);
+                double spotFactor = 1;
+                double sampledBlue = snapshot.getPixelReader().getColor(innerX, 0).getBlue();
+                assertEquals(FAIL_MESSAGE, calculateLambertTerm(innerX) * spotFactor, sampledBlue, DELTA);
+
+                int middleX = angleToDist(MIDDLE_ANGLE_SAMPLE);
+                spotFactor = calculateSpotlightFactor(MIDDLE_ANGLE_SAMPLE);
+                sampledBlue = snapshot.getPixelReader().getColor(middleX, 0).getBlue();
+                assertEquals(FAIL_MESSAGE, calculateLambertTerm(middleX) * spotFactor, sampledBlue, DELTA);
+
+                int outerX = angleToDist(OUTSIDE_ANGLE_SAMPLE);
+                spotFactor = 0;
+                sampledBlue = snapshot.getPixelReader().getColor(outerX, 0).getBlue();
+                assertEquals(FAIL_MESSAGE, calculateLambertTerm(outerX) * spotFactor, sampledBlue, DELTA);
+            }
+        });
+    }
+
+    // I = pow((cosAngle - cosOuter) / (cosInner - cosOuter), falloff)
+    private double calculateSpotlightFactor(double degrees) {
+        double numerator = degCos(degrees) - degCos(LIGHT.getOuterAngle());
+        double denom = degCos(LIGHT.getInnerAngle()) - degCos(LIGHT.getOuterAngle());
+        return Math.pow(numerator / denom, LIGHT.getFalloff());
+    }
+
+    private double degCos(double degrees) {
+        return Math.cos(Math.toRadians(degrees));
+    }
+
+    private int angleToDist(double degrees) {
+        return (int) (LIGHT_DIST * Math.tan(Math.toRadians(degrees)));
+    }
+}