opengl: shared textures

Author: ujpv

make/test/JtregNativeJdk.gmk

@@ -96,7 +96,8 @@ ifeq ($(call isTargetOs, macosx), true)
   BUILD_JDK_JTREG_LIBRARIES_LIBS_libTestDynamicStore := \
       -framework Cocoa -framework SystemConfiguration
   BUILD_JDK_JTREG_LIBRARIES_LIBS_libSharedTexturesTest := \
-      -framework Cocoa -framework Metal
+      -framework Cocoa -framework Metal -framework OpenGL
+  BUILD_JDK_JTREG_EXCLUDE += libSharedTexturesTest.c
 else
   BUILD_JDK_JTREG_EXCLUDE += libTestMainKeyWindow.m
   BUILD_JDK_JTREG_EXCLUDE += libTestDynamicStore.m
@@ -108,6 +109,7 @@ endif
 ifeq ($(OPENJDK_TARGET_OS), windows)
   BUILD_JDK_JTREG_LIBRARIES_LIBS_libwindows_touch_robot := user32.lib
   BUILD_JDK_JTREG_EXCLUDE += libtouchscreen_device.c
+  BUILD_JDK_JTREG_LIBRARIES_LIBS_libSharedTexturesTest := gdi32.lib opengl32.lib user32.lib
 else
   ifeq ($(OPENJDK_TARGET_OS), linux)
     BUILD_JDK_JTREG_EXCLUDE += libwindows_touch_robot.c
@@ -123,6 +125,7 @@ ifeq ($(call isTargetOs, linux), true)
   BUILD_JDK_JTREG_LIBRARIES_STRIP_SYMBOLS_libFib := false
   # nio tests' libCreationTimeHelper native needs -ldl linker flag
   BUILD_JDK_JTREG_LIBRARIES_LDFLAGS_libCreationTimeHelper := -ldl
+  BUILD_JDK_JTREG_LIBRARIES_LIBS_libSharedTexturesTest := -lX11 -lGL -lGLX
 endif
 
 ifeq ($(ASAN_ENABLED), true)

src/java.desktop/linux/classes/com/jetbrains/desktop/SharedTextures.java

@@ -0,0 +1,103 @@
+/*
+ * Copyright 2025 JetBrains s.r.o.
+ * 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.jetbrains.desktop;
+
+import com.jetbrains.desktop.image.TextureWrapperImage;
+import com.jetbrains.exported.JBRApi;
+import sun.awt.image.SurfaceManager;
+import sun.awt.image.TextureWrapperSurfaceManager;
+import sun.java2d.SurfaceData;
+
+import sun.java2d.opengl.*;
+
+import java.awt.GraphicsConfiguration;
+import java.awt.GraphicsEnvironment;
+import java.awt.Image;
+
+@JBRApi.Service
+@JBRApi.Provides("SharedTextures")
+public class SharedTextures {
+    public final static int METAL_TEXTURE_TYPE = 1;
+    public final static int OPENGL_TEXTURE_TYPE = 2;
+
+    public static SharedTextures create() {
+        return new SharedTextures();
+    }
+
+    private SharedTextures() {}
+
+    public Image wrapTexture(GraphicsConfiguration gc, long texture) {
+        return new TextureWrapperImage(gc, texture);
+    }
+
+    public int getTextureType(GraphicsConfiguration gc) {
+        try {
+            if (gc instanceof GLXGraphicsConfig) {
+                return OPENGL_TEXTURE_TYPE;
+            }
+        } catch (Exception e) {
+            throw new InternalError("Unexpected exception during reflection", e);
+        }
+
+        return 0;
+    }
+
+    @Deprecated
+    public int getTextureType() {
+        GraphicsConfiguration gc = GraphicsEnvironment
+                .getLocalGraphicsEnvironment()
+                .getDefaultScreenDevice()
+                .getDefaultConfiguration();
+        return getTextureType(gc);
+    }
+
+    static SurfaceManager createSurfaceManager(GraphicsConfiguration gc, Image image, long texture) {
+        SurfaceData sd;
+        if (gc instanceof GLXGraphicsConfig glxGraphicsConfig) {
+            sd = new GLXTextureWrapperSurfaceData(glxGraphicsConfig, image, texture);
+        } else {
+            throw new IllegalArgumentException("Unsupported graphics configuration: " + gc);
+        }
+
+        return new TextureWrapperSurfaceManager(sd);
+    }
+
+    public long getSharedOpenGLContext(GraphicsConfiguration gc) {
+        if (gc instanceof GLXGraphicsConfig) {
+            return GLXGraphicsConfigExt.getSharedContext();
+        }
+
+        throw new IllegalArgumentException("Unsupported graphics configuration: " + gc);
+    }
+
+    public long getSharedOpenGLPixelFormat(GraphicsConfiguration gc) {
+        if (gc instanceof GLXGraphicsConfig) {
+            return GLXGraphicsConfigExt.getPixelFormat();
+        }
+
+        throw new IllegalArgumentException("Unsupported graphics configuration: " + gc);
+    }
+}

src/java.desktop/macosx/classes/com/jetbrains/desktop/SharedTextures.java

@@ -31,8 +31,8 @@
 import sun.awt.image.TextureWrapperSurfaceManager;
 import sun.java2d.SurfaceData;
 import sun.java2d.metal.MTLGraphicsConfig;
-import sun.java2d.metal.MTLSurfaceData;
 import sun.java2d.metal.MTLTextureWrapperSurfaceData;
+import sun.java2d.opengl.*;
 
 import java.awt.GraphicsConfiguration;
 import java.awt.GraphicsEnvironment;
@@ -42,49 +42,67 @@
 @JBRApi.Provides("SharedTextures")
 public class SharedTextures {
     public final static int METAL_TEXTURE_TYPE = 1;
-
-    private final int textureType;
+    public final static int OPENGL_TEXTURE_TYPE = 2;
 
     public static SharedTextures create() {
         return new SharedTextures();
     }
 
-    private SharedTextures() {
-        textureType = getTextureTypeImpl();
-        if (textureType == 0) {
-            throw new JBRApi.ServiceNotAvailableException();
-        }
-    }
-
-    public int getTextureType() {
-        return textureType;
-    }
+    private SharedTextures() {}
 
     public Image wrapTexture(GraphicsConfiguration gc, long texture) {
         return new TextureWrapperImage(gc, texture);
     }
 
-    private static int getTextureTypeImpl() {
+    public int getTextureType(GraphicsConfiguration gc) {
+        try {
+            if (gc instanceof MTLGraphicsConfig) {
+                return METAL_TEXTURE_TYPE;
+            } else if (gc instanceof CGLGraphicsConfig) {
+                return OPENGL_TEXTURE_TYPE;
+            }
+        } catch (Exception e) {
+            throw new InternalError("Unexpected exception during reflection", e);
+        }
+
+        return 0;
+    }
+
+    @Deprecated
+    public int getTextureType() {
         GraphicsConfiguration gc = GraphicsEnvironment
                 .getLocalGraphicsEnvironment()
                 .getDefaultScreenDevice()
                 .getDefaultConfiguration();
-
-        if (gc instanceof MTLGraphicsConfig) {
-            return METAL_TEXTURE_TYPE;
-        }
-
-        return 0;
+        return getTextureType(gc);
     }
 
     static SurfaceManager createSurfaceManager(GraphicsConfiguration gc, Image image, long texture) {
         SurfaceData sd;
         if (gc instanceof MTLGraphicsConfig mtlGraphicsConfig) {
             sd = new MTLTextureWrapperSurfaceData(mtlGraphicsConfig, image, texture);
+        } else if (gc instanceof CGLGraphicsConfig cglGraphicsConfig) {
+            sd = new CGLTextureWrapperSurfaceData(cglGraphicsConfig, image, texture);
         } else {
             throw new IllegalArgumentException("Unsupported graphics configuration: " + gc);
         }
 
         return new TextureWrapperSurfaceManager(sd);
     }
+
+    public long getSharedOpenGLContext(GraphicsConfiguration gc) {
+        if (gc instanceof CGLGraphicsConfig) {
+            return CGLGraphicsConfigExt.getSharedContext();
+        }
+
+        throw new IllegalArgumentException("Unsupported graphics configuration: " + gc);
+    }
+
+    public long getSharedOpenGLPixelFormat(GraphicsConfiguration gc) {
+        if (gc instanceof CGLGraphicsConfig) {
+            return CGLGraphicsConfigExt.getPixelFormat();
+        }
+
+        throw new IllegalArgumentException("Unsupported graphics configuration: " + gc);
+    }
 }

src/java.desktop/macosx/classes/sun/java2d/metal/MTLSurfaceDataExt.java

@@ -1,5 +1,9 @@
 package sun.java2d.metal;
 
 public class MTLSurfaceDataExt {
-    public static native boolean initWithTexture(long pData, boolean isOpaque, long texturePtr);
+    public static boolean initWithTexture(MTLSurfaceData sd, long texturePtr) {
+        return initWithTexture(sd.getNativeOps(), false, texturePtr);
+    }
+
+    private static native boolean initWithTexture(long pData, boolean isOpaque, long texturePtr);
 }

src/java.desktop/macosx/classes/sun/java2d/metal/MTLTextureWrapperSurfaceData.java

@@ -22,7 +22,7 @@ public MTLTextureWrapperSurfaceData(MTLGraphicsConfig gc, Image image, long pTex
         rq.lock();
         try {
             MTLContext.setScratchSurface(gc);
-            rq.flushAndInvokeNow(() -> success.set(MTLSurfaceDataExt.initWithTexture(getNativeOps(), false, pTexture)));
+            rq.flushAndInvokeNow(() -> success.set(MTLSurfaceDataExt.initWithTexture(this, pTexture)));
         } finally {
             rq.unlock();
         }

src/java.desktop/macosx/classes/sun/java2d/opengl/CGLGraphicsConfigExt.java

@@ -0,0 +1,6 @@
+package sun.java2d.opengl;
+
+public class CGLGraphicsConfigExt {
+    public static native long getSharedContext();
+    public static native long getPixelFormat();
+}

src/java.desktop/macosx/classes/sun/java2d/opengl/CGLSurfaceData.java

@@ -43,8 +43,8 @@ private native void initOps(OGLGraphicsConfig gc, long pConfigInfo,
                                 long pPeerData, long layerPtr, int xoff,
                                 int yoff, boolean isOpaque);
 
-    private CGLSurfaceData(CGLLayer layer, CGLGraphicsConfig gc,
-                           ColorModel cm, int type, int width, int height) {
+    protected CGLSurfaceData(CGLLayer layer, CGLGraphicsConfig gc,
+                             ColorModel cm, int type, int width, int height) {
         super(gc, cm, type);
         // TEXTURE shouldn't be scaled, it is used for managed BufferedImages.
         scale = type == TEXTURE ? 1 : gc.getDevice().getScaleFactor();

src/java.desktop/macosx/classes/sun/java2d/opengl/CGLTextureWrapperSurfaceData.java

@@ -0,0 +1,50 @@
+package sun.java2d.opengl;
+
+import sun.java2d.SurfaceData;
+
+import java.awt.*;
+import java.awt.image.ColorModel;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+public class CGLTextureWrapperSurfaceData extends CGLSurfaceData {
+
+    public CGLTextureWrapperSurfaceData(CGLGraphicsConfig gc, Image image, long textureId) {
+        super(null, gc, ColorModel.getRGBdefault(), RT_TEXTURE, 0, 0);
+
+        OGLRenderQueue rq = OGLRenderQueue.getInstance();
+        AtomicBoolean success = new AtomicBoolean(false);
+        rq.lock();
+        try {
+            OGLContext.setScratchSurface(gc);
+            rq.flushAndInvokeNow(() -> success.set(OGLSurfaceDataExt.initWithTexture(this, textureId)));
+        } finally {
+            rq.unlock();
+        }
+
+        if (!success.get()) {
+            throw new IllegalArgumentException("Failed to init the surface data");
+        }
+    }
+
+    @Override
+    public SurfaceData getReplacement() {
+        throw new UnsupportedOperationException();
+    }
+
+    @Override
+    public Rectangle getBounds() {
+        return getNativeBounds();
+    }
+
+    @Override
+    public Object getDestination() {
+        return null;
+    }
+
+    @Override
+    public void flush() {
+        // reset the texture id first to avoid the texture deallocation
+        OGLSurfaceDataExt.resetTextureId(this);
+        super.flush();
+    }
+}

src/java.desktop/macosx/native/libawt_lwawt/java2d/opengl/CGLGraphicsConfigExt.m

@@ -0,0 +1,18 @@
+#import "sun_java2d_opengl_CGLGraphicsConfigExt.h"
+
+#import "JNIUtilities.h"
+
+extern NSOpenGLContext *sharedContext;
+extern NSOpenGLPixelFormat *sharedPixelFormat;
+
+JNIEXPORT jlong JNICALL
+Java_sun_java2d_opengl_CGLGraphicsConfigExt_getSharedContext
+    (JNIEnv *env, jclass cls) {
+  return ptr_to_jlong(sharedContext.CGLContextObj) ;
+}
+
+JNIEXPORT jlong JNICALL
+Java_sun_java2d_opengl_CGLGraphicsConfigExt_getPixelFormat
+    (JNIEnv *env, jclass cls) {
+  return ptr_to_jlong(sharedPixelFormat.CGLPixelFormatObj);
+}

src/java.desktop/share/classes/com/jetbrains/desktop/image/TextureWrapperImage.java

@@ -138,21 +138,15 @@ private static SurfaceManager createManager(GraphicsConfiguration gc, Image imag
         }
 
         try {
-            if (gc == null) {
-                throw new IllegalArgumentException("GraphicsConfiguration cannot be null");
-            }
-            if (texture == 0) {
-                throw new IllegalArgumentException("Invalid texture");
-            }
-
             return (SurfaceManager) createSurfaceManagerMethod.invoke(null, gc, image, texture);
-        } catch (java.lang.reflect.InvocationTargetException e) {
-            if (e.getCause() instanceof IllegalArgumentException iae) {
+        }
+        catch (java.lang.reflect.InvocationTargetException e) {
+            Throwable cause = e.getCause();
+            if (cause instanceof IllegalArgumentException iae) {
                 throw iae;
-            } else if (e.getCause() instanceof UnsupportedOperationException uoe) {
+            } else if (cause instanceof UnsupportedOperationException uoe) {
                 throw uoe;
             } else {
-                Throwable cause = e.getTargetException();
                 String message = String.format("Failed to create surface manager - Cause: %s, Message: %s",
                         cause.getClass().getName(),
                         cause.getMessage());