1 /*
2 * Copyright (c) 2011, 2015, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation. Oracle designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Oracle in the LICENSE file that accompanied this code.
10 *
11 * This code is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 * version 2 for more details (a copy is included in the LICENSE file that
15 * accompanied this code).
16 *
17 * You should have received a copy of the GNU General Public License version
18 * 2 along with this work; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 * or visit www.oracle.com if you need additional information or have any
23 * questions.
24 */
25
26 #import <stdlib.h>
27 #import <JavaNativeFoundation/JavaNativeFoundation.h>
28
29 #import "sun_java2d_opengl_CGLSurfaceData.h"
30
31 #import "jni.h"
32 #import "jni_util.h"
33 #import "OGLRenderQueue.h"
34 #import "CGLGraphicsConfig.h"
35 #import "CGLSurfaceData.h"
36 #import "CGLLayer.h"
37 #import "ThreadUtilities.h"
38
39 /* JDK's glext.h is already included and will prevent the Apple glext.h
40 * being included, so define the externs directly
41 */
42 extern void glBindFramebufferEXT(GLenum target, GLuint framebuffer);
43 extern CGLError CGLTexImageIOSurface2D(
44 CGLContextObj ctx, GLenum target, GLenum internal_format,
45 GLsizei width, GLsizei height, GLenum format, GLenum type,
46 IOSurfaceRef ioSurface, GLuint plane);
47
48 /**
49 * The methods in this file implement the native windowing system specific
50 * layer (CGL) for the OpenGL-based Java 2D pipeline.
51 */
52
53 #pragma mark -
54 #pragma mark "--- Mac OS X specific methods for GL pipeline ---"
55
56 // TODO: hack that's called from OGLRenderQueue to test out unlockFocus behavior
57 #if 0
58 void
59 OGLSD_UnlockFocus(OGLContext *oglc, OGLSDOps *dstOps)
60 {
61 CGLCtxInfo *ctxinfo = (CGLCtxInfo *)oglc->ctxInfo;
62 CGLSDOps *cglsdo = (CGLSDOps *)dstOps->privOps;
63 fprintf(stderr, "about to unlock focus: %p %p\n",
64 cglsdo->peerData, ctxinfo->context);
65
66 NSOpenGLView *nsView = cglsdo->peerData;
67 if (nsView != NULL) {
68 JNF_COCOA_ENTER(env);
69 [nsView unlockFocus];
70 JNF_COCOA_EXIT(env);
71 }
72 }
73 #endif
74
75 /**
76 * Makes the given context current to its associated "scratch" surface. If
77 * the operation is successful, this method will return JNI_TRUE; otherwise,
78 * returns JNI_FALSE.
79 */
80 static jboolean
81 CGLSD_MakeCurrentToScratch(JNIEnv *env, OGLContext *oglc)
82 {
83 J2dTraceLn(J2D_TRACE_INFO, "CGLSD_MakeCurrentToScratch");
84
85 if (oglc == NULL) {
86 J2dRlsTraceLn(J2D_TRACE_ERROR,
87 "CGLSD_MakeCurrentToScratch: context is null");
88 return JNI_FALSE;
89 }
90
91 JNF_COCOA_ENTER(env);
92
93 CGLCtxInfo *ctxinfo = (CGLCtxInfo *)oglc->ctxInfo;
94 #if USE_NSVIEW_FOR_SCRATCH
95 [ctxinfo->context makeCurrentContext];
96 [ctxinfo->context setView: ctxinfo->scratchSurface];
97 #else
98 [ctxinfo->context clearDrawable];
99 [ctxinfo->context makeCurrentContext];
100 [ctxinfo->context setPixelBuffer: ctxinfo->scratchSurface
101 cubeMapFace: 0
102 mipMapLevel: 0
103 currentVirtualScreen: [ctxinfo->context currentVirtualScreen]];
104 #endif
105
106 JNF_COCOA_EXIT(env);
107
108 return JNI_TRUE;
109 }
110
111 /**
112 * This function disposes of any native windowing system resources associated
113 * with this surface.
114 */
115 void
116 OGLSD_DestroyOGLSurface(JNIEnv *env, OGLSDOps *oglsdo)
117 {
118 J2dTraceLn(J2D_TRACE_INFO, "OGLSD_DestroyOGLSurface");
119
120 JNF_COCOA_ENTER(env);
121
122 CGLSDOps *cglsdo = (CGLSDOps *)oglsdo->privOps;
123 if (oglsdo->drawableType == OGLSD_WINDOW) {
124 // detach the NSView from the NSOpenGLContext
125 CGLGraphicsConfigInfo *cglInfo = cglsdo->configInfo;
126 OGLContext *oglc = cglInfo->context;
127 CGLCtxInfo *ctxinfo = (CGLCtxInfo *)oglc->ctxInfo;
128 [ctxinfo->context clearDrawable];
129 }
130
131 oglsdo->drawableType = OGLSD_UNDEFINED;
132
133 JNF_COCOA_EXIT(env);
134 }
135
136 /**
137 * Returns a pointer (as a jlong) to the native CGLGraphicsConfigInfo
138 * associated with the given OGLSDOps. This method can be called from
139 * shared code to retrieve the native GraphicsConfig data in a platform-
140 * independent manner.
141 */
142 jlong
143 OGLSD_GetNativeConfigInfo(OGLSDOps *oglsdo)
144 {
145 J2dTraceLn(J2D_TRACE_INFO, "OGLSD_GetNativeConfigInfo");
146
147 if (oglsdo == NULL) {
148 J2dRlsTraceLn(J2D_TRACE_ERROR, "OGLSD_GetNativeConfigInfo: ops are null");
149 return 0L;
150 }
151
152 CGLSDOps *cglsdo = (CGLSDOps *)oglsdo->privOps;
153 if (cglsdo == NULL) {
154 J2dRlsTraceLn(J2D_TRACE_ERROR, "OGLSD_GetNativeConfigInfo: cgl ops are null");
155 return 0L;
156 }
157
158 return ptr_to_jlong(cglsdo->configInfo);
159 }
160
161 /**
162 * Makes the given GraphicsConfig's context current to its associated
163 * "scratch" surface. If there is a problem making the context current,
164 * this method will return NULL; otherwise, returns a pointer to the
165 * OGLContext that is associated with the given GraphicsConfig.
166 */
167 OGLContext *
168 OGLSD_SetScratchSurface(JNIEnv *env, jlong pConfigInfo)
169 {
170 J2dTraceLn(J2D_TRACE_INFO, "OGLSD_SetScratchContext");
171
172 CGLGraphicsConfigInfo *cglInfo = (CGLGraphicsConfigInfo *)jlong_to_ptr(pConfigInfo);
173 if (cglInfo == NULL) {
174 J2dRlsTraceLn(J2D_TRACE_ERROR, "OGLSD_SetScratchContext: cgl config info is null");
175 return NULL;
176 }
177
178 OGLContext *oglc = cglInfo->context;
179 if (oglc == NULL) {
180 J2dRlsTraceLn(J2D_TRACE_ERROR, "OGLSD_SetScratchContext: ogl context is null");
181 return NULL;
182 }
183
184 CGLCtxInfo *ctxinfo = (CGLCtxInfo *)oglc->ctxInfo;
185
186 JNF_COCOA_ENTER(env);
187
188 // avoid changing the context's target view whenever possible, since
189 // calling setView causes flickering; as long as our context is current
190 // to some view, it's not necessary to switch to the scratch surface
191 if ([ctxinfo->context view] == nil) {
192 // it seems to be necessary to explicitly flush between context changes
193 OGLContext *currentContext = OGLRenderQueue_GetCurrentContext();
194 if (currentContext != NULL) {
195 j2d_glFlush();
196 }
197
198 if (!CGLSD_MakeCurrentToScratch(env, oglc)) {
199 return NULL;
200 }
201 // make sure our context is current
202 } else if ([NSOpenGLContext currentContext] != ctxinfo->context) {
203 [ctxinfo->context makeCurrentContext];
204 }
205
206 if (OGLC_IS_CAP_PRESENT(oglc, CAPS_EXT_FBOBJECT)) {
207 // the GL_EXT_framebuffer_object extension is present, so this call
208 // will ensure that we are bound to the scratch surface (and not
209 // some other framebuffer object)
210 j2d_glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
211 }
212
213 JNF_COCOA_EXIT(env);
214
215 return oglc;
216 }
217
218 /**
219 * Makes a context current to the given source and destination
220 * surfaces. If there is a problem making the context current, this method
221 * will return NULL; otherwise, returns a pointer to the OGLContext that is
222 * associated with the destination surface.
223 */
224 OGLContext *
225 OGLSD_MakeOGLContextCurrent(JNIEnv *env, OGLSDOps *srcOps, OGLSDOps *dstOps)
226 {
227 J2dTraceLn(J2D_TRACE_INFO, "OGLSD_MakeOGLContextCurrent");
228
229 CGLSDOps *dstCGLOps = (CGLSDOps *)dstOps->privOps;
230
231 J2dTraceLn4(J2D_TRACE_VERBOSE, " src: %d %p dst: %d %p", srcOps->drawableType, srcOps, dstOps->drawableType, dstOps);
232
233 OGLContext *oglc = dstCGLOps->configInfo->context;
234 if (oglc == NULL) {
235 J2dRlsTraceLn(J2D_TRACE_ERROR, "OGLSD_MakeOGLContextCurrent: context is null");
236 return NULL;
237 }
238
239 CGLCtxInfo *ctxinfo = (CGLCtxInfo *)oglc->ctxInfo;
240
241 // it seems to be necessary to explicitly flush between context changes
242 OGLContext *currentContext = OGLRenderQueue_GetCurrentContext();
243 if (currentContext != NULL) {
244 j2d_glFlush();
245 }
246
247 if (dstOps->drawableType == OGLSD_FBOBJECT) {
248 // first make sure we have a current context (if the context isn't
249 // already current to some drawable, we will make it current to
250 // its scratch surface)
251 if (oglc != currentContext) {
252 if (!CGLSD_MakeCurrentToScratch(env, oglc)) {
253 return NULL;
254 }
255 }
256
257 // now bind to the fbobject associated with the destination surface;
258 // this means that all rendering will go into the fbobject destination
259 // (note that we unbind the currently bound texture first; this is
260 // recommended procedure when binding an fbobject)
261 j2d_glBindTexture(GL_TEXTURE_2D, 0);
262 j2d_glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, dstOps->fbobjectID);
263
264 return oglc;
265 }
266
267 JNF_COCOA_ENTER(env);
268
269 CGLSDOps *cglsdo = (CGLSDOps *)dstOps->privOps;
270 NSView *nsView = (NSView *)cglsdo->peerData;
271
272 if ([ctxinfo->context view] != nsView) {
273 [ctxinfo->context makeCurrentContext];
274 [ctxinfo->context setView: nsView];
275 }
276
277 if (OGLC_IS_CAP_PRESENT(oglc, CAPS_EXT_FBOBJECT)) {
278 // the GL_EXT_framebuffer_object extension is present, so we
279 // must bind to the default (windowing system provided)
280 // framebuffer
281 j2d_glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
282 }
283
284 JNF_COCOA_EXIT(env);
285
286 return oglc;
287 }
288
289 /**
290 * This function initializes a native window surface and caches the window
291 * bounds in the given OGLSDOps. Returns JNI_TRUE if the operation was
292 * successful; JNI_FALSE otherwise.
293 */
294 jboolean
295 OGLSD_InitOGLWindow(JNIEnv *env, OGLSDOps *oglsdo)
296 {
297 J2dTraceLn(J2D_TRACE_INFO, "OGLSD_InitOGLWindow");
298
299 if (oglsdo == NULL) {
300 J2dRlsTraceLn(J2D_TRACE_ERROR, "OGLSD_InitOGLWindow: ops are null");
301 return JNI_FALSE;
302 }
303
304 CGLSDOps *cglsdo = (CGLSDOps *)oglsdo->privOps;
305 if (cglsdo == NULL) {
306 J2dRlsTraceLn(J2D_TRACE_ERROR, "OGLSD_InitOGLWindow: cgl ops are null");
307 return JNI_FALSE;
308 }
309
310 AWTView *v = cglsdo->peerData;
311 if (v == NULL) {
312 J2dRlsTraceLn(J2D_TRACE_ERROR, "OGLSD_InitOGLWindow: view is invalid");
313 return JNI_FALSE;
314 }
315
316 JNF_COCOA_ENTER(env);
317 NSRect surfaceBounds = [v bounds];
318 oglsdo->drawableType = OGLSD_WINDOW;
319 oglsdo->isOpaque = JNI_TRUE;
320 oglsdo->width = surfaceBounds.size.width;
321 oglsdo->height = surfaceBounds.size.height;
322 JNF_COCOA_EXIT(env);
323
324 J2dTraceLn2(J2D_TRACE_VERBOSE, " created window: w=%d h=%d", oglsdo->width, oglsdo->height);
325
326 return JNI_TRUE;
327 }
328
329 void
330 OGLSD_SwapBuffers(JNIEnv *env, jlong pPeerData)
331 {
332 J2dTraceLn(J2D_TRACE_INFO, "OGLSD_SwapBuffers");
333
334 JNF_COCOA_ENTER(env);
335 [[NSOpenGLContext currentContext] flushBuffer];
336 JNF_COCOA_EXIT(env);
337 }
338
339 void
340 OGLSD_Flush(JNIEnv *env)
341 {
342 OGLSDOps *dstOps = OGLRenderQueue_GetCurrentDestination();
343 if (dstOps != NULL) {
344 CGLSDOps *dstCGLOps = (CGLSDOps *)dstOps->privOps;
345 CGLLayer *layer = (CGLLayer*)dstCGLOps->layer;
346 if (layer != NULL) {
347 [JNFRunLoop performOnMainThreadWaiting:NO withBlock:^(){
348 AWT_ASSERT_APPKIT_THREAD;
349 [layer setNeedsDisplay];
350
351 #ifdef REMOTELAYER
352 /* If there's a remote layer (being used for testing)
353 * then we want to have that also receive the texture.
354 * First sync. up its dimensions with that of the layer
355 * we have attached to the local window and tell it that
356 * it also needs to copy the texture.
357 */
358 if (layer.remoteLayer != nil) {
359 CGLLayer* remoteLayer = layer.remoteLayer;
360 remoteLayer.target = GL_TEXTURE_2D;
361 remoteLayer.textureID = layer.textureID;
362 remoteLayer.textureWidth = layer.textureWidth;
363 remoteLayer.textureHeight = layer.textureHeight;
364 [remoteLayer setNeedsDisplay];
365 }
366 #endif /* REMOTELAYER */
367 }];
368 }
369 }
370 }
371
372 #pragma mark -
373 #pragma mark "--- CGLSurfaceData methods ---"
374
375 extern LockFunc OGLSD_Lock;
376 extern GetRasInfoFunc OGLSD_GetRasInfo;
377 extern UnlockFunc OGLSD_Unlock;
378 extern DisposeFunc OGLSD_Dispose;
379
380 JNIEXPORT void JNICALL
381 Java_sun_java2d_opengl_CGLSurfaceData_initOps
382 (JNIEnv *env, jobject cglsd,
383 jlong pConfigInfo, jlong pPeerData, jlong layerPtr,
384 jint xoff, jint yoff, jboolean isOpaque)
385 {
386 J2dTraceLn(J2D_TRACE_INFO, "CGLSurfaceData_initOps");
387 J2dTraceLn1(J2D_TRACE_INFO, " pPeerData=%p", jlong_to_ptr(pPeerData));
388 J2dTraceLn2(J2D_TRACE_INFO, " xoff=%d, yoff=%d", (int)xoff, (int)yoff);
389
390 OGLSDOps *oglsdo = (OGLSDOps *)
391 SurfaceData_InitOps(env, cglsd, sizeof(OGLSDOps));
392 CGLSDOps *cglsdo = (CGLSDOps *)malloc(sizeof(CGLSDOps));
393 if (cglsdo == NULL) {
394 JNU_ThrowOutOfMemoryError(env, "creating native cgl ops");
395 return;
396 }
397
398 oglsdo->privOps = cglsdo;
399
400 oglsdo->sdOps.Lock = OGLSD_Lock;
401 oglsdo->sdOps.GetRasInfo = OGLSD_GetRasInfo;
402 oglsdo->sdOps.Unlock = OGLSD_Unlock;
403 oglsdo->sdOps.Dispose = OGLSD_Dispose;
404
405 oglsdo->drawableType = OGLSD_UNDEFINED;
406 oglsdo->activeBuffer = GL_FRONT;
407 oglsdo->needsInit = JNI_TRUE;
408 oglsdo->xOffset = xoff;
409 oglsdo->yOffset = yoff;
410 oglsdo->isOpaque = isOpaque;
411
412 cglsdo->peerData = (AWTView *)jlong_to_ptr(pPeerData);
413 cglsdo->layer = (CGLLayer *)jlong_to_ptr(layerPtr);
414 cglsdo->configInfo = (CGLGraphicsConfigInfo *)jlong_to_ptr(pConfigInfo);
415
416 if (cglsdo->configInfo == NULL) {
417 free(cglsdo);
418 JNU_ThrowNullPointerException(env, "Config info is null in initOps");
419 }
420 }
421
422 JNIEXPORT void JNICALL
423 Java_sun_java2d_opengl_CGLSurfaceData_clearWindow
424 (JNIEnv *env, jobject cglsd)
425 {
426 J2dTraceLn(J2D_TRACE_INFO, "CGLSurfaceData_clearWindow");
427
428 OGLSDOps *oglsdo = (OGLSDOps*) SurfaceData_GetOps(env, cglsd);
429 CGLSDOps *cglsdo = (CGLSDOps*) oglsdo->privOps;
430
431 cglsdo->peerData = NULL;
432 cglsdo->layer = NULL;
433 }
434
435 #pragma mark -
436 #pragma mark "--- CGLSurfaceData methods - Mac OS X specific ---"
437
438 // Must be called on the QFT...
439 JNIEXPORT void JNICALL
440 Java_sun_java2d_opengl_CGLSurfaceData_validate
441 (JNIEnv *env, jobject jsurfacedata,
442 jint xoff, jint yoff, jint width, jint height, jboolean isOpaque)
443 {
444 J2dTraceLn2(J2D_TRACE_INFO, "CGLSurfaceData_validate: w=%d h=%d", width, height);
445
446 OGLSDOps *oglsdo = (OGLSDOps*)SurfaceData_GetOps(env, jsurfacedata);
447 oglsdo->needsInit = JNI_TRUE;
448 oglsdo->xOffset = xoff;
449 oglsdo->yOffset = yoff;
450
451 oglsdo->width = width;
452 oglsdo->height = height;
453 oglsdo->isOpaque = isOpaque;
454
455 if (oglsdo->drawableType == OGLSD_WINDOW) {
456 OGLContext_SetSurfaces(env, ptr_to_jlong(oglsdo), ptr_to_jlong(oglsdo));
457
458 // we have to explicitly tell the NSOpenGLContext that its target
459 // drawable has changed size
460 CGLSDOps *cglsdo = (CGLSDOps *)oglsdo->privOps;
461 OGLContext *oglc = cglsdo->configInfo->context;
462 CGLCtxInfo *ctxinfo = (CGLCtxInfo *)oglc->ctxInfo;
463
464 JNF_COCOA_ENTER(env);
465 [ctxinfo->context update];
466 JNF_COCOA_EXIT(env);
467 }
468 }