FXGL 3D rendering: camera and JavaFX shaders

3D Rendering in FXGL and JavaFX: Features, Limitations, and System Modeling Integration

The JavaFX 3D camera gives you full control over view parameters. Adjusting the field of view (FOV) lets you dynamically change the viewing angle using bindings:

camera3D.getPerspectiveCamera().fieldOfViewProperty().bind(cam_val);

Tweaking the near and far clipping planes optimizes rendering by culling invisible objects. Translate and Rotate transformations handle camera movement and rotation.

To attach the camera to an object like a car, calculate the position like this:

var distanceToCamera = -8;
var pos = entity.getPosition3D().subtract(entity.getTransformComponent().getDirection3D().multiply(distanceToCamera));
transform.setPosition3D(pos);
transform.lookAt(entity.getPosition3D());
transform.setY(entity.getY() + CAMERA_HEIGHT_OFFSET);

Smooth movement is achieved with interpolation using easing factors:

double smoothXY = 0.2;
double smoothZ = 0.2;

var distanceToCamera = -8;
var targetPos = entity.getPosition3D().subtract(
        entity.getTransformComponent().getDirection3D().multiply(distanceToCamera)
);

double newX = cameraPos.getX() + (targetPos.getX() - cameraPos.getX()) * smoothXY;
double newY = cameraPos.getY() + (targetPos.getY() - cameraPos.getY()) * smoothXY;
double newZ = cameraPos.getZ() + (targetPos.getZ() - cameraPos.getZ()) * smoothZ;

cameraPos = new Point3D(newX, newY, newZ);

transform.setPosition3D(cameraPos);
transform.lookAt(entity.getPosition3D());
transform.setY(cameraPos.getY() + CAMERA_HEIGHT_OFFSET);

This creates smooth cinematic effects and responsive interactive controls.

Phong Materials and Texturing

PhongMaterial supports texture maps for realistic rendering:

• diffuseMap: Base texture and surface color.
• normalMap: Simulates surface bumps without extra geometry, saving resources.
• specularMap: Controls surface highlights and shine.
• specularPower: Adjusts glossiness from matte to mirror-like.

You can auto-generate normal maps from diffuse maps for quick texturing.

Model Import and Shaders

Supported formats include .obj and .3ds, preserving hierarchies and transformations. Imports generate ready-to-use JavaFX nodes (MeshView, Group).

Integrate GLSL shaders via low-level APIs:

• Vertex and fragment shaders for custom rendering.
• Swap standard Phong lighting for neon, stylized, or procedural effects.
• Manage textures and vertex attributes in shaders.

ShaderProgram hooks extend the default pipeline.

JavaFX 3D Limitations

No Shadows

Objects don't cast shadows. Simulate them with manual polygons. Dynamic shadow mapping isn't available without direct OpenGL calls.

Limited Lighting

Only PointLight, DirectionalLight, and AmbientLight are supported—no Spotlights. Per-vertex lighting causes artifacts on low-poly models. Intensity and falloff controls lack flexibility.

No Built-in Physics Engine

No collision detection, gravity, or inertia. Implement manually or use external libraries.

Code-Only Scene Building

No WYSIWYG editor. Scenes are assembled via Group, SubScene, and MeshView in Java code.

Integrating with RepeatCore for System Modeling

For cross-platform apps with mathematical models, integrate RepeatCore:

RepeatCore.parseClassMap();
RepeatCore.runtimeAsService = true;
RepeatCore.isSingle = true;
RepeatCoreService.runtimeAsService = true;
RepeatCoreServiceDocument.verboseLevel = 0;
RepeatCoreServiceDocument.startWithoutBinFile = true;
var repeatCoreService = new RepeatCoreService();
var tempdoc = new RepeatCoreServiceDocument();
serviceDocument = tempdoc.openDocument(filename);
serviceDocument.setParentRepeatCoreService(repeatCoreService);
serviceDocument.documentCalculate();

Fetch objects by ID:

speed_setpoint = (Constant) getObjbyIdFromList(serviceDocument.componentList, "1739110251130");

Update data via bindings or streams to sync with FXGL 3D rendering. This enables apps for controlling electric drives with real-time visualization.

Example: Electric drive control demo with charts and 3D scenes.

Practical FXGL Implementation

Porting assets from classic games (like NFS) to FXGL involves tweaking scale, lighting, and models. Fixing scale issues and importing textures shows its prototyping power.

Adding a UI for light settings and object hierarchies simplifies debugging.

Key Takeaways:

• FXGL + JavaFX 3D shines for prototypes and gamified simulators, not production games.
• PhongMaterial with normal maps delivers solid visuals without high-poly counts.
• RepeatCore integration embeds system modeling into 3D apps.
• Main limits: no shadows, physics, or visual editor.
• GLSL shaders unlock custom rendering effects.

— Editorial Team