The functionality of the SWT canvas is almost identical with the GLCanvas of JOGL, why not make the swt canvas equally fast?

[reza1234567891]

basically i wonder and think it would be a good idea to make the canvas of swt hardware accelerated, the functionality seems almost the same as the JOGL canvas which can already be integretaed with SWT, so why not make the SWT Canvas fast to begin with? will this happen in gtk4 perhaps? at least have an option to turn it on?

[akurtakov]

Have you measured how much slower it is ? E.g. on Gtk 3.x it relies on Cairo (https://www.cairographics.org/) which has multiple backends (https://www.cairographics.org/backends/) so it would depend on your system configuration whether it is hardware accelerated or not.
If you have concrete example that shows significant slowdown it would be nice to try out.

[reza1234567891]

one difference is that swt cant go faster than the screen fps, where as glcanvas can

example:

polyline with 30k lines, sinewave with noise:
jogl 430 fps
swt 4 fps

swt is much more sensitive to the number of pixels being drawn, so it performs better for a sine wave with no or little noise

[reza1234567891]

this is jogl

import org.eclipse.swt.SWT;
import org.eclipse.swt.events.MouseEvent;
import org.eclipse.swt.events.MouseListener;
import org.eclipse.swt.events.MouseMoveListener;
import org.eclipse.swt.events.SelectionAdapter;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.layout.FillLayout;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.widgets.Button;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Shell;

import com.jogamp.opengl.*;
import com.jogamp.opengl.swt.GLCanvas;
import com.jogamp.opengl.util.awt.TextRenderer;

import java.awt.Font;
import java.nio.FloatBuffer;

public class test implements GLEventListener {

private static final int POINTS = 30000;
private float[] vertices = new float[POINTS * 2];
private TextRenderer textRenderer;

private float phase = 0f;  // phase offset for sine wave movement

// FPS tracking
private int frameCount = 0;
private long lastTime = System.currentTimeMillis();
private float fps = 0f;

// Animation control
volatile boolean running = true;

// Mouse position over canvas (SWT coordinates)
private int mouseX = -1;
private int mouseY = -1;

// Drag square tracking
private boolean dragging = false;
private int dragStartX = 0;
private int dragStartY = 0;
private int dragCurrentX = 0;
private int dragCurrentY = 0;

// VBO id
private int vboId;

public test() {
    // initial vertices array is empty; updated each frame
}

private void updateVertices() {
    for (int i = 0; i < POINTS; i++) {
        float x = (float) i / (POINTS - 1) * 2f - 1f; // map to [-1,1]
        float y = (float) ( Math.sin(10 * (x + phase) * Math.PI) * 0.5f+ Math.random()*0.5 );
        vertices[i * 2] = x;
        vertices[i * 2 + 1] = y;
    }
}

@Override
public void init(GLAutoDrawable drawable) {
    GL2 gl = drawable.getGL().getGL2();
    gl.glClearColor(0f, 0f, 0f, 1f);
    gl.glLineWidth(1.0f);

    // Disable VSync
    gl.setSwapInterval(0);

    // Create VBO
    int[] buffers = new int[1];
    gl.glGenBuffers(1, buffers, 0);
    vboId = buffers[0];
    gl.glBindBuffer(GL.GL_ARRAY_BUFFER, vboId);
    // allocate empty buffer, usage dynamic because we'll update every frame
    gl.glBufferData(GL.GL_ARRAY_BUFFER, vertices.length * Float.BYTES, null, GL.GL_DYNAMIC_DRAW);
    gl.glBindBuffer(GL.GL_ARRAY_BUFFER, 0);

    textRenderer = new TextRenderer(new Font("SansSerif", Font.BOLD, 14));
}

@Override
public void dispose(GLAutoDrawable drawable) {
    if (textRenderer != null) {
        textRenderer.dispose();
    }

    GL2 gl = drawable.getGL().getGL2();
    int[] buffers = {vboId};
    gl.glDeleteBuffers(1, buffers, 0);
}

@Override
public void display(GLAutoDrawable drawable) {
    if (running) {
        phase += 0.005f;
        if (phase > 2f) phase -= 2f;
    }

    updateVertices();

    GL2 gl = drawable.getGL().getGL2();
    gl.glClear(GL.GL_COLOR_BUFFER_BIT);

    // Upload updated vertex data to GPU buffer
    gl.glBindBuffer(GL.GL_ARRAY_BUFFER, vboId);
    gl.glBufferSubData(GL.GL_ARRAY_BUFFER, 0, vertices.length * Float.BYTES, FloatBuffer.wrap(vertices));

    // Enable vertex array and set pointer
    gl.glEnableClientState(GL2.GL_VERTEX_ARRAY);
    gl.glVertexPointer(2, GL.GL_FLOAT, 0, 0);

    // Draw line strip from VBO
    gl.glColor3f(0f, 1f, 0f);
    gl.glDrawArrays(GL.GL_LINE_STRIP, 0, POINTS);

    gl.glDisableClientState(GL2.GL_VERTEX_ARRAY);
    gl.glBindBuffer(GL.GL_ARRAY_BUFFER, 0);

    // Draw drag rectangle if dragging
    if (dragging) {
        gl.glEnable(GL.GL_BLEND);
        gl.glBlendFunc(GL.GL_SRC_ALPHA, GL.GL_ONE_MINUS_SRC_ALPHA);
        gl.glColor4f(1f, 0f, 0f, 0.5f);

        int width = drawable.getSurfaceWidth();
        int height = drawable.getSurfaceHeight();

        float x1 = 2f * dragStartX / width - 1f;
        float y1 = 1f - 2f * dragStartY / height;  // invert Y axis
        float x2 = 2f * dragCurrentX / width - 1f;
        float y2 = 1f - 2f * dragCurrentY / height;

        float left = Math.min(x1, x2);
        float right = Math.max(x1, x2);
        float bottom = Math.min(y1, y2);
        float top = Math.max(y1, y2);

        gl.glBegin(GL2.GL_QUADS);
        gl.glVertex2f(left, bottom);
        gl.glVertex2f(right, bottom);
        gl.glVertex2f(right, top);
        gl.glVertex2f(left, top);
        gl.glEnd();

        gl.glDisable(GL.GL_BLEND);
    }

    // Update FPS every second
    frameCount++;
    long currentTime = System.currentTimeMillis();
    long elapsed = currentTime - lastTime;
    if (elapsed >= 1000) {
        fps = (frameCount * 1000f) / elapsed;
        frameCount = 0;
        lastTime = currentTime;
    }

    // Calculate sine value under mouse x if mouse is on canvas
    String sineValStr = "";
    if (mouseX >= 0 && mouseY >= 0) {
        int width = drawable.getSurfaceWidth();
        float glX = 2f * mouseX / width - 1f; // map pixel x to GL coord x
        float sineVal = (float) Math.sin(10 * (glX + phase) * Math.PI) * 0.5f;
        sineValStr = String.format("Sine value: %.3f", sineVal);
    }

    // Draw text info
    textRenderer.beginRendering(drawable.getSurfaceWidth(), drawable.getSurfaceHeight());
    textRenderer.setColor(1f, 1f, 1f, 1f);
    textRenderer.draw("Moving sine wave with 50,000 points (VBO)", 10, drawable.getSurfaceHeight() - 30);
    textRenderer.draw(String.format("FPS: %.1f", fps), 10, drawable.getSurfaceHeight() - 50);

    if (mouseX >= 0 && mouseY >= 0) {
        String mousePosText = String.format("Mouse: (%d, %d)", mouseX, mouseY);
        textRenderer.draw(mousePosText, 10, drawable.getSurfaceHeight() - 70);
        textRenderer.draw(sineValStr, 10, drawable.getSurfaceHeight() - 90);
    }
    textRenderer.endRendering();
}

@Override
public void reshape(GLAutoDrawable drawable, int x, int y, int width, int height) {
    GL2 gl = drawable.getGL().getGL2();

    gl.glViewport(0, 0, width, height);
    gl.glMatrixMode(GL2.GL_PROJECTION);
    gl.glLoadIdentity();
    gl.glOrtho(-1, 1, -1, 1, -1, 1);
    gl.glMatrixMode(GL2.GL_MODELVIEW);
    gl.glLoadIdentity();
}

public static void main(String[] args) {
    Display display = new Display();
    Shell shell = new Shell(display);
    shell.setText("SWT + JOGL High FPS Plot with VBO");
    shell.setLayout(new GridLayout(1, false));
    shell.setSize(800, 600);

    Composite buttonComposite = new Composite(shell, SWT.NONE);
    buttonComposite.setLayoutData(new GridData(SWT.FILL, SWT.CENTER, true, false));
    buttonComposite.setLayout(new FillLayout());

    Button startButton = new Button(buttonComposite, SWT.PUSH);
    startButton.setText("Start");

    Button stopButton = new Button(buttonComposite, SWT.PUSH);
    stopButton.setText("Stop");

    GLProfile profile = GLProfile.get(GLProfile.GL2);
    GLCapabilities caps = new GLCapabilities(profile);

    GLCanvas canvas = new GLCanvas(shell, SWT.NONE, caps, null);
    canvas.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true));

    test renderer = new test();
    canvas.addGLEventListener(renderer);

    canvas.addMouseMoveListener(new MouseMoveListener() {
        @Override
        public void mouseMove(MouseEvent e) {
            renderer.mouseX = e.x;
            renderer.mouseY = e.y;
            if (renderer.dragging) {
                renderer.dragCurrentX = e.x;
                renderer.dragCurrentY = e.y;
            }
        }
    });

    canvas.addMouseListener(new MouseListener() {
        @Override
        public void mouseDoubleClick(MouseEvent e) {}

        @Override
        public void mouseDown(MouseEvent e) {
            renderer.dragging = true;
            renderer.dragStartX = e.x;
            renderer.dragStartY = e.y;
            renderer.dragCurrentX = e.x;
            renderer.dragCurrentY = e.y;
        }

        @Override
        public void mouseUp(MouseEvent e) {
            renderer.dragging = false;
        }
    });

    // Render loop - runs only while running is true
    Runnable renderLoop = new Runnable() {
        public void run() {
            if (!canvas.isDisposed()) {
                if (renderer.running) {
                    canvas.display();
                    display.timerExec(0, this);
                }
            }
        }
    };

    renderLoop.run();

    startButton.addSelectionListener(new SelectionAdapter() {
        @Override
        public void widgetSelected(SelectionEvent e) {
            if (!renderer.running) {
                renderer.running = true;
                display.timerExec(0, renderLoop); // restart loop
            }
        }
    });

    stopButton.addSelectionListener(new SelectionAdapter() {
        @Override
        public void widgetSelected(SelectionEvent e) {
            renderer.running = false; // stop loop scheduling
        }
    });

    shell.open();
    while (!shell.isDisposed()) {
        if (!display.readAndDispatch()) {
            display.sleep();
        }
    }
    display.dispose();
}

}

[reza1234567891]

this is swt

import org.eclipse.swt.SWT;
import org.eclipse.swt.events.MouseEvent;
import org.eclipse.swt.events.MouseListener;
import org.eclipse.swt.events.MouseMoveListener;
import org.eclipse.swt.events.SelectionAdapter;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.layout.FillLayout;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.widgets.Button;
import org.eclipse.swt.widgets.Canvas;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Shell;

import java.util.Arrays;

public class swt_compare {

private static final int POINTS =30000;
private float[] vertices = new float[POINTS * 2];

private float phase = 0f;
private boolean running = true;

private int mouseX = -1;
private int mouseY = -1;

private boolean dragging = false;
private int dragStartX = 0;
private int dragStartY = 0;
private int dragCurrentX = 0;
private int dragCurrentY = 0;

// FPS tracking
private int frameCount = 0;
private long lastTime = System.currentTimeMillis();
private float fps = 0f;

private void updateVertices(int width, int height) {
    for (int i = 0; i < POINTS; i++) {
        float x = (float) i / (POINTS - 1) * width;
        float y = (float) (Math.sin(10 * ((x / width) * 2 - 1 + phase) * Math.PI) * 0.5 + 0.5 + Math.random()*0.5) * height;
        vertices[i * 2] = x;
        vertices[i * 2 + 1] = y;
    }
}

public void run() {
    Display display = new Display();
    Shell shell = new Shell(display);
    shell.setText("SWT Native Canvas High FPS Plot");
    shell.setLayout(new GridLayout(1, false));
    shell.setSize(800, 600);

    Composite buttonComposite = new Composite(shell, SWT.NONE);
    buttonComposite.setLayoutData(new GridData(SWT.FILL, SWT.CENTER, true, false));
    buttonComposite.setLayout(new FillLayout());

    Button startButton = new Button(buttonComposite, SWT.PUSH);
    startButton.setText("Start");

    Button stopButton = new Button(buttonComposite, SWT.PUSH);
    stopButton.setText("Stop");

    Canvas canvas = new Canvas(shell, SWT.NO_BACKGROUND | SWT.DOUBLE_BUFFERED);
    canvas.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true));

    // Paint handler
    canvas.addPaintListener(e -> {
        int width = canvas.getSize().x;
        int height = canvas.getSize().y;

        if (running) {
            phase += 0.005f;
            if (phase > 2f) phase -= 2f;
        }

        updateVertices(width, height);

        // Clear background
        //e.gc.setBackground(display.getSystemColor(SWT.COLOR_BLACK));
        e.gc.fillRectangle(canvas.getClientArea());

        // Draw sine wave
        e.gc.setForeground(display.getSystemColor(SWT.COLOR_BLUE));
        int[] polyline = new int[POINTS * 2];
        for (int i = 0; i < POINTS; i++) {
            polyline[i * 2] = (int) vertices[i * 2];
            polyline[i * 2 + 1] = (int) vertices[i * 2 + 1];
        }
        e.gc.drawPolyline(polyline);

        // Drag rectangle
        if (dragging) {
            e.gc.setAlpha(128);
            e.gc.setBackground(display.getSystemColor(SWT.COLOR_RED));
            int left = Math.min(dragStartX, dragCurrentX);
            int top = Math.min(dragStartY, dragCurrentY);
            int w = Math.abs(dragCurrentX - dragStartX);
            int h = Math.abs(dragCurrentY - dragStartY);
            e.gc.fillRectangle(left, top, w, h);
            e.gc.setAlpha(255);
        }

        // FPS calculation
        frameCount++;
        long currentTime = System.currentTimeMillis();
        if (currentTime - lastTime >= 1000) {
            fps = (frameCount * 1000f) / (currentTime - lastTime);
            frameCount = 0;
            lastTime = currentTime;
        }

        // Info text
        e.gc.setForeground(display.getSystemColor(SWT.COLOR_BLACK));
        e.gc.drawText("Moving sine wave with " + POINTS + " points", 10, 10, true);
        e.gc.drawText(String.format("FPS: %.1f", fps), 10, 30, true);

        if (mouseX >= 0 && mouseY >= 0) {
            e.gc.drawText("Mouse: (" + mouseX + ", " + mouseY + ")", 10, 50, true);
            float glX = 2f * mouseX / width - 1f;
            float sineVal = (float) Math.sin(10 * (glX + phase) * Math.PI) * 0.5f;
            e.gc.drawText(String.format("Sine value: %.3f", sineVal), 10, 70, true);
        }
    });

    // Mouse listeners
    canvas.addMouseMoveListener(new MouseMoveListener() {
        @Override
        public void mouseMove(MouseEvent e) {
            mouseX = e.x;
            mouseY = e.y;
            if (dragging) {
                dragCurrentX = e.x;
                dragCurrentY = e.y;
            }
        }
    });

    canvas.addMouseListener(new MouseListener() {
        @Override
        public void mouseDoubleClick(MouseEvent e) {}

        @Override
        public void mouseDown(MouseEvent e) {
            dragging = true;
            dragStartX = e.x;
            dragStartY = e.y;
            dragCurrentX = e.x;
            dragCurrentY = e.y;
        }

        @Override
        public void mouseUp(MouseEvent e) {
            dragging = false;
        }
    });

    // Animation loop
    Runnable loop = new Runnable() {
        @Override
        public void run() {
            if (!canvas.isDisposed()) {
                if (running) {
                    canvas.redraw();
                    display.timerExec(5, this);
                }
            }
        }
    };
    loop.run();

    startButton.addSelectionListener(new SelectionAdapter() {
        @Override
        public void widgetSelected(SelectionEvent e) {
            if (!running) {
                running = true;
                display.timerExec(5, loop);
            }
        }
    });

    stopButton.addSelectionListener(new SelectionAdapter() {
        @Override
        public void widgetSelected(SelectionEvent e) {
            running = false;
        }
    });

    shell.open();
    while (!shell.isDisposed()) {
        if (!display.readAndDispatch()) display.sleep();
    }
    display.dispose();
}

public static void main(String[] args) {
    new swt_compare().run();
}

}

[reza1234567891]

the code is generated by chatgpt

[DenisUngemach]

basically i wonder and think it would be a good idea to make the canvas of swt hardware accelerated, the functionality seems almost the same as the JOGL canvas which can already be integretaed with SWT, so why not make the SWT Canvas fast to begin with? will this happen in gtk4 perhaps? at least have an option to turn it on?

JOGL has a completely different API than the classical canvas.
So do you suggest to create a GC which relies on JOGL in order to make the classical canvas run with opengl and by that with hardware acceleration? This would mean a completely new GC implementation is necessary.

As akurtakov said, there are better alternatives. We also think about creating a skia-GC which also has multiple backends ( opengl is one of them ).

I think in general the idea to switch between 2D graphic libraries in SWT is probably the best concept to work with. Maybe it is also possible to use cairo under the GC of windows.

In this repo: https://github.com/swt-initiative31/skija-canvas we want to check whether skia works as 2d graphics library, but we just have started.

[reza1234567891]

basically i wonder and think it would be a good idea to make the canvas of swt hardware accelerated, the functionality seems almost the same as the JOGL canvas which can already be integretaed with SWT, so why not make the SWT Canvas fast to begin with? will this happen in gtk4 perhaps? at least have an option to turn it on?

JOGL has a completely different API than the classical canvas. So do you suggest to create a GC which relies on JOGL in order to make the classical canvas run with opengl and by that with hardware acceleration? This would mean a completely new GC implementation is necessary.

As akurtakov said, there are better alternatives. We also think about creating a skia-GC which also has multiple backends ( opengl is one of them ).

I think in general the idea to switch between 2D graphic libraries in SWT is probably the best concept to work with. Maybe it is also possible to use cairo under the GC of windows.

In this repo: https://github.com/swt-initiative31/skija-canvas we want to check whether skia works as 2d graphics library, but we just have started.

i have learnt more about the inner workings of SWT after asking the question, i am just a user of SWT. From my understanding cairo has hardware acceleration support but it isnt used, the easiest way to get hardware accleration for the canvas should be to activate it for cairo and make SWT have a flag to use it. According to chatgpt a 200-300 LOC patch. It even gave me a guide on how to do it myself so i think for someone who knows how it works it could be very doable with minimal effort. What has to be added is how SWT uses cairo, make it use cairo-gl if the user wants it and cairo-gl is installed and fallback to the current CPU-drawing if it doesnt work. The performance difference is huge and makes it possible to create nice graphics with high frequency with SWT with the same commands as we are already used to with GC.

a hardware accelerated canvas would possibly lead to many use cases, maybe even new graphics classes to create more advanced objects on the canvas, 3D engines, high freqency plotting etc. we already know how easy SWT is to use.

[DenisUngemach]

Are you talking about linux only or also about windows and mac?

On linux, as akurtakov has written, you can check in SWT, whether the cairo implementation uses cairo-gl.

[reza1234567891]

Are you talking about linux only or also about windows and mac?

On linux, as akurtakov has written, you can check in SWT, whether the cairo implementation uses cairo-gl.

linux only for me but i try to be general

according to my chatgpt research it is not enough to set up cairo-gl as SWT can't use it today, it has to with how SWT uses cairo so even if i reconfigured my system and activated cairo-gl it would make no difference.

chatgpt says it has something to do with "SWT’s GTK3 backend always uses image surfaces" but "cairo-gl only works if the surface is a GL surface"... i guess you know better than med exactly what this means but i guess it has to do with how SWT uses cairo

[ptziegler]

What has to be added is how SWT uses cairo, make it use cairo-gl if the user wants it and cairo-gl is installed and fallback to the current CPU-drawing if it doesnt work.

FYI: cairo-gl is deprecated and has been removed completely from recent Cairo versions:
https://gitlab.freedesktop.org/cairo/cairo/-/merge_requests/287

[reza1234567891]

What has to be added is how SWT uses cairo, make it use cairo-gl if the user wants it and cairo-gl is installed and fallback to the current CPU-drawing if it doesnt work.

FYI: cairo-gl is deprecated and has been removed completely from recent Cairo versions: https://gitlab.freedesktop.org/cairo/cairo/-/merge_requests/287

thanks for info, i didnt know, i guess i will just wait for gtk4 and wayland and hope it will lead to hardware accelaration of the canvas

[laeubi]

A while back I use FFM to use Opengl with SW directly without require a native java opengl binding:

• Add panama binding for OpenGL to gtk #571

This was only an experiment and the binding is actually a bit bigger than needed, but it has aslo worked well with windows.

The main lmitation with SWT in general is that its GC class (compared to e.g. Graphics2D in SWT) is final and therefore it is not possible to plug in alternative implementations, e.g. for PDF rendering or SVG output or using open GL as backend and so on.

[reza1234567891]

A while back I use FFM to use Opengl with SW directly without require a native java opengl binding:

• Add panama binding for OpenGL to gtk #571

This was only an experiment and the binding is actually a bit bigger than needed, but it has aslo worked well with windows.

The main lmitation with SWT in general is that its GC class (compared to e.g. Graphics2D in SWT) is final and therefore it is not possible to plug in alternative implementations, e.g. for PDF rendering or SVG output or using open GL as backend and so on.

they are updating all of SWT to try to create a unified version for all platforms, and they seem to try to hardware accelerate it or have it as an option (something like that) , so i think asking them for changes like this in the current SWT which they want to phase out is bad timing from us