1 /*
2 * Copyright (c) 2011, 2012, 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. For instance, if the given OGLSDOps is of type
114 * OGLSD_PBUFFER, this method implementation will destroy the actual pbuffer
115 * surface.
116 */
117 void
118 OGLSD_DestroyOGLSurface(JNIEnv *env, OGLSDOps *oglsdo)
119 {
120 J2dTraceLn(J2D_TRACE_INFO, "OGLSD_DestroyOGLSurface");
121
122 JNF_COCOA_ENTER(env);
123
124 CGLSDOps *cglsdo = (CGLSDOps *)oglsdo->privOps;
125 if (oglsdo->drawableType == OGLSD_PBUFFER) {
126 if (oglsdo->textureID != 0) {
127 j2d_glDeleteTextures(1, &oglsdo->textureID);
128 oglsdo->textureID = 0;
129 }
130 if (cglsdo->pbuffer != NULL) {
131 [cglsdo->pbuffer release];
132 cglsdo->pbuffer = NULL;
133 }
134 } else if (oglsdo->drawableType == OGLSD_WINDOW) {
135 // detach the NSView from the NSOpenGLContext
136 CGLGraphicsConfigInfo *cglInfo = cglsdo->configInfo;
137 OGLContext *oglc = cglInfo->context;
138 CGLCtxInfo *ctxinfo = (CGLCtxInfo *)oglc->ctxInfo;
139 [ctxinfo->context clearDrawable];
140 }
141
142 oglsdo->drawableType = OGLSD_UNDEFINED;
143
144 JNF_COCOA_EXIT(env);
145 }
146
147 /**
148 * Returns a pointer (as a jlong) to the native CGLGraphicsConfigInfo
149 * associated with the given OGLSDOps. This method can be called from
150 * shared code to retrieve the native GraphicsConfig data in a platform-
151 * independent manner.
152 */
153 jlong
154 OGLSD_GetNativeConfigInfo(OGLSDOps *oglsdo)
155 {
156 J2dTraceLn(J2D_TRACE_INFO, "OGLSD_GetNativeConfigInfo");
157
158 if (oglsdo == NULL) {
159 J2dRlsTraceLn(J2D_TRACE_ERROR, "OGLSD_GetNativeConfigInfo: ops are null");
160 return 0L;
161 }
162
163 CGLSDOps *cglsdo = (CGLSDOps *)oglsdo->privOps;
164 if (cglsdo == NULL) {
165 J2dRlsTraceLn(J2D_TRACE_ERROR, "OGLSD_GetNativeConfigInfo: cgl ops are null");
166 return 0L;
167 }
168
169 return ptr_to_jlong(cglsdo->configInfo);
170 }
171
172 /**
173 * Makes the given GraphicsConfig's context current to its associated
174 * "scratch" surface. If there is a problem making the context current,
175 * this method will return NULL; otherwise, returns a pointer to the
176 * OGLContext that is associated with the given GraphicsConfig.
177 */
178 OGLContext *
179 OGLSD_SetScratchSurface(JNIEnv *env, jlong pConfigInfo)
180 {
181 J2dTraceLn(J2D_TRACE_INFO, "OGLSD_SetScratchContext");
182
183 CGLGraphicsConfigInfo *cglInfo = (CGLGraphicsConfigInfo *)jlong_to_ptr(pConfigInfo);
184 if (cglInfo == NULL) {
185 J2dRlsTraceLn(J2D_TRACE_ERROR, "OGLSD_SetScratchContext: cgl config info is null");
186 return NULL;
187 }
188
189 OGLContext *oglc = cglInfo->context;
190 if (oglc == NULL) {
191 J2dRlsTraceLn(J2D_TRACE_ERROR, "OGLSD_SetScratchContext: ogl context is null");
192 return NULL;
193 }
194
195 CGLCtxInfo *ctxinfo = (CGLCtxInfo *)oglc->ctxInfo;
196
197 JNF_COCOA_ENTER(env);
198
199 // avoid changing the context's target view whenever possible, since
200 // calling setView causes flickering; as long as our context is current
201 // to some view, it's not necessary to switch to the scratch surface
202 if ([ctxinfo->context view] == nil) {
203 // it seems to be necessary to explicitly flush between context changes
204 OGLContext *currentContext = OGLRenderQueue_GetCurrentContext();
205 if (currentContext != NULL) {
206 j2d_glFlush();
207 }
208
209 if (!CGLSD_MakeCurrentToScratch(env, oglc)) {
210 return NULL;
211 }
212 // make sure our context is current
213 } else if ([NSOpenGLContext currentContext] != ctxinfo->context) {
214 [ctxinfo->context makeCurrentContext];
215 }
216
217 if (OGLC_IS_CAP_PRESENT(oglc, CAPS_EXT_FBOBJECT)) {
218 // the GL_EXT_framebuffer_object extension is present, so this call
219 // will ensure that we are bound to the scratch surface (and not
220 // some other framebuffer object)
221 j2d_glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
222 }
223
224 JNF_COCOA_EXIT(env);
225
226 return oglc;
227 }
228
229 /**
230 * Makes a context current to the given source and destination
231 * surfaces. If there is a problem making the context current, this method
232 * will return NULL; otherwise, returns a pointer to the OGLContext that is
233 * associated with the destination surface.
234 */
235 OGLContext *
236 OGLSD_MakeOGLContextCurrent(JNIEnv *env, OGLSDOps *srcOps, OGLSDOps *dstOps)
237 {
238 J2dTraceLn(J2D_TRACE_INFO, "OGLSD_MakeOGLContextCurrent");
239
240 CGLSDOps *dstCGLOps = (CGLSDOps *)dstOps->privOps;
241
242 J2dTraceLn4(J2D_TRACE_VERBOSE, " src: %d %p dst: %d %p", srcOps->drawableType, srcOps, dstOps->drawableType, dstOps);
243
244 OGLContext *oglc = dstCGLOps->configInfo->context;
245 if (oglc == NULL) {
246 J2dRlsTraceLn(J2D_TRACE_ERROR, "OGLSD_MakeOGLContextCurrent: context is null");
247 return NULL;
248 }
249
250 CGLCtxInfo *ctxinfo = (CGLCtxInfo *)oglc->ctxInfo;
251
252 // it seems to be necessary to explicitly flush between context changes
253 OGLContext *currentContext = OGLRenderQueue_GetCurrentContext();
254 if (currentContext != NULL) {
255 j2d_glFlush();
256 }
257
258 if (dstOps->drawableType == OGLSD_FBOBJECT) {
259 // first make sure we have a current context (if the context isn't
260 // already current to some drawable, we will make it current to
261 // its scratch surface)
262 if (oglc != currentContext) {
263 if (!CGLSD_MakeCurrentToScratch(env, oglc)) {
264 return NULL;
265 }
266 }
267
268 // now bind to the fbobject associated with the destination surface;
269 // this means that all rendering will go into the fbobject destination
270 // (note that we unbind the currently bound texture first; this is
271 // recommended procedure when binding an fbobject)
272 j2d_glBindTexture(GL_TEXTURE_2D, 0);
273 j2d_glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, dstOps->fbobjectID);
274
275 return oglc;
276 }
277
278 JNF_COCOA_ENTER(env);
279
280 // set the current surface
281 if (dstOps->drawableType == OGLSD_PBUFFER) {
282 // REMIND: pbuffers are not fully tested yet...
283 [ctxinfo->context clearDrawable];
284 [ctxinfo->context makeCurrentContext];
285 [ctxinfo->context setPixelBuffer: dstCGLOps->pbuffer
286 cubeMapFace: 0
287 mipMapLevel: 0
288 currentVirtualScreen: [ctxinfo->context currentVirtualScreen]];
289 } else {
290 CGLSDOps *cglsdo = (CGLSDOps *)dstOps->privOps;
291 NSView *nsView = (NSView *)cglsdo->peerData;
292
293 if ([ctxinfo->context view] != nsView) {
294 [ctxinfo->context makeCurrentContext];
295 [ctxinfo->context setView: nsView];
296 }
297 }
298
299 if (OGLC_IS_CAP_PRESENT(oglc, CAPS_EXT_FBOBJECT)) {
300 // the GL_EXT_framebuffer_object extension is present, so we
301 // must bind to the default (windowing system provided)
302 // framebuffer
303 j2d_glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
304 }
305
306 if ((srcOps != dstOps) && (srcOps->drawableType == OGLSD_PBUFFER)) {
307 // bind pbuffer to the render texture object (since we are preparing
308 // to copy from the pbuffer)
309 CGLSDOps *srcCGLOps = (CGLSDOps *)srcOps->privOps;
310 j2d_glBindTexture(GL_TEXTURE_2D, srcOps->textureID);
311 [ctxinfo->context
312 setTextureImageToPixelBuffer: srcCGLOps->pbuffer
313 colorBuffer: GL_FRONT];
314 }
315
316 JNF_COCOA_EXIT(env);
317
318 return oglc;
319 }
320
321 /**
322 * This function initializes a native window surface and caches the window
323 * bounds in the given OGLSDOps. Returns JNI_TRUE if the operation was
324 * successful; JNI_FALSE otherwise.
325 */
326 jboolean
327 OGLSD_InitOGLWindow(JNIEnv *env, OGLSDOps *oglsdo)
328 {
329 J2dTraceLn(J2D_TRACE_INFO, "OGLSD_InitOGLWindow");
330
331 if (oglsdo == NULL) {
332 J2dRlsTraceLn(J2D_TRACE_ERROR, "OGLSD_InitOGLWindow: ops are null");
333 return JNI_FALSE;
334 }
335
336 CGLSDOps *cglsdo = (CGLSDOps *)oglsdo->privOps;
337 if (cglsdo == NULL) {
338 J2dRlsTraceLn(J2D_TRACE_ERROR, "OGLSD_InitOGLWindow: cgl ops are null");
339 return JNI_FALSE;
340 }
341
342 AWTView *v = cglsdo->peerData;
343 if (v == NULL) {
344 J2dRlsTraceLn(J2D_TRACE_ERROR, "OGLSD_InitOGLWindow: view is invalid");
345 return JNI_FALSE;
346 }
347
348 JNF_COCOA_ENTER(env);
349 NSRect surfaceBounds = [v bounds];
350 oglsdo->drawableType = OGLSD_WINDOW;
351 oglsdo->isOpaque = JNI_TRUE;
352 oglsdo->width = surfaceBounds.size.width;
353 oglsdo->height = surfaceBounds.size.height;
354 JNF_COCOA_EXIT(env);
355
356 J2dTraceLn2(J2D_TRACE_VERBOSE, " created window: w=%d h=%d", oglsdo->width, oglsdo->height);
357
358 return JNI_TRUE;
359 }
360
361 void
362 OGLSD_SwapBuffers(JNIEnv *env, jlong pPeerData)
363 {
364 J2dTraceLn(J2D_TRACE_INFO, "OGLSD_SwapBuffers");
365
366 JNF_COCOA_ENTER(env);
367 [[NSOpenGLContext currentContext] flushBuffer];
368 JNF_COCOA_EXIT(env);
369 }
370
371 void
372 OGLSD_Flush(JNIEnv *env)
373 {
374 OGLSDOps *dstOps = OGLRenderQueue_GetCurrentDestination();
375 if (dstOps != NULL) {
376 CGLSDOps *dstCGLOps = (CGLSDOps *)dstOps->privOps;
377 CGLLayer *layer = (CGLLayer*)dstCGLOps->layer;
378 if (layer != NULL) {
379 [JNFRunLoop performOnMainThreadWaiting:NO withBlock:^(){
380 AWT_ASSERT_APPKIT_THREAD;
381 [layer setNeedsDisplay];
382
383 #ifdef REMOTELAYER
384 /* If there's a remote layer (being used for testing)
385 * then we want to have that also receive the texture.
386 * First sync. up its dimensions with that of the layer
387 * we have attached to the local window and tell it that
388 * it also needs to copy the texture.
389 */
390 if (layer.remoteLayer != nil) {
391 CGLLayer* remoteLayer = layer.remoteLayer;
392 remoteLayer.target = GL_TEXTURE_2D;
393 remoteLayer.textureID = layer.textureID;
394 remoteLayer.textureWidth = layer.textureWidth;
395 remoteLayer.textureHeight = layer.textureHeight;
396 [remoteLayer setNeedsDisplay];
397 }
398 #endif /* REMOTELAYER */
399 }];
400 }
401 }
402 }
403
404 #pragma mark -
405 #pragma mark "--- CGLSurfaceData methods ---"
406
407 extern LockFunc OGLSD_Lock;
408 extern GetRasInfoFunc OGLSD_GetRasInfo;
409 extern UnlockFunc OGLSD_Unlock;
410 extern DisposeFunc OGLSD_Dispose;
411
412 JNIEXPORT void JNICALL
413 Java_sun_java2d_opengl_CGLSurfaceData_initOps
414 (JNIEnv *env, jobject cglsd,
415 jlong pConfigInfo, jlong pPeerData, jlong layerPtr,
416 jint xoff, jint yoff, jboolean isOpaque)
417 {
418 J2dTraceLn(J2D_TRACE_INFO, "CGLSurfaceData_initOps");
419 J2dTraceLn1(J2D_TRACE_INFO, " pPeerData=%p", jlong_to_ptr(pPeerData));
420 J2dTraceLn2(J2D_TRACE_INFO, " xoff=%d, yoff=%d", (int)xoff, (int)yoff);
421
422 OGLSDOps *oglsdo = (OGLSDOps *)
423 SurfaceData_InitOps(env, cglsd, sizeof(OGLSDOps));
424 CGLSDOps *cglsdo = (CGLSDOps *)malloc(sizeof(CGLSDOps));
425 if (cglsdo == NULL) {
426 JNU_ThrowOutOfMemoryError(env, "creating native cgl ops");
427 return;
428 }
429
430 oglsdo->privOps = cglsdo;
431
432 oglsdo->sdOps.Lock = OGLSD_Lock;
433 oglsdo->sdOps.GetRasInfo = OGLSD_GetRasInfo;
434 oglsdo->sdOps.Unlock = OGLSD_Unlock;
435 oglsdo->sdOps.Dispose = OGLSD_Dispose;
436
437 oglsdo->drawableType = OGLSD_UNDEFINED;
438 oglsdo->activeBuffer = GL_FRONT;
439 oglsdo->needsInit = JNI_TRUE;
440 oglsdo->xOffset = xoff;
441 oglsdo->yOffset = yoff;
442 oglsdo->isOpaque = isOpaque;
443
444 cglsdo->peerData = (AWTView *)jlong_to_ptr(pPeerData);
445 cglsdo->layer = (CGLLayer *)jlong_to_ptr(layerPtr);
446 cglsdo->configInfo = (CGLGraphicsConfigInfo *)jlong_to_ptr(pConfigInfo);
447
448 if (cglsdo->configInfo == NULL) {
449 free(cglsdo);
450 JNU_ThrowNullPointerException(env, "Config info is null in initOps");
451 }
452 }
453
454 JNIEXPORT void JNICALL
455 Java_sun_java2d_opengl_CGLSurfaceData_clearWindow
456 (JNIEnv *env, jobject cglsd)
457 {
458 J2dTraceLn(J2D_TRACE_INFO, "CGLSurfaceData_clearWindow");
459
460 OGLSDOps *oglsdo = (OGLSDOps*) SurfaceData_GetOps(env, cglsd);
461 CGLSDOps *cglsdo = (CGLSDOps*) oglsdo->privOps;
462
463 cglsdo->peerData = NULL;
464 cglsdo->layer = NULL;
465 }
466
467 JNIEXPORT jboolean JNICALL
468 Java_sun_java2d_opengl_CGLSurfaceData_initPbuffer
469 (JNIEnv *env, jobject cglsd,
470 jlong pData, jlong pConfigInfo, jboolean isOpaque,
471 jint width, jint height)
472 {
473 J2dTraceLn3(J2D_TRACE_INFO, "CGLSurfaceData_initPbuffer: w=%d h=%d opq=%d", width, height, isOpaque);
474
475 OGLSDOps *oglsdo = (OGLSDOps *)jlong_to_ptr(pData);
476 if (oglsdo == NULL) {
477 J2dRlsTraceLn(J2D_TRACE_ERROR, "CGLSurfaceData_initPbuffer: ops are null");
478 return JNI_FALSE;
479 }
480
481 CGLSDOps *cglsdo = (CGLSDOps *)oglsdo->privOps;
482 if (cglsdo == NULL) {
483 J2dRlsTraceLn(J2D_TRACE_ERROR, "CGLSurfaceData_initPbuffer: cgl ops are null");
484 return JNI_FALSE;
485 }
486
487 CGLGraphicsConfigInfo *cglInfo = (CGLGraphicsConfigInfo *)
488 jlong_to_ptr(pConfigInfo);
489 if (cglInfo == NULL) {
490 J2dRlsTraceLn(J2D_TRACE_ERROR, "CGLSurfaceData_initPbuffer: cgl config info is null");
491 return JNI_FALSE;
492 }
493
494 // find the maximum allowable texture dimensions (this value ultimately
495 // determines our maximum pbuffer size)
496 int pbMax = 0;
497 j2d_glGetIntegerv(GL_MAX_TEXTURE_SIZE, &pbMax);
498
499 int pbWidth = 0;
500 int pbHeight = 0;
501 if (OGLC_IS_CAP_PRESENT(cglInfo->context, CAPS_TEXNONPOW2)) {
502 // use non-power-of-two dimensions directly
503 pbWidth = (width <= pbMax) ? width : 0;
504 pbHeight = (height <= pbMax) ? height : 0;
505 } else {
506 // find the appropriate power-of-two dimensions
507 pbWidth = OGLSD_NextPowerOfTwo(width, pbMax);
508 pbHeight = OGLSD_NextPowerOfTwo(height, pbMax);
509 }
510
511 J2dTraceLn3(J2D_TRACE_VERBOSE, " desired pbuffer dimensions: w=%d h=%d max=%d", pbWidth, pbHeight, pbMax);
512
513 // if either dimension is 0, we cannot allocate a pbuffer/texture with the
514 // requested dimensions
515 if (pbWidth == 0 || pbHeight == 0) {
516 J2dRlsTraceLn(J2D_TRACE_ERROR, "CGLSurfaceData_initPbuffer: dimensions too large");
517 return JNI_FALSE;
518 }
519
520 int format = isOpaque ? GL_RGB : GL_RGBA;
521
522 JNF_COCOA_ENTER(env);
523
524 cglsdo->pbuffer =
525 [[NSOpenGLPixelBuffer alloc]
526 initWithTextureTarget: GL_TEXTURE_2D
527 textureInternalFormat: format
528 textureMaxMipMapLevel: 0
529 pixelsWide: pbWidth
530 pixelsHigh: pbHeight];
531 if (cglsdo->pbuffer == nil) {
532 J2dRlsTraceLn(J2D_TRACE_ERROR, "CGLSurfaceData_initPbuffer: could not create pbuffer");
533 return JNI_FALSE;
534 }
535
536 // make sure the actual dimensions match those that we requested
537 GLsizei actualWidth = [cglsdo->pbuffer pixelsWide];
538 GLsizei actualHeight = [cglsdo->pbuffer pixelsHigh];
539 if (actualWidth != pbWidth || actualHeight != pbHeight) {
540 J2dRlsTraceLn2(J2D_TRACE_ERROR, "CGLSurfaceData_initPbuffer: actual (w=%d h=%d) != requested", actualWidth, actualHeight);
541 [cglsdo->pbuffer release];
542 return JNI_FALSE;
543 }
544
545 GLuint texID = 0;
546 j2d_glGenTextures(1, &texID);
547 j2d_glBindTexture(GL_TEXTURE_2D, texID);
548
549 oglsdo->drawableType = OGLSD_PBUFFER;
550 oglsdo->isOpaque = isOpaque;
551 oglsdo->width = width;
552 oglsdo->height = height;
553 oglsdo->textureID = texID;
554 oglsdo->textureWidth = pbWidth;
555 oglsdo->textureHeight = pbHeight;
556 oglsdo->activeBuffer = GL_FRONT;
557 oglsdo->needsInit = JNI_TRUE;
558
559 OGLSD_INIT_TEXTURE_FILTER(oglsdo, GL_NEAREST);
560
561 JNF_COCOA_EXIT(env);
562
563 return JNI_TRUE;
564 }
565
566 #pragma mark -
567 #pragma mark "--- CGLSurfaceData methods - Mac OS X specific ---"
568
569 // Must be called on the QFT...
570 JNIEXPORT void JNICALL
571 Java_sun_java2d_opengl_CGLSurfaceData_validate
572 (JNIEnv *env, jobject jsurfacedata,
573 jint xoff, jint yoff, jint width, jint height, jboolean isOpaque)
574 {
575 J2dTraceLn2(J2D_TRACE_INFO, "CGLSurfaceData_validate: w=%d h=%d", width, height);
576
577 OGLSDOps *oglsdo = (OGLSDOps*)SurfaceData_GetOps(env, jsurfacedata);
578 oglsdo->needsInit = JNI_TRUE;
579 oglsdo->xOffset = xoff;
580 oglsdo->yOffset = yoff;
581
582 oglsdo->width = width;
583 oglsdo->height = height;
584 oglsdo->isOpaque = isOpaque;
585
586 if (oglsdo->drawableType == OGLSD_WINDOW) {
587 OGLContext_SetSurfaces(env, ptr_to_jlong(oglsdo), ptr_to_jlong(oglsdo));
588
589 // we have to explicitly tell the NSOpenGLContext that its target
590 // drawable has changed size
591 CGLSDOps *cglsdo = (CGLSDOps *)oglsdo->privOps;
592 OGLContext *oglc = cglsdo->configInfo->context;
593 CGLCtxInfo *ctxinfo = (CGLCtxInfo *)oglc->ctxInfo;
594
595 JNF_COCOA_ENTER(env);
596 [ctxinfo->context update];
597 JNF_COCOA_EXIT(env);
598 }
599 }