1 /*
2 * Copyright (c) 2019, 2019, 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
28 #import "sun_java2d_metal_MetalSurfaceData.h"
29
30 #import "jni_util.h"
31 #import "MetalRenderQueue.h"
32 #import "MetalGraphicsConfig.h"
33 #import "MetalSurfaceData.h"
34 #import "ThreadUtilities.h"
35
36 /* JDK's glext.h is already included and will prevent the Apple glext.h
37 * being included, so define the externs directly
38 */
39 /*extern void glBindFramebufferEXT(GLenum target, GLuint framebuffer);
40 extern CGLError CGLTexImageIOSurface2D(
41 CGLContextObj ctx, GLenum target, GLenum internal_format,
42 GLsizei width, GLsizei height, GLenum format, GLenum type,
43 IOSurfaceRef ioSurface, GLuint plane);*/
44
45 /**
46 * The methods in this file implement the native windowing system specific
47 * layer (CGL) for the OpenGL-based Java 2D pipeline.
48 */
49
50 #pragma mark -
51 #pragma mark "--- Mac OS X specific methods for GL pipeline ---"
52
53 // TODO: hack that's called from OGLRenderQueue to test out unlockFocus behavior
54 /*#if 0
55 void
56 OGLSD_UnlockFocus(OGLContext *oglc, OGLSDOps *dstOps)
57 {
58 CGLCtxInfo *ctxinfo = (CGLCtxInfo *)oglc->ctxInfo;
59 CGLSDOps *cglsdo = (CGLSDOps *)dstOps->privOps;
60 fprintf(stderr, "about to unlock focus: %p %p\n",
61 cglsdo->peerData, ctxinfo->context);
62
63 NSOpenGLView *nsView = cglsdo->peerData;
64 if (nsView != NULL) {
65 JNF_COCOA_ENTER(env);
66 [nsView unlockFocus];
67 JNF_COCOA_EXIT(env);
68 }
69 }
70 #endif*/
71
72 /**
73 * Makes the given context current to its associated "scratch" surface. If
74 * the operation is successful, this method will return JNI_TRUE; otherwise,
75 * returns JNI_FALSE.
76 */
77 /*static jboolean
78 CGLSD_MakeCurrentToScratch(JNIEnv *env, OGLContext *oglc)
79 {
80 J2dTraceLn(J2D_TRACE_INFO, "CGLSD_MakeCurrentToScratch");
81
82 if (oglc == NULL) {
83 J2dRlsTraceLn(J2D_TRACE_ERROR,
84 "CGLSD_MakeCurrentToScratch: context is null");
85 return JNI_FALSE;
86 }
87
88 JNF_COCOA_ENTER(env);
89
90 CGLCtxInfo *ctxinfo = (CGLCtxInfo *)oglc->ctxInfo;
91 #if USE_NSVIEW_FOR_SCRATCH
92 [ctxinfo->context makeCurrentContext];
93 [ctxinfo->context setView: ctxinfo->scratchSurface];
94 #else
95 [ctxinfo->context clearDrawable];
96 [ctxinfo->context makeCurrentContext];
97 [ctxinfo->context setPixelBuffer: ctxinfo->scratchSurface
98 cubeMapFace: 0
99 mipMapLevel: 0
100 currentVirtualScreen: [ctxinfo->context currentVirtualScreen]];
101 #endif
102
103 JNF_COCOA_EXIT(env);
104
105 return JNI_TRUE;
106 }*/
107
108 /**
109 * This function disposes of any native windowing system resources associated
110 * with this surface.
111 */
112 /*void
113 OGLSD_DestroyOGLSurface(JNIEnv *env, OGLSDOps *oglsdo)
114 {
115 J2dTraceLn(J2D_TRACE_INFO, "OGLSD_DestroyOGLSurface");
116
117 JNF_COCOA_ENTER(env);
118
119 CGLSDOps *cglsdo = (CGLSDOps *)oglsdo->privOps;
120 if (oglsdo->drawableType == OGLSD_WINDOW) {
121 // detach the NSView from the NSOpenGLContext
122 CGLGraphicsConfigInfo *cglInfo = cglsdo->configInfo;
123 OGLContext *oglc = cglInfo->context;
124 CGLCtxInfo *ctxinfo = (CGLCtxInfo *)oglc->ctxInfo;
125 [ctxinfo->context clearDrawable];
126 }
127
128 oglsdo->drawableType = OGLSD_UNDEFINED;
129
130 JNF_COCOA_EXIT(env);
131 }*/
132
133 /**
134 * Returns a pointer (as a jlong) to the native CGLGraphicsConfigInfo
135 * associated with the given OGLSDOps. This method can be called from
136 * shared code to retrieve the native GraphicsConfig data in a platform-
137 * independent manner.
138 */
139 /*jlong
140 OGLSD_GetNativeConfigInfo(OGLSDOps *oglsdo)
141 {
142 J2dTraceLn(J2D_TRACE_INFO, "OGLSD_GetNativeConfigInfo");
143
144 if (oglsdo == NULL) {
145 J2dRlsTraceLn(J2D_TRACE_ERROR, "OGLSD_GetNativeConfigInfo: ops are null");
146 return 0L;
147 }
148
149 CGLSDOps *cglsdo = (CGLSDOps *)oglsdo->privOps;
150 if (cglsdo == NULL) {
151 J2dRlsTraceLn(J2D_TRACE_ERROR, "OGLSD_GetNativeConfigInfo: cgl ops are null");
152 return 0L;
153 }
154
155 return ptr_to_jlong(cglsdo->configInfo);
156 }*/
157
158 /**
159 * Makes the given GraphicsConfig's context current to its associated
160 * "scratch" surface. If there is a problem making the context current,
161 * this method will return NULL; otherwise, returns a pointer to the
162 * OGLContext that is associated with the given GraphicsConfig.
163 */
164 /*OGLContext *
165 OGLSD_SetScratchSurface(JNIEnv *env, jlong pConfigInfo)
166 {
167 J2dTraceLn(J2D_TRACE_INFO, "OGLSD_SetScratchContext");
168
169 CGLGraphicsConfigInfo *cglInfo = (CGLGraphicsConfigInfo *)jlong_to_ptr(pConfigInfo);
170 if (cglInfo == NULL) {
171 J2dRlsTraceLn(J2D_TRACE_ERROR, "OGLSD_SetScratchContext: cgl config info is null");
172 return NULL;
173 }
174
175 OGLContext *oglc = cglInfo->context;
176 if (oglc == NULL) {
177 J2dRlsTraceLn(J2D_TRACE_ERROR, "OGLSD_SetScratchContext: ogl context is null");
178 return NULL;
179 }
180
181 CGLCtxInfo *ctxinfo = (CGLCtxInfo *)oglc->ctxInfo;
182
183 JNF_COCOA_ENTER(env);
184
185 // avoid changing the context's target view whenever possible, since
186 // calling setView causes flickering; as long as our context is current
187 // to some view, it's not necessary to switch to the scratch surface
188 if ([ctxinfo->context view] == nil) {
189 // it seems to be necessary to explicitly flush between context changes
190 OGLContext *currentContext = OGLRenderQueue_GetCurrentContext();
191 if (currentContext != NULL) {
192 j2d_glFlush();
193 }
194
195 if (!CGLSD_MakeCurrentToScratch(env, oglc)) {
196 return NULL;
197 }
198 // make sure our context is current
199 } else if ([NSOpenGLContext currentContext] != ctxinfo->context) {
200 [ctxinfo->context makeCurrentContext];
201 }
202
203 if (OGLC_IS_CAP_PRESENT(oglc, CAPS_EXT_FBOBJECT)) {
204 // the GL_EXT_framebuffer_object extension is present, so this call
205 // will ensure that we are bound to the scratch surface (and not
206 // some other framebuffer object)
207 j2d_glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
208 }
209
210 JNF_COCOA_EXIT(env);
211
212 return oglc;
213 }*/
214
215 /**
216 * Makes a context current to the given source and destination
217 * surfaces. If there is a problem making the context current, this method
218 * will return NULL; otherwise, returns a pointer to the OGLContext that is
219 * associated with the destination surface.
220 */
221 /*OGLContext *
222 OGLSD_MakeOGLContextCurrent(JNIEnv *env, OGLSDOps *srcOps, OGLSDOps *dstOps)
223 {
224 J2dTraceLn(J2D_TRACE_INFO, "OGLSD_MakeOGLContextCurrent");
225
226 CGLSDOps *dstCGLOps = (CGLSDOps *)dstOps->privOps;
227
228 J2dTraceLn4(J2D_TRACE_VERBOSE, " src: %d %p dst: %d %p", srcOps->drawableType, srcOps, dstOps->drawableType, dstOps);
229
230 OGLContext *oglc = dstCGLOps->configInfo->context;
231 if (oglc == NULL) {
232 J2dRlsTraceLn(J2D_TRACE_ERROR, "OGLSD_MakeOGLContextCurrent: context is null");
233 return NULL;
234 }
235
236 CGLCtxInfo *ctxinfo = (CGLCtxInfo *)oglc->ctxInfo;
237
238 // it seems to be necessary to explicitly flush between context changes
239 OGLContext *currentContext = OGLRenderQueue_GetCurrentContext();
240 if (currentContext != NULL) {
241 j2d_glFlush();
242 }
243
244 if (dstOps->drawableType == OGLSD_FBOBJECT) {
245 // first make sure we have a current context (if the context isn't
246 // already current to some drawable, we will make it current to
247 // its scratch surface)
248 if (oglc != currentContext) {
249 if (!CGLSD_MakeCurrentToScratch(env, oglc)) {
250 return NULL;
251 }
252 }
253
254 // now bind to the fbobject associated with the destination surface;
255 // this means that all rendering will go into the fbobject destination
256 // (note that we unbind the currently bound texture first; this is
257 // recommended procedure when binding an fbobject)
258 j2d_glBindTexture(GL_TEXTURE_2D, 0);
259 j2d_glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, dstOps->fbobjectID);
260
261 return oglc;
262 }
263
264 JNF_COCOA_ENTER(env);
265
266 CGLSDOps *cglsdo = (CGLSDOps *)dstOps->privOps;
267 NSView *nsView = (NSView *)cglsdo->peerData;
268
269 if ([ctxinfo->context view] != nsView) {
270 [ctxinfo->context makeCurrentContext];
271 [ctxinfo->context setView: nsView];
272 }
273
274 if (OGLC_IS_CAP_PRESENT(oglc, CAPS_EXT_FBOBJECT)) {
275 // the GL_EXT_framebuffer_object extension is present, so we
276 // must bind to the default (windowing system provided)
277 // framebuffer
278 j2d_glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
279 }
280
281 JNF_COCOA_EXIT(env);
282
283 return oglc;
284 }*/
285
286 /**
287 * This function initializes a native window surface and caches the window
288 * bounds in the given OGLSDOps. Returns JNI_TRUE if the operation was
289 * successful; JNI_FALSE otherwise.
290 */
291 /*jboolean
292 OGLSD_InitOGLWindow(JNIEnv *env, OGLSDOps *oglsdo)
293 {
294 J2dTraceLn(J2D_TRACE_INFO, "OGLSD_InitOGLWindow");
295
296 if (oglsdo == NULL) {
297 J2dRlsTraceLn(J2D_TRACE_ERROR, "OGLSD_InitOGLWindow: ops are null");
298 return JNI_FALSE;
299 }
300
301 CGLSDOps *cglsdo = (CGLSDOps *)oglsdo->privOps;
302 if (cglsdo == NULL) {
303 J2dRlsTraceLn(J2D_TRACE_ERROR, "OGLSD_InitOGLWindow: cgl ops are null");
304 return JNI_FALSE;
305 }
306
307 AWTView *v = cglsdo->peerData;
308 if (v == NULL) {
309 J2dRlsTraceLn(J2D_TRACE_ERROR, "OGLSD_InitOGLWindow: view is invalid");
310 return JNI_FALSE;
311 }
312
313 JNF_COCOA_ENTER(env);
314 NSRect surfaceBounds = [v bounds];
315 oglsdo->drawableType = OGLSD_WINDOW;
316 oglsdo->isOpaque = JNI_TRUE;
317 oglsdo->width = surfaceBounds.size.width;
318 oglsdo->height = surfaceBounds.size.height;
319 JNF_COCOA_EXIT(env);
320
321 J2dTraceLn2(J2D_TRACE_VERBOSE, " created window: w=%d h=%d", oglsdo->width, oglsdo->height);
322
323 return JNI_TRUE;
324 }
325
326 void
327 OGLSD_SwapBuffers(JNIEnv *env, jlong pPeerData)
328 {
329 J2dTraceLn(J2D_TRACE_INFO, "OGLSD_SwapBuffers");
330
331 JNF_COCOA_ENTER(env);
332 [[NSOpenGLContext currentContext] flushBuffer];
333 JNF_COCOA_EXIT(env);
334 }*/
335
336 /*void
337 OGLSD_Flush(JNIEnv *env)
338 {
339 OGLSDOps *dstOps = OGLRenderQueue_GetCurrentDestination();
340 if (dstOps != NULL) {
341 CGLSDOps *dstCGLOps = (CGLSDOps *)dstOps->privOps;
342 CGLLayer *layer = (CGLLayer*)dstCGLOps->layer;
343 if (layer != NULL) {
344 [JNFRunLoop performOnMainThreadWaiting:NO withBlock:^(){
345 AWT_ASSERT_APPKIT_THREAD;
346 [layer setNeedsDisplay];
347
348 #ifdef REMOTELAYER*/
349 /* If there's a remote layer (being used for testing)
350 * then we want to have that also receive the texture.
351 * First sync. up its dimensions with that of the layer
352 * we have attached to the local window and tell it that
353 * it also needs to copy the texture.
354 */
355 /*if (layer.remoteLayer != nil) {
356 CGLLayer* remoteLayer = layer.remoteLayer;
357 remoteLayer.target = GL_TEXTURE_2D;
358 remoteLayer.textureID = layer.textureID;
359 remoteLayer.textureWidth = layer.textureWidth;
360 remoteLayer.textureHeight = layer.textureHeight;
361 [remoteLayer setNeedsDisplay];
362 }
363 #endif*/ /* REMOTELAYER */
364 //}];
365 //}
366 //}
367 //}
368
369 #pragma mark -
370 #pragma mark "--- MetalSurfaceData methods ---"
371
372 //extern LockFunc OGLSD_Lock;
373 //extern GetRasInfoFunc OGLSD_GetRasInfo;
374 //extern UnlockFunc OGLSD_Unlock;
375 //extern DisposeFunc OGLSD_Dispose;
376
377 JNIEXPORT void JNICALL
378 Java_sun_java2d_metal_MetalSurfaceData_initOps
379 (JNIEnv* env, jobject metalsd,
380 jlong pConfigInfo, jlong pPeerData, jlong layerPtr,
381 jint xoff, jint yoff, jboolean isOpaque)
382 {
383 //J2dTraceLn(J2D_TRACE_INFO, "MetalSurfaceData_initOps");
384 //J2dTraceLn1(J2D_TRACE_INFO, " pPeerData=%p", jlong_to_ptr(pPeerData));
385 //J2dTraceLn2(J2D_TRACE_INFO, " xoff=%d, yoff=%d", (int)xoff, (int)yoff);
386
387 //fprintf(stdout, "MetalSurfaceData_initOps\n");fflush(stdout);
388 MetalSDOps* metalsdo = (MetalSDOps*)
389 SurfaceData_InitOps(env, metalsd, sizeof(MetalSDOps));
390 if (metalsdo == NULL) {
391 JNU_ThrowOutOfMemoryError(env, "creating native metal ops");
392 return;
393 }
394
395 // TODO : Check use case of below parameters and use them
396 /*metalsdo->sdOps.Lock = OGLSD_Lock;
397 metalsdo->sdOps.GetRasInfo = OGLSD_GetRasInfo;
398 metalsdo->sdOps.Unlock = OGLSD_Unlock;
399 metalsdo->sdOps.Dispose = OGLSD_Dispose;*/
400
401 metalsdo->xOffset = xoff;
402 metalsdo->yOffset = yoff;
403 metalsdo->isOpaque = isOpaque;
404
405 metalsdo->peerData = (AWTView *)jlong_to_ptr(pPeerData);
406 metalsdo->layer = (MetalLayer *)jlong_to_ptr(layerPtr);
407 metalsdo->configInfo = (MetalGraphicsConfigInfo *)jlong_to_ptr(pConfigInfo);
408
409 if (metalsdo->configInfo == NULL) {
410 free(metalsdo);
411 JNU_ThrowNullPointerException(env, "Config info is null in initOps");
412 }
413 }
414
415 JNIEXPORT void JNICALL
416 Java_sun_java2d_opengl_MetalSurfaceData_clearWindow
417 (JNIEnv *env, jobject metalsd)
418 {
419 //J2dTraceLn(J2D_TRACE_INFO, "MetalSurfaceData_clearWindow");
420
421 MetalSDOps* metalsdo = (MetalSDOps*) SurfaceData_GetOps(env, metalsd);
422
423 metalsdo->peerData = NULL;
424 metalsdo->layer = NULL;
425 metalsdo->mtlTexture = NULL;
426 }
427
428 #pragma mark -
429 #pragma mark "--- CGLSurfaceData methods - Mac OS X specific ---"
430
431 // Must be called on the QFT...
432 JNIEXPORT void JNICALL
433 Java_sun_java2d_metal_MetalSurfaceData_validate
434 (JNIEnv *env, jobject jsurfacedata,
435 jint xoff, jint yoff, jint width, jint height, jboolean isOpaque)
436 {
437 //J2dTraceLn2(J2D_TRACE_INFO, "CGLSurfaceData_validate: w=%d h=%d", width, height);
438
439 MetalSDOps* metalsdo = (MetalSDOps*)SurfaceData_GetOps(env, jsurfacedata);
440 //oglsdo->needsInit = JNI_TRUE;
441 metalsdo->xOffset = xoff;
442 metalsdo->yOffset = yoff;
443
444 metalsdo->width = width;
445 metalsdo->height = height;
446 metalsdo->isOpaque = isOpaque;
447
448 // TODO : We need to have similar logic for Metal
449 /*if (oglsdo->drawableType == OGLSD_WINDOW) {
450 OGLContext_SetSurfaces(env, ptr_to_jlong(oglsdo), ptr_to_jlong(oglsdo));
451
452 // we have to explicitly tell the NSOpenGLContext that its target
453 // drawable has changed size
454 CGLSDOps *cglsdo = (CGLSDOps *)oglsdo->privOps;
455 OGLContext *oglc = cglsdo->configInfo->context;
456 CGLCtxInfo *ctxinfo = (CGLCtxInfo *)oglc->ctxInfo;
457
458 JNF_COCOA_ENTER(env);
459 [ctxinfo->context update];
460 JNF_COCOA_EXIT(env);
461 }*/
462 }
463
464 JNIEXPORT jboolean JNICALL
465 Java_sun_java2d_metal_MetalSurfaceData_initTexture
466 (JNIEnv *env, jobject oglsd,
467 jlong pData, jboolean isOpaque,
468 jint width, jint height)
469 {
470 MetalSDOps* metalsdo = (MetalSDOps *)jlong_to_ptr(pData);
471 //fprintf(stdout, "MetalSurfaceData_initTexture\n");fflush(stdout);
472 // OFFLINE TEXTURE
473 MTLTextureDescriptor* textureDescriptor = [[MTLTextureDescriptor alloc] init];
474
475 // Indicate that each pixel has a blue, green, red, and alpha channel, where each channel is
476 // an 8-bit unsigned normalized value (i.e. 0 maps to 0.0 and 255 maps to 1.0)
477 textureDescriptor.pixelFormat = MTLPixelFormatBGRA8Unorm;
478 textureDescriptor.usage = MTLTextureUsageShaderRead | MTLTextureUsageRenderTarget;
479
480 // Set the pixel dimensions of the texture
481 textureDescriptor.width = width;
482 textureDescriptor.height = height;
483
484 // Create the texture from the device by using the descriptor
485 metalsdo->mtlTexture = [metalsdo->configInfo->device newTextureWithDescriptor:textureDescriptor];
486
487 metalsdo->width = width;
488 metalsdo->height = height;
489 metalsdo->isOpaque = isOpaque;
490
491 // TODO : We may need to refactor the code related shader initialization
492 MetalGraphicsConfigInfo* pInfo =
493 (MetalGraphicsConfigInfo*)jlong_to_ptr(metalsdo->configInfo);
494 if ((pInfo == NULL)) {
495 return -1;
496 }
497
498 MetalLayer* mtlLayer = jlong_to_ptr(metalsdo->layer);
499
500 //mtlLayer.device = pInfo->device;
501 mtlLayer.pixelFormat = MTLPixelFormatBGRA8Unorm;
502
503 //mtlLayer.commandQueue = pInfo->commandQueue;
504
505 /*
506 // Load shaders.
507 NSError *error = nil;
508 id<MTLLibrary> mtlLibrary = [metalsdo->configInfo->device newLibraryWithFile: @"/tmp/MyShader.metallib" error:&error];
509 if (!mtlLibrary) {
510 NSLog(@"Failed to load library. error %@", error);
511 //exit(0);
512 }
513
514 //create a vertex and fragment function object
515 id<MTLFunction> vertexProgram = [mtlLibrary newFunctionWithName:@"vertexShader"];
516 id<MTLFunction> fragmentProgram = [mtlLibrary newFunctionWithName:@"fragmentShader"];
517
518 MTLRenderPipelineDescriptor* mtlRenderPipelineDescriptor = [[MTLRenderPipelineDescriptor alloc] init];
519
520 //assign the vertex and fragment functions to the descriptor
521 [mtlRenderPipelineDescriptor setVertexFunction:vertexProgram];
522 [mtlRenderPipelineDescriptor setFragmentFunction:fragmentProgram];
523
524 //specify the target-texture pixel format
525
526 mtlRenderPipelineDescriptor.colorAttachments[0].pixelFormat=MTLPixelFormatBGRA8Unorm;
527
528 //create the Rendering Pipeline Object
529 metalsdo->renderPipelineState = [mtlLayer.device newRenderPipelineStateWithDescriptor:mtlRenderPipelineDescriptor error:nil];*/
530
531 return JNI_TRUE;
532 }