JavaFX与LWJGL项目集成：如何实现组件互嵌？

Got it, let's break down two solid approaches to integrate LWJGL with JavaFX—either embedding your LWJGL render output into a JavaFX scene, or using JavaFX buttons to control your LWJGL logic. Here's how to implement both:

1. Embed LWJGL Rendering into a JavaFX Scene #

This approach renders LWJGL content off-screen, then pushes the frame data to a JavaFX ImageView (or Canvas) to display it within your JavaFX UI.

Step-by-Step Implementation #

JavaFX Application Class

This sets up the main scene and handles updating the UI with LWJGL's frame data:

import javafx.application.Application;
import javafx.application.Platform;
import javafx.scene.Scene;
import javafx.scene.image.Image;
import javafx.scene.image.ImageView;
import javafx.scene.layout.StackPane;
import javafx.stage.Stage;
import java.io.ByteArrayInputStream;

public class LwjglFxEmbed extends Application {
    private LwjglOffscreenRenderer renderer;
    private ImageView renderView;

    @Override
    public void start(Stage primaryStage) {
        renderView = new ImageView();
        StackPane root = new StackPane(renderView);
        Scene scene = new Scene(root, 800, 600);

        // Initialize LWJGL renderer with a callback to update the JavaFX view
        renderer = new LwjglOffscreenRenderer(800, 600, this::updateRenderOutput);

        // Start LWJGL render loop in a separate thread
        new Thread(renderer::startRenderLoop).start();

        primaryStage.setTitle("LWJGL Embedded in JavaFX");
        primaryStage.setScene(scene);
        primaryStage.show();
    }

    // Update JavaFX ImageView with new frame data (must run on JavaFX thread)
    private void updateRenderOutput(byte[] pixelData) {
        Platform.runLater(() -> {
            renderView.setImage(new Image(
                new ByteArrayInputStream(pixelData),
                800, 600, true, true
            ));
        });
    }

    @Override
    public void stop() {
        renderer.shutdown();
    }

    public static void main(String[] args) {
        launch(args);
    }
}

LWJGL Off-Screen Renderer Class

Handles LWJGL initialization, off-screen rendering, and frame data extraction:

import org.lwjgl.BufferUtils;
import org.lwjgl.glfw.GLFW;
import org.lwjgl.opengl.GL;
import org.lwjgl.opengl.GL11;
import org.lwjgl.opengl.GL30;
import java.nio.ByteBuffer;

public class LwjglOffscreenRenderer {
    private final int width;
    private final int height;
    private final FrameUpdateCallback updateCallback;
    private volatile boolean running = true;
    private int framebuffer;
    private int texture;
    private ByteBuffer pixelBuffer;

    public interface FrameUpdateCallback {
        void onFrameReady(byte[] pixels);
    }

    public LwjglOffscreenRenderer(int width, int height, FrameUpdateCallback callback) {
        this.width = width;
        this.height = height;
        this.updateCallback = callback;
        this.pixelBuffer = BufferUtils.createByteBuffer(width * height * 4);
    }

    public void startRenderLoop() {
        // Initialize GLFW with an invisible window for context
        GLFW.glfwInit();
        GLFW.glfwDefaultWindowHints();
        GLFW.glfwWindowHint(GLFW.GLFW_VISIBLE, GLFW.GLFW_FALSE);
        long window = GLFW.glfwCreateWindow(width, height, "", 0, 0);
        GLFW.glfwMakeContextCurrent(window);
        GL.createCapabilities();

        // Set up framebuffer for off-screen rendering
        initFramebuffer();

        while (running && !GLFW.glfwWindowShouldClose(window)) {
            renderFrame();
            extractAndSendFrameData();
            GLFW.glfwSwapBuffers(window);
            GLFW.glfwPollEvents();
        }

        // Cleanup resources
        cleanup();
        GLFW.glfwDestroyWindow(window);
        GLFW.glfwTerminate();
    }

    private void initFramebuffer() {
        framebuffer = GL30.glGenFramebuffers();
        GL30.glBindFramebuffer(GL30.GL_FRAMEBUFFER, framebuffer);

        // Create texture to hold render output
        texture = GL11.glGenTextures();
        GL11.glBindTexture(GL11.GL_TEXTURE_2D, texture);
        GL11.glTexImage2D(GL11.GL_TEXTURE_2D, 0, GL11.GL_RGBA, width, height, 0, GL11.GL_RGBA, GL11.GL_UNSIGNED_BYTE, null);
        GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MIN_FILTER, GL11.GL_LINEAR);

        // Attach texture to framebuffer
        GL30.glFramebufferTexture2D(GL30.GL_FRAMEBUFFER, GL30.GL_COLOR_ATTACHMENT0, GL11.GL_TEXTURE_2D, texture, 0);

        if (GL30.glCheckFramebufferStatus(GL30.GL_FRAMEBUFFER) != GL30.GL_FRAMEBUFFER_COMPLETE) {
            throw new RuntimeException("Failed to initialize off-screen framebuffer");
        }
        GL30.glBindFramebuffer(GL30.GL_FRAMEBUFFER, 0);
    }

    private void renderFrame() {
        GL30.glBindFramebuffer(GL30.GL_FRAMEBUFFER, framebuffer);
        GL11.glClearColor(0.2f, 0.3f, 0.3f, 1.0f);
        GL11.glClear(GL11.GL_COLOR_BUFFER_BIT);

        // Add your custom LWJGL rendering logic here (example: triangle)
        drawTriangle();

        GL30.glBindFramebuffer(GL30.GL_FRAMEBUFFER, 0);
    }

    private void drawTriangle() {
        GL11.glBegin(GL11.GL_TRIANGLES);
        GL11.glColor3f(1.0f, 0.0f, 0.0f);
        GL11.glVertex2f(-0.5f, -0.5f);
        GL11.glColor3f(0.0f, 1.0f, 0.0f);
        GL11.glVertex2f(0.5f, -0.5f);
        GL11.glColor3f(0.0f, 0.0f, 1.0f);
        GL11.glVertex2f(0.0f, 0.5f);
        GL11.glEnd();
    }

    private void extractAndSendFrameData() {
        GL30.glBindFramebuffer(GL30.GL_FRAMEBUFFER, framebuffer);
        pixelBuffer.rewind();
        GL11.glReadPixels(0, 0, width, height, GL11.GL_RGBA, GL11.GL_UNSIGNED_BYTE, pixelBuffer);
        GL30.glBindFramebuffer(GL30.GL_FRAMEBUFFER, 0);

        // Flip pixels (LWJGL reads from bottom-left, JavaFX expects top-left)
        byte[] flippedPixels = new byte[width * height * 4];
        for (int y = 0; y < height; y++) {
            System.arraycopy(pixelBuffer.array(), y * width * 4, flippedPixels, (height - 1 - y) * width * 4, width * 4);
        }

        updateCallback.onFrameReady(flippedPixels);
    }

    public void shutdown() {
        running = false;
    }

    private void cleanup() {
        GL30.glDeleteFramebuffers(framebuffer);
        GL11.glDeleteTextures(texture);
    }
}

2. Control LWJGL with JavaFX Buttons #

This approach keeps LWJGL running in its own window (or off-screen) and uses JavaFX buttons to trigger LWJGL logic (like starting/stopping rendering, changing settings).

Step-by-Step Implementation #

JavaFX UI Class

Creates buttons and binds their actions to LWJGL control methods:

import javafx.application.Application;
import javafx.scene.Scene;
import javafx.scene.control.Button;
import javafx.scene.layout.VBox;
import javafx.stage.Stage;
import javafx.geometry.Insets;

public class FxControlLwjgl extends Application {
    private LwjglRuntimeController lwjglController;

    @Override
    public void start(Stage primaryStage) {
        Button startBtn = new Button("Start LWJGL Rendering");
        Button stopBtn = new Button("Stop Rendering");
        Button colorToggleBtn = new Button("Toggle Background Color");

        // Initialize LWJGL in a separate thread
        lwjglController = new LwjglRuntimeController();
        new Thread(lwjglController::initAndRun).start();

        // Bind button actions to LWJGL controls
        startBtn.setOnAction(e -> lwjglController.setRenderingActive(true));
        stopBtn.setOnAction(e -> lwjglController.setRenderingActive(false));
        colorToggleBtn.setOnAction(e -> lwjglController.toggleBackgroundColor());

        VBox root = new VBox(10, startBtn, stopBtn, colorToggleBtn);
        root.setPadding(new Insets(20));
        Scene scene = new Scene(root, 300, 200);

        primaryStage.setTitle("JavaFX Controls LWJGL");
        primaryStage.setScene(scene);
        primaryStage.show();
    }

    @Override
    public void stop() {
        lwjglController.shutdown();
    }

    public static void main(String[] args) {
        launch(args);
    }
}

LWJGL Runtime Controller Class

Handles LWJGL window setup, rendering loop, and exposes control methods:

import org.lwjgl.glfw.GLFW;
import org.lwjgl.opengl.GL;
import org.lwjgl.opengl.GL11;

public class LwjglRuntimeController {
    private volatile boolean renderingActive = false;
    private volatile float bgR = 0.2f, bgG = 0.3f, bgB = 0.3f;
    private long window;

    public void initAndRun() {
        // Initialize GLFW and create visible window
        GLFW.glfwInit();
        GLFW.glfwDefaultWindowHints();
        window = GLFW.glfwCreateWindow(800, 600, "LWJGL Controlled by JavaFX", 0, 0);
        GLFW.glfwMakeContextCurrent(window);
        GLFW.glfwShowWindow(window);
        GL.createCapabilities();

        while (!GLFW.glfwWindowShouldClose(window)) {
            if (renderingActive) {
                renderFrame();
            }
            GLFW.glfwSwapBuffers(window);
            GLFW.glfwPollEvents();
        }

        shutdown();
    }

    private void renderFrame() {
        GL11.glClearColor(bgR, bgG, bgB, 1.0f);
        GL11.glClear(GL11.GL_COLOR_BUFFER_BIT);
        // Add your custom LWJGL rendering logic here
    }

    // Thread-safe control methods
    public void setRenderingActive(boolean active) {
        this.renderingActive = active;
    }

    public void toggleBackgroundColor() {
        if (bgR == 0.2f) {
            bgR = 0.3f; bgG = 0.2f; bgB = 0.4f;
        } else {
            bgR = 0.2f; bgG = 0.3f; bgB = 0.3f;
        }
    }

    public void shutdown() {
        renderingActive = false;
        GLFW.glfwDestroyWindow(window);
        GLFW.glfwTerminate();
    }
}

Key Notes #

• Thread Safety: Always update JavaFX UI elements via Platform.runLater() (JavaFX UI thread), and never call OpenGL methods outside the LWJGL render thread (OpenGL contexts are thread-bound).
• Dependencies: Ensure your project includes LWJGL modules (core, GLFW, OpenGL) and JavaFX modules (controls, graphics, base). For modular projects, declare these dependencies in your module-info.java.
• Performance: For higher performance in the embedded approach, use JavaFX's Canvas and PixelWriter instead of ImageView to avoid creating new Image objects every frame.

内容的提问来源于stack exchange，提问作者Khaled Shoushara