8217853: Cleanup in the D3D native pipeline

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

@@ -90,22 +90,6 @@ 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/NGShape3D.java

@@ -26,7 +26,6 @@
 package com.sun.javafx.sg.prism;
 
 import com.sun.javafx.geom.Vec3d;
-import com.sun.javafx.geom.Vec3f;
 import com.sun.javafx.geom.transform.Affine3D;
 import com.sun.javafx.util.Utils;
 import com.sun.prism.Graphics;
@@ -36,7 +35,6 @@
 
 import javafx.application.ConditionalFeature;
 import javafx.application.Platform;
-import javafx.geometry.Point3D;
 import javafx.scene.shape.CullFace;
 import javafx.scene.shape.DrawMode;
 
@@ -118,35 +116,23 @@ private void renderMeshView(Graphics g) {
             drawModeDirty = false;
         }
 
-        // Setup lights
+        setupLights(g);
+
+        meshView.render(g);
+    }
+
+    private void setupLights(Graphics g) {
         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.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(),
-                    1,
-                    NGPointLight.getDefaultMaxRange(),
-                    (float) NGPointLight.getSimulatedDirection().getX(),
-                    (float) NGPointLight.getSimulatedDirection().getY(),
-                    (float) NGPointLight.getSimulatedDirection().getZ(),
-                    NGPointLight.getSimulatedInnerAngle(),
-                    NGPointLight.getSimulatedOuterAngle(),
-                    NGPointLight.getSimulatedFalloff());
+        NGLightBase[] lights = g.getLights();
+        if (noLights(lights)) {
+            createDefaultLight(g);
+            lightIndex++;
         } else {
             float ambientRed = 0.0f;
             float ambientBlue = 0.0f;
             float ambientGreen = 0.0f;
 
-            for (NGLightBase lightBase : g.getLights()) {
+            for (NGLightBase lightBase : lights) {
                 if (lightBase == null) {
                     // The array of lights can have nulls
                     break;
@@ -162,6 +148,12 @@ private void renderMeshView(Graphics g) {
                 if (rL == 0.0f && gL == 0.0f && bL == 0.0f) {
                     continue;
                 }
+                if (lightBase instanceof NGAmbientLight) {
+                    // Accumulate ambient lights
+                    ambientRed   += rL;
+                    ambientGreen += gL;
+                    ambientBlue  += bL;
+                }
                 /* 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)
@@ -179,61 +171,95 @@ private void renderMeshView(Graphics g) {
                  * 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(),
-                            1,
-                            light.getMaxRange(),
-                            (float) light.getDirection().getX(),
-                            (float) light.getDirection().getY(),
-                            (float) light.getDirection().getZ(),
-                            light.getInnerAngle(),
-                            light.getOuterAngle(),
-                            light.getFalloff());
+                else if (lightBase instanceof NGSpotLight) {
+                    addSpotLight((NGSpotLight) lightBase, lightIndex++, rL, gL, bL);
+                } else if (lightBase instanceof NGPointLight) {
+                    addPointLight((NGPointLight) lightBase, lightIndex++, rL, gL, bL);
                 } else if (lightBase instanceof NGDirectionalLight) {
-                    var light = (NGDirectionalLight) lightBase;
-                    meshView.setLight(lightIndex++,
-                            0, 0, 0,                 // position is irrelevant
-                            rL, gL, bL, 1.0f,
-                            1, 0, 0,                 // attenuation is irrelevant
-                            0,
-                            Float.POSITIVE_INFINITY, // range is irrelevant
-                            (float) light.getDirection().getX(),
-                            (float) light.getDirection().getY(),
-                            (float) light.getDirection().getZ(),
-                            0, 0, 0);                // spotlight factors are irrelevant
-                } else if (lightBase instanceof NGAmbientLight) {
-                    // Accumulate ambient lights
-                    ambientRed   += rL;
-                    ambientGreen += gL;
-                    ambientBlue  += bL;
+                    addDirectionalLight((NGDirectionalLight) lightBase, lightIndex++, rL, gL, bL);
                 }
             }
-            ambientRed = Utils.clamp(0, ambientRed, 1);
-            ambientGreen = Utils.clamp(0, ambientGreen, 1);
-            ambientBlue = Utils.clamp(0, ambientBlue, 1);
-            meshView.setAmbientLight(ambientRed, ambientGreen, ambientBlue);
+            if (ambientRed != 0.0f || ambientGreen != 0.0f || ambientBlue != 0.0f) {
+                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 (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, 1, 0, // ca la qa isAttenuated maxRange
-                    0, 0, 1,    // dirX Y Z
-                    0, 0, 0);   // inner outer falloff
+            resetLight(lightIndex++);
         }
+    }
 
-        meshView.render(g);
+    private boolean noLights(NGLightBase[] lights) {
+        return lights == null || lights[0] == null;
+    }
+
+    /**
+     * Creates a white point light at the camera's (eye) position. The light uses the default attenuation parameters,
+     * which means that it is not attenuated (isAttenuated == 0).
+     */
+    private void createDefaultLight(Graphics g) {
+        meshView.setAmbientLight(0.0f, 0.0f, 0.0f);
+        Vec3d cameraPos = g.getCameraNoClone().getPositionInWorld(null);
+        var direction = NGPointLight.getSimulatedDirection();
+        meshView.setLight(0,
+                (float) cameraPos.x, (float) cameraPos.y, (float) cameraPos.z,
+                1.0f, 1.0f, 1.0f, 1.0f,
+                NGPointLight.getDefaultCa(), NGPointLight.getDefaultLa(), NGPointLight.getDefaultQa(), 0,
+                NGPointLight.getDefaultMaxRange(),
+                (float) direction.getX(), (float) direction.getY(), (float) direction.getZ(),
+                NGPointLight.getSimulatedInnerAngle(),
+                NGPointLight.getSimulatedOuterAngle(),
+                NGPointLight.getSimulatedFalloff());
+    }
+
+    private void addPointLight(NGPointLight light, int lightIndex, float r, float g, float b) {
+        Affine3D lightWT = light.getWorldTransform();
+        var direction = NGPointLight.getSimulatedDirection();
+        meshView.setLight(lightIndex,
+                (float) lightWT.getMxt(), (float) lightWT.getMyt(), (float) lightWT.getMzt(),
+                r, g, b, 1.0f,
+                light.getCa(), light.getLa(), light.getQa(), 1,
+                light.getMaxRange(),
+                (float) direction.getX(), (float) direction.getY(), (float) direction.getZ(),
+                NGPointLight.getSimulatedInnerAngle(),
+                NGPointLight.getSimulatedOuterAngle(),
+                NGPointLight.getSimulatedFalloff());
+    }
+
+    private void addSpotLight(NGSpotLight light, int lightIndex, float r, float g, float b) {
+        Affine3D lightWT = light.getWorldTransform();
+        var normDir = light.getDirection().normalize();
+        meshView.setLight(lightIndex,
+                (float) lightWT.getMxt(), (float) lightWT.getMyt(), (float) lightWT.getMzt(),
+                r, g, b, 1.0f,
+                light.getCa(), light.getLa(), light.getQa(), 1,
+                light.getMaxRange(),
+                (float) normDir.getX(), (float) normDir.getY(), (float) normDir.getZ(),
+                light.getInnerAngle(), light.getOuterAngle(), light.getFalloff());
+    }
+
+    private void addDirectionalLight(NGDirectionalLight light, int lightIndex, float r, float g, float b) {
+        var normDir = light.getDirection().normalize();
+        meshView.setLight(lightIndex,
+                0, 0, 0,                 // position is irrelevant
+                r, g, b, 1.0f,
+                1, 0, 0, 0,              // attenuation is irrelevant
+                Float.POSITIVE_INFINITY, // range is irrelevant
+                (float) normDir.getX(), (float) normDir.getY(), (float) normDir.getZ(),
+                0, 0, 0);                // spotlight factors are irrelevant
+    }
+
+    private void resetLight(int lightIndex) {
+        meshView.setLight(lightIndex,
+                0, 0, 0,    // x y z
+                0, 0, 0, 0, // r g b lightOn
+                1, 0, 0, 1, 0, // ca la qa isAttenuated maxRange
+                0, 0, 1,    // dirX Y Z
+                0, 0, 0);   // inner outer falloff
     }
 
     public void setMesh(NGTriangleMesh triangleMesh) {

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

@@ -68,7 +68,6 @@ public static float getDefaultFalloff() {
     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);
@@ -85,7 +84,6 @@ public void setDirection(Point3D direction) {
 
     private float innerAngle = DEFAULT_INNER_ANGLE;
 
-    @Override
     public float getInnerAngle() {
         return innerAngle;
     }
@@ -100,7 +98,6 @@ public void setInnerAngle(float innerAngle) {
 
     private float outerAngle = DEFAULT_OUTER_ANGLE;
 
-    @Override
     public float getOuterAngle() {
         return outerAngle;
     }
@@ -115,7 +112,6 @@ public void setOuterAngle(float outerAngle) {
 
     private float falloff = DEFAULT_FALLOFF;
 
-    @Override
     public float getFalloff() {
         return falloff;
     }

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

@@ -31,38 +31,23 @@ using std::endl;
 
 // Destructor definition
 
-D3DLight::~D3DLight() {
-}
-
-D3DLight::D3DLight() :
-    color(),
-    position(),
-    w(0),
-    attenuation(),
-    maxRange(0),
-    direction(),
-    innerAngle(0),
-    outerAngle(0),
-    falloff(0)
-    {}
-
 bool D3DLight::isPointLight() {
     return falloff == 0 && outerAngle == 180 && attenuation[3] > 0.5;
 }
 
 bool D3DLight::isDirectionalLight() {
-    // testing if w is 0 or 1 using <0.5 since equality check for floating points might not work well
+    // testing if attenuation.w is 0 or 1 using <0.5 since equality check for floating points might not work well
     return attenuation[3] < 0.5;
 }
 
-void D3DLight::setColor(float r, float g, float b) {
-    color[0] = r;
-    color[1] = g;
-    color[2] = b;
-}
-
-void D3DLight::setPosition(float x, float y, float z) {
-    position[0] = x;
-    position[1] = y;
-    position[2] = z;
-}
+//void D3DLight::setColor(float r, float g, float b) {
+//    color[0] = r;
+//    color[1] = g;
+//    color[2] = b;
+//}
+//
+//void D3DLight::setPosition(float x, float y, float z) {
+//    position[0] = x;
+//    position[1] = y;
+//    position[2] = z;
+//}

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

@@ -26,28 +26,26 @@
 #ifndef D3DLIGHT_H
 #define D3DLIGHT_H
 
-#include "D3DContext.h"
-
 // See     Light.h
 
 class D3DLight {
 public:
-    D3DLight();
-    virtual ~D3DLight();
+    D3DLight() = default;
+    virtual ~D3DLight() = default;
     bool isPointLight();
     bool isDirectionalLight();
-    void setColor(float r, float g, float b);
-    void setPosition(float x, float y, float z);
-
-    float position[3];
-    float color[3];
-    float w;
-    float attenuation[4]; // ca, la, qa, isAttenuated
-    float maxRange;
-    float direction[3];
-    float innerAngle;
-    float outerAngle;
-    float falloff;
+//    void setColor(float r, float g, float b);
+//    void setPosition(float x, float y, float z);
+
+    float position[3] = {0};
+    float color[3] = {0};
+    float lightOn = 0;
+    float attenuation[4] = {0}; // ca, la, qa, isAttenuated
+    float maxRange = 0;
+    float direction[3] = {0};
+    float innerAngle = 0;
+    float outerAngle = 0;
+    float falloff = 0;
 
 private: