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 #ifndef HEADLESS |
|
27 |
|
28 #include <stdlib.h> |
|
29 #include <Foundation/NSObjCRuntime.h> |
|
30 #include "sun_java2d_pipe_BufferedOpCodes.h" |
|
31 #include "jlong.h" |
|
32 //#include "OGLBlitLoops.h" |
|
33 //#include "OGLBufImgOps.h" |
|
34 //#include "OGLContext.h" |
|
35 //#include "OGLMaskBlit.h" |
|
36 //#include "OGLMaskFill.h" |
|
37 //#include "OGLPaints.h" |
|
38 //#include "OGLRenderQueue.h" |
|
39 //#include "OGLRenderer.h" |
|
40 //#include "OGLSurfaceData.h" |
|
41 //#include "OGLTextRenderer.h" |
|
42 //#include "OGLVertexCache.h" |
|
43 |
|
44 #include "MetalRenderer.h" |
|
45 #include "MetalRenderQueue.h" |
|
46 #include "Trace.h" |
|
47 #include "MetalSurfaceData.h" |
|
48 |
|
49 /** |
|
50 * Used to track whether we are in a series of a simple primitive operations |
|
51 * or texturing operations. This variable should be controlled only via |
|
52 * the INIT/CHECK/RESET_PREVIOUS_OP() macros. See the |
|
53 * OGLRenderQueue_CheckPreviousOp() method below for more information. |
|
54 */ |
|
55 //jint previousOp; |
|
56 |
|
57 /** |
|
58 * References to the "current" context and destination surface. |
|
59 */ |
|
60 //static MetalContext *mtlc = NULL; |
|
61 static MetalSDOps *dstOps = NULL; |
|
62 static MetalContext *mtlc = NULL; |
|
63 |
|
64 /** |
|
65 * The following methods are implemented in the windowing system (i.e. GLX |
|
66 * and WGL) source files. |
|
67 */ |
|
68 //extern OGLContext *OGLSD_SetScratchSurface(JNIEnv *env, jlong pConfigInfo); |
|
69 //extern void OGLGC_DestroyOGLGraphicsConfig(jlong pConfigInfo); |
|
70 //extern void OGLSD_SwapBuffers(JNIEnv *env, jlong window); |
|
71 //extern void OGLSD_Flush(JNIEnv *env); |
|
72 |
|
73 JNIEXPORT jlong JNICALL |
|
74 Java_sun_java2d_metal_MetalRenderQueue_flushBuffer(JNIEnv *env, jobject mtlrq, jlong buf, jint limit) |
|
75 { |
|
76 jboolean sync = JNI_FALSE; |
|
77 unsigned char *b, *end; |
|
78 |
|
79 J2dTraceLn1(J2D_TRACE_INFO, |
|
80 "MetalRenderQueue_flushBuffer: limit=%d", limit); |
|
81 |
|
82 NSLog(@"Java_sun_java2d_metal_MetalRenderQueue_flushBuffer :"); |
|
83 |
|
84 b = (unsigned char *)jlong_to_ptr(buf); |
|
85 if (b == NULL) { |
|
86 /*J2dRlsTraceLn(J2D_TRACE_ERROR, |
|
87 "MetalRenderQueue_flushBuffer: cannot get direct buffer address");*/ |
|
88 return 0; |
|
89 } |
|
90 |
|
91 //INIT_PREVIOUS_OP(); |
|
92 end = b + limit; |
|
93 |
|
94 while (b < end) { |
|
95 jint opcode = NEXT_INT(b); |
|
96 |
|
97 fprintf(stdout, "MetalRenderQueue_flushBuffer_opcode : %d\n", opcode);fflush(stdout); |
|
98 switch (opcode) { |
|
99 |
|
100 // draw ops |
|
101 case sun_java2d_pipe_BufferedOpCodes_DRAW_LINE: |
|
102 { |
|
103 jint x1 = NEXT_INT(b); |
|
104 jint y1 = NEXT_INT(b); |
|
105 jint x2 = NEXT_INT(b); |
|
106 jint y2 = NEXT_INT(b); |
|
107 MetalRenderer_DrawLine(mtlc, x1, y1, x2, y2); |
|
108 } |
|
109 break; |
|
110 case sun_java2d_pipe_BufferedOpCodes_DRAW_RECT: |
|
111 { |
|
112 jint x = NEXT_INT(b); |
|
113 jint y = NEXT_INT(b); |
|
114 jint w = NEXT_INT(b); |
|
115 jint h = NEXT_INT(b); |
|
116 MetalRenderer_DrawRect(mtlc, x, y, w, h); |
|
117 } |
|
118 break; |
|
119 case sun_java2d_pipe_BufferedOpCodes_DRAW_POLY: |
|
120 { |
|
121 jint nPoints = NEXT_INT(b); |
|
122 jboolean isClosed = NEXT_BOOLEAN(b); |
|
123 jint transX = NEXT_INT(b); |
|
124 jint transY = NEXT_INT(b); |
|
125 /*jint *xPoints = (jint *)b; |
|
126 jint *yPoints = ((jint *)b) + nPoints; |
|
127 OGLRenderer_DrawPoly(oglc, nPoints, isClosed, |
|
128 transX, transY, |
|
129 xPoints, yPoints);*/ |
|
130 SKIP_BYTES(b, nPoints * BYTES_PER_POLY_POINT); |
|
131 } |
|
132 break; |
|
133 case sun_java2d_pipe_BufferedOpCodes_DRAW_PIXEL: |
|
134 { |
|
135 jint x = NEXT_INT(b); |
|
136 jint y = NEXT_INT(b); |
|
137 // Note that we could use GL_POINTS here, but the common |
|
138 // use case for DRAW_PIXEL is when rendering a Path2D, |
|
139 // which will consist of a mix of DRAW_PIXEL and DRAW_LINE |
|
140 // calls. So to improve batching we use GL_LINES here, |
|
141 // even though it requires an extra vertex per pixel. |
|
142 /*CONTINUE_IF_NULL(oglc); |
|
143 CHECK_PREVIOUS_OP(GL_LINES); |
|
144 j2d_glVertex2i(x, y); |
|
145 j2d_glVertex2i(x+1, y+1);*/ |
|
146 } |
|
147 break; |
|
148 case sun_java2d_pipe_BufferedOpCodes_DRAW_SCANLINES: |
|
149 { |
|
150 jint count = NEXT_INT(b); |
|
151 //OGLRenderer_DrawScanlines(oglc, count, (jint *)b); |
|
152 SKIP_BYTES(b, count * BYTES_PER_SCANLINE); |
|
153 } |
|
154 break; |
|
155 case sun_java2d_pipe_BufferedOpCodes_DRAW_PARALLELOGRAM: |
|
156 { |
|
157 jfloat x11 = NEXT_FLOAT(b); |
|
158 jfloat y11 = NEXT_FLOAT(b); |
|
159 jfloat dx21 = NEXT_FLOAT(b); |
|
160 jfloat dy21 = NEXT_FLOAT(b); |
|
161 jfloat dx12 = NEXT_FLOAT(b); |
|
162 jfloat dy12 = NEXT_FLOAT(b); |
|
163 jfloat lwr21 = NEXT_FLOAT(b); |
|
164 jfloat lwr12 = NEXT_FLOAT(b); |
|
165 MetalRenderer_DrawParallelogram(mtlc, |
|
166 x11, y11, |
|
167 dx21, dy21, |
|
168 dx12, dy12, |
|
169 lwr21, lwr12); |
|
170 } |
|
171 break; |
|
172 case sun_java2d_pipe_BufferedOpCodes_DRAW_AAPARALLELOGRAM: |
|
173 { |
|
174 jfloat x11 = NEXT_FLOAT(b); |
|
175 jfloat y11 = NEXT_FLOAT(b); |
|
176 jfloat dx21 = NEXT_FLOAT(b); |
|
177 jfloat dy21 = NEXT_FLOAT(b); |
|
178 jfloat dx12 = NEXT_FLOAT(b); |
|
179 jfloat dy12 = NEXT_FLOAT(b); |
|
180 jfloat lwr21 = NEXT_FLOAT(b); |
|
181 jfloat lwr12 = NEXT_FLOAT(b); |
|
182 /*OGLRenderer_DrawAAParallelogram(oglc, dstOps, |
|
183 x11, y11, |
|
184 dx21, dy21, |
|
185 dx12, dy12, |
|
186 lwr21, lwr12);*/ |
|
187 } |
|
188 break; |
|
189 |
|
190 // fill ops |
|
191 case sun_java2d_pipe_BufferedOpCodes_FILL_RECT: |
|
192 { |
|
193 jint x = NEXT_INT(b); |
|
194 jint y = NEXT_INT(b); |
|
195 jint w = NEXT_INT(b); |
|
196 jint h = NEXT_INT(b); |
|
197 MetalRenderer_FillRect(mtlc, x, y, w, h); |
|
198 } |
|
199 break; |
|
200 case sun_java2d_pipe_BufferedOpCodes_FILL_SPANS: |
|
201 { |
|
202 jint count = NEXT_INT(b); |
|
203 //OGLRenderer_FillSpans(oglc, count, (jint *)b); |
|
204 SKIP_BYTES(b, count * BYTES_PER_SPAN); |
|
205 } |
|
206 break; |
|
207 case sun_java2d_pipe_BufferedOpCodes_FILL_PARALLELOGRAM: |
|
208 { |
|
209 jfloat x11 = NEXT_FLOAT(b); |
|
210 jfloat y11 = NEXT_FLOAT(b); |
|
211 jfloat dx21 = NEXT_FLOAT(b); |
|
212 jfloat dy21 = NEXT_FLOAT(b); |
|
213 jfloat dx12 = NEXT_FLOAT(b); |
|
214 jfloat dy12 = NEXT_FLOAT(b); |
|
215 MetalRenderer_FillParallelogram(mtlc, |
|
216 x11, y11, |
|
217 dx21, dy21, |
|
218 dx12, dy12); |
|
219 } |
|
220 break; |
|
221 case sun_java2d_pipe_BufferedOpCodes_FILL_AAPARALLELOGRAM: |
|
222 { |
|
223 jfloat x11 = NEXT_FLOAT(b); |
|
224 jfloat y11 = NEXT_FLOAT(b); |
|
225 jfloat dx21 = NEXT_FLOAT(b); |
|
226 jfloat dy21 = NEXT_FLOAT(b); |
|
227 jfloat dx12 = NEXT_FLOAT(b); |
|
228 jfloat dy12 = NEXT_FLOAT(b); |
|
229 /*OGLRenderer_FillAAParallelogram(oglc, dstOps, |
|
230 x11, y11, |
|
231 dx21, dy21, |
|
232 dx12, dy12);*/ |
|
233 } |
|
234 break; |
|
235 |
|
236 // text-related ops |
|
237 case sun_java2d_pipe_BufferedOpCodes_DRAW_GLYPH_LIST: |
|
238 { |
|
239 jint numGlyphs = NEXT_INT(b); |
|
240 jint packedParams = NEXT_INT(b); |
|
241 jfloat glyphListOrigX = NEXT_FLOAT(b); |
|
242 jfloat glyphListOrigY = NEXT_FLOAT(b); |
|
243 /*jboolean usePositions = EXTRACT_BOOLEAN(packedParams, |
|
244 OFFSET_POSITIONS); |
|
245 jboolean subPixPos = EXTRACT_BOOLEAN(packedParams, |
|
246 OFFSET_SUBPIXPOS); |
|
247 jboolean rgbOrder = EXTRACT_BOOLEAN(packedParams, |
|
248 OFFSET_RGBORDER); |
|
249 jint lcdContrast = EXTRACT_BYTE(packedParams, |
|
250 OFFSET_CONTRAST); |
|
251 unsigned char *images = b; |
|
252 unsigned char *positions; |
|
253 jint bytesPerGlyph; |
|
254 if (usePositions) { |
|
255 positions = (b + numGlyphs * BYTES_PER_GLYPH_IMAGE); |
|
256 bytesPerGlyph = BYTES_PER_POSITIONED_GLYPH; |
|
257 } else { |
|
258 positions = NULL; |
|
259 bytesPerGlyph = BYTES_PER_GLYPH_IMAGE; |
|
260 } |
|
261 OGLTR_DrawGlyphList(env, oglc, dstOps, |
|
262 numGlyphs, usePositions, |
|
263 subPixPos, rgbOrder, lcdContrast, |
|
264 glyphListOrigX, glyphListOrigY, |
|
265 images, positions); |
|
266 SKIP_BYTES(b, numGlyphs * bytesPerGlyph);*/ |
|
267 } |
|
268 break; |
|
269 |
|
270 // copy-related ops |
|
271 case sun_java2d_pipe_BufferedOpCodes_COPY_AREA: |
|
272 { |
|
273 jint x = NEXT_INT(b); |
|
274 jint y = NEXT_INT(b); |
|
275 jint w = NEXT_INT(b); |
|
276 jint h = NEXT_INT(b); |
|
277 jint dx = NEXT_INT(b); |
|
278 jint dy = NEXT_INT(b); |
|
279 /*OGLBlitLoops_CopyArea(env, oglc, dstOps, |
|
280 x, y, w, h, dx, dy);*/ |
|
281 } |
|
282 break; |
|
283 case sun_java2d_pipe_BufferedOpCodes_BLIT: |
|
284 { |
|
285 jint packedParams = NEXT_INT(b); |
|
286 jint sx1 = NEXT_INT(b); |
|
287 jint sy1 = NEXT_INT(b); |
|
288 jint sx2 = NEXT_INT(b); |
|
289 jint sy2 = NEXT_INT(b); |
|
290 jdouble dx1 = NEXT_DOUBLE(b); |
|
291 jdouble dy1 = NEXT_DOUBLE(b); |
|
292 jdouble dx2 = NEXT_DOUBLE(b); |
|
293 jdouble dy2 = NEXT_DOUBLE(b); |
|
294 jlong pSrc = NEXT_LONG(b); |
|
295 jlong pDst = NEXT_LONG(b); |
|
296 /*jint hint = EXTRACT_BYTE(packedParams, OFFSET_HINT); |
|
297 jboolean texture = EXTRACT_BOOLEAN(packedParams, |
|
298 OFFSET_TEXTURE); |
|
299 jboolean rtt = EXTRACT_BOOLEAN(packedParams, |
|
300 OFFSET_RTT); |
|
301 jboolean xform = EXTRACT_BOOLEAN(packedParams, |
|
302 OFFSET_XFORM); |
|
303 jboolean isoblit = EXTRACT_BOOLEAN(packedParams, |
|
304 OFFSET_ISOBLIT); |
|
305 if (isoblit) { |
|
306 OGLBlitLoops_IsoBlit(env, oglc, pSrc, pDst, |
|
307 xform, hint, texture, rtt, |
|
308 sx1, sy1, sx2, sy2, |
|
309 dx1, dy1, dx2, dy2); |
|
310 } else { |
|
311 jint srctype = EXTRACT_BYTE(packedParams, OFFSET_SRCTYPE); |
|
312 OGLBlitLoops_Blit(env, oglc, pSrc, pDst, |
|
313 xform, hint, srctype, texture, |
|
314 sx1, sy1, sx2, sy2, |
|
315 dx1, dy1, dx2, dy2); |
|
316 }*/ |
|
317 } |
|
318 break; |
|
319 case sun_java2d_pipe_BufferedOpCodes_SURFACE_TO_SW_BLIT: |
|
320 { |
|
321 jint sx = NEXT_INT(b); |
|
322 jint sy = NEXT_INT(b); |
|
323 jint dx = NEXT_INT(b); |
|
324 jint dy = NEXT_INT(b); |
|
325 jint w = NEXT_INT(b); |
|
326 jint h = NEXT_INT(b); |
|
327 jint dsttype = NEXT_INT(b); |
|
328 jlong pSrc = NEXT_LONG(b); |
|
329 jlong pDst = NEXT_LONG(b); |
|
330 /*OGLBlitLoops_SurfaceToSwBlit(env, oglc, |
|
331 pSrc, pDst, dsttype, |
|
332 sx, sy, dx, dy, w, h);*/ |
|
333 } |
|
334 break; |
|
335 case sun_java2d_pipe_BufferedOpCodes_MASK_FILL: |
|
336 { |
|
337 jint x = NEXT_INT(b); |
|
338 jint y = NEXT_INT(b); |
|
339 jint w = NEXT_INT(b); |
|
340 jint h = NEXT_INT(b); |
|
341 jint maskoff = NEXT_INT(b); |
|
342 jint maskscan = NEXT_INT(b); |
|
343 jint masklen = NEXT_INT(b); |
|
344 unsigned char *pMask = (masklen > 0) ? b : NULL; |
|
345 /*OGLMaskFill_MaskFill(oglc, x, y, w, h, |
|
346 maskoff, maskscan, masklen, pMask);*/ |
|
347 SKIP_BYTES(b, masklen); |
|
348 } |
|
349 break; |
|
350 case sun_java2d_pipe_BufferedOpCodes_MASK_BLIT: |
|
351 { |
|
352 jint dstx = NEXT_INT(b); |
|
353 jint dsty = NEXT_INT(b); |
|
354 jint width = NEXT_INT(b); |
|
355 jint height = NEXT_INT(b); |
|
356 jint masklen = width * height * sizeof(jint); |
|
357 /*OGLMaskBlit_MaskBlit(env, oglc, |
|
358 dstx, dsty, width, height, b);*/ |
|
359 SKIP_BYTES(b, masklen); |
|
360 } |
|
361 break; |
|
362 |
|
363 // state-related ops |
|
364 case sun_java2d_pipe_BufferedOpCodes_SET_RECT_CLIP: |
|
365 { |
|
366 jint x1 = NEXT_INT(b); |
|
367 jint y1 = NEXT_INT(b); |
|
368 jint x2 = NEXT_INT(b); |
|
369 jint y2 = NEXT_INT(b); |
|
370 //OGLContext_SetRectClip(oglc, dstOps, x1, y1, x2, y2); |
|
371 MetalRenderer_SetRectClip(mtlc, x1, y1, x2, y2); |
|
372 } |
|
373 break; |
|
374 case sun_java2d_pipe_BufferedOpCodes_BEGIN_SHAPE_CLIP: |
|
375 { |
|
376 //OGLContext_BeginShapeClip(oglc); |
|
377 } |
|
378 break; |
|
379 case sun_java2d_pipe_BufferedOpCodes_SET_SHAPE_CLIP_SPANS: |
|
380 { |
|
381 jint count = NEXT_INT(b); |
|
382 //OGLRenderer_FillSpans(oglc, count, (jint *)b); |
|
383 SKIP_BYTES(b, count * BYTES_PER_SPAN); |
|
384 } |
|
385 break; |
|
386 case sun_java2d_pipe_BufferedOpCodes_END_SHAPE_CLIP: |
|
387 { |
|
388 //OGLContext_EndShapeClip(oglc, dstOps); |
|
389 } |
|
390 break; |
|
391 case sun_java2d_pipe_BufferedOpCodes_RESET_CLIP: |
|
392 { |
|
393 //OGLContext_ResetClip(oglc); |
|
394 } |
|
395 break; |
|
396 case sun_java2d_pipe_BufferedOpCodes_SET_ALPHA_COMPOSITE: |
|
397 { |
|
398 jint rule = NEXT_INT(b); |
|
399 jfloat extraAlpha = NEXT_FLOAT(b); |
|
400 jint flags = NEXT_INT(b); |
|
401 //OGLContext_SetAlphaComposite(oglc, rule, extraAlpha, flags); |
|
402 } |
|
403 break; |
|
404 case sun_java2d_pipe_BufferedOpCodes_SET_XOR_COMPOSITE: |
|
405 { |
|
406 jint xorPixel = NEXT_INT(b); |
|
407 //OGLContext_SetXorComposite(oglc, xorPixel); |
|
408 } |
|
409 break; |
|
410 case sun_java2d_pipe_BufferedOpCodes_RESET_COMPOSITE: |
|
411 { |
|
412 //OGLContext_ResetComposite(oglc); |
|
413 } |
|
414 break; |
|
415 case sun_java2d_pipe_BufferedOpCodes_SET_TRANSFORM: |
|
416 { |
|
417 jdouble m00 = NEXT_DOUBLE(b); |
|
418 jdouble m10 = NEXT_DOUBLE(b); |
|
419 jdouble m01 = NEXT_DOUBLE(b); |
|
420 jdouble m11 = NEXT_DOUBLE(b); |
|
421 jdouble m02 = NEXT_DOUBLE(b); |
|
422 jdouble m12 = NEXT_DOUBLE(b); |
|
423 //OGLContext_SetTransform(oglc, m00, m10, m01, m11, m02, m12); |
|
424 } |
|
425 break; |
|
426 case sun_java2d_pipe_BufferedOpCodes_RESET_TRANSFORM: |
|
427 { |
|
428 //OGLContext_ResetTransform(oglc); |
|
429 } |
|
430 break; |
|
431 |
|
432 // context-related ops |
|
433 case sun_java2d_pipe_BufferedOpCodes_SET_SURFACES: |
|
434 { |
|
435 //fprintf(stdout, "MetalRenderQueue_flushBuffer_SetSurfaces\n");fflush(stdout); |
|
436 jlong pSrc = NEXT_LONG(b); |
|
437 jlong pDst = NEXT_LONG(b); |
|
438 /*if (oglc != NULL) { |
|
439 RESET_PREVIOUS_OP(); |
|
440 } |
|
441 oglc = OGLContext_SetSurfaces(env, pSrc, pDst);*/ |
|
442 dstOps = (MetalSDOps *)jlong_to_ptr(pDst); |
|
443 } |
|
444 break; |
|
445 case sun_java2d_pipe_BufferedOpCodes_SET_SCRATCH_SURFACE: |
|
446 { |
|
447 jlong pConfigInfo = NEXT_LONG(b); |
|
448 /*if (oglc != NULL) { |
|
449 RESET_PREVIOUS_OP(); |
|
450 } |
|
451 oglc = OGLSD_SetScratchSurface(env, pConfigInfo); |
|
452 dstOps = NULL;*/ |
|
453 } |
|
454 break; |
|
455 case sun_java2d_pipe_BufferedOpCodes_FLUSH_SURFACE: |
|
456 { |
|
457 jlong pData = NEXT_LONG(b); |
|
458 /*OGLSDOps *oglsdo = (OGLSDOps *)jlong_to_ptr(pData); |
|
459 if (oglsdo != NULL) { |
|
460 CONTINUE_IF_NULL(oglc); |
|
461 RESET_PREVIOUS_OP(); |
|
462 OGLSD_Delete(env, oglsdo); |
|
463 }*/ |
|
464 } |
|
465 break; |
|
466 case sun_java2d_pipe_BufferedOpCodes_DISPOSE_SURFACE: |
|
467 { |
|
468 jlong pData = NEXT_LONG(b); |
|
469 /*OGLSDOps *oglsdo = (OGLSDOps *)jlong_to_ptr(pData); |
|
470 if (oglsdo != NULL) { |
|
471 CONTINUE_IF_NULL(oglc); |
|
472 RESET_PREVIOUS_OP(); |
|
473 OGLSD_Delete(env, oglsdo); |
|
474 if (oglsdo->privOps != NULL) { |
|
475 free(oglsdo->privOps); |
|
476 } |
|
477 }*/ |
|
478 } |
|
479 break; |
|
480 case sun_java2d_pipe_BufferedOpCodes_DISPOSE_CONFIG: |
|
481 { |
|
482 jlong pConfigInfo = NEXT_LONG(b); |
|
483 /*CONTINUE_IF_NULL(oglc); |
|
484 RESET_PREVIOUS_OP(); |
|
485 OGLGC_DestroyOGLGraphicsConfig(pConfigInfo); |
|
486 |
|
487 // the previous method will call glX/wglMakeCurrent(None), |
|
488 // so we should nullify the current oglc and dstOps to avoid |
|
489 // calling glFlush() (or similar) while no context is current |
|
490 oglc = NULL; |
|
491 dstOps = NULL;*/ |
|
492 } |
|
493 break; |
|
494 case sun_java2d_pipe_BufferedOpCodes_INVALIDATE_CONTEXT: |
|
495 { |
|
496 // flush just in case there are any pending operations in |
|
497 // the hardware pipe |
|
498 /*if (oglc != NULL) { |
|
499 RESET_PREVIOUS_OP(); |
|
500 j2d_glFlush(); |
|
501 } |
|
502 |
|
503 // invalidate the references to the current context and |
|
504 // destination surface that are maintained at the native level |
|
505 oglc = NULL; |
|
506 dstOps = NULL;*/ |
|
507 } |
|
508 break; |
|
509 case sun_java2d_pipe_BufferedOpCodes_SAVE_STATE: |
|
510 { |
|
511 /*j2d_glPushAttrib(GL_ALL_ATTRIB_BITS); |
|
512 j2d_glPushClientAttrib(GL_CLIENT_ALL_ATTRIB_BITS); |
|
513 j2d_glMatrixMode(GL_MODELVIEW); |
|
514 j2d_glPushMatrix(); |
|
515 j2d_glMatrixMode(GL_PROJECTION); |
|
516 j2d_glPushMatrix(); |
|
517 j2d_glMatrixMode(GL_TEXTURE); |
|
518 j2d_glPushMatrix();*/ |
|
519 } |
|
520 break; |
|
521 |
|
522 case sun_java2d_pipe_BufferedOpCodes_RESTORE_STATE: |
|
523 { |
|
524 /*j2d_glPopAttrib(); |
|
525 j2d_glPopClientAttrib(); |
|
526 j2d_glMatrixMode(GL_MODELVIEW); |
|
527 j2d_glPopMatrix(); |
|
528 j2d_glMatrixMode(GL_PROJECTION); |
|
529 j2d_glPopMatrix(); |
|
530 j2d_glMatrixMode(GL_TEXTURE); |
|
531 j2d_glPopMatrix();*/ |
|
532 } |
|
533 break; |
|
534 case sun_java2d_pipe_BufferedOpCodes_SYNC: |
|
535 { |
|
536 //sync = JNI_TRUE; |
|
537 } |
|
538 break; |
|
539 |
|
540 // multibuffering ops |
|
541 case sun_java2d_pipe_BufferedOpCodes_SWAP_BUFFERS: |
|
542 { |
|
543 jlong window = NEXT_LONG(b); |
|
544 /*if (oglc != NULL) { |
|
545 RESET_PREVIOUS_OP(); |
|
546 } |
|
547 OGLSD_SwapBuffers(env, window);*/ |
|
548 } |
|
549 break; |
|
550 |
|
551 // special no-op (mainly used for achieving 8-byte alignment) |
|
552 case sun_java2d_pipe_BufferedOpCodes_NOOP: |
|
553 break; |
|
554 |
|
555 // paint-related ops |
|
556 case sun_java2d_pipe_BufferedOpCodes_RESET_PAINT: |
|
557 { |
|
558 //OGLPaints_ResetPaint(oglc); |
|
559 } |
|
560 break; |
|
561 case sun_java2d_pipe_BufferedOpCodes_SET_COLOR: |
|
562 { |
|
563 fprintf(stdout, "MetalRenderQueue_flushBuffer_SetColor\n");fflush(stdout); |
|
564 jint color = NEXT_INT(b); |
|
565 MetalRenderer_SetColor(mtlc, color); |
|
566 } |
|
567 break; |
|
568 case sun_java2d_pipe_BufferedOpCodes_SET_GRADIENT_PAINT: |
|
569 { |
|
570 jboolean useMask= NEXT_BOOLEAN(b); |
|
571 jboolean cyclic = NEXT_BOOLEAN(b); |
|
572 jdouble p0 = NEXT_DOUBLE(b); |
|
573 jdouble p1 = NEXT_DOUBLE(b); |
|
574 jdouble p3 = NEXT_DOUBLE(b); |
|
575 jint pixel1 = NEXT_INT(b); |
|
576 jint pixel2 = NEXT_INT(b); |
|
577 /*OGLPaints_SetGradientPaint(oglc, useMask, cyclic, |
|
578 p0, p1, p3, |
|
579 pixel1, pixel2);*/ |
|
580 } |
|
581 break; |
|
582 case sun_java2d_pipe_BufferedOpCodes_SET_LINEAR_GRADIENT_PAINT: |
|
583 { |
|
584 jboolean useMask = NEXT_BOOLEAN(b); |
|
585 jboolean linear = NEXT_BOOLEAN(b); |
|
586 jint cycleMethod = NEXT_INT(b); |
|
587 jint numStops = NEXT_INT(b); |
|
588 jfloat p0 = NEXT_FLOAT(b); |
|
589 jfloat p1 = NEXT_FLOAT(b); |
|
590 jfloat p3 = NEXT_FLOAT(b); |
|
591 void *fractions, *pixels; |
|
592 fractions = b; SKIP_BYTES(b, numStops * sizeof(jfloat)); |
|
593 pixels = b; SKIP_BYTES(b, numStops * sizeof(jint)); |
|
594 /*OGLPaints_SetLinearGradientPaint(oglc, dstOps, |
|
595 useMask, linear, |
|
596 cycleMethod, numStops, |
|
597 p0, p1, p3, |
|
598 fractions, pixels);*/ |
|
599 } |
|
600 break; |
|
601 case sun_java2d_pipe_BufferedOpCodes_SET_RADIAL_GRADIENT_PAINT: |
|
602 { |
|
603 jboolean useMask = NEXT_BOOLEAN(b); |
|
604 jboolean linear = NEXT_BOOLEAN(b); |
|
605 jint numStops = NEXT_INT(b); |
|
606 jint cycleMethod = NEXT_INT(b); |
|
607 jfloat m00 = NEXT_FLOAT(b); |
|
608 jfloat m01 = NEXT_FLOAT(b); |
|
609 jfloat m02 = NEXT_FLOAT(b); |
|
610 jfloat m10 = NEXT_FLOAT(b); |
|
611 jfloat m11 = NEXT_FLOAT(b); |
|
612 jfloat m12 = NEXT_FLOAT(b); |
|
613 jfloat focusX = NEXT_FLOAT(b); |
|
614 void *fractions, *pixels; |
|
615 fractions = b; SKIP_BYTES(b, numStops * sizeof(jfloat)); |
|
616 pixels = b; SKIP_BYTES(b, numStops * sizeof(jint)); |
|
617 /*OGLPaints_SetRadialGradientPaint(oglc, dstOps, |
|
618 useMask, linear, |
|
619 cycleMethod, numStops, |
|
620 m00, m01, m02, |
|
621 m10, m11, m12, |
|
622 focusX, |
|
623 fractions, pixels);*/ |
|
624 } |
|
625 break; |
|
626 case sun_java2d_pipe_BufferedOpCodes_SET_TEXTURE_PAINT: |
|
627 { |
|
628 jboolean useMask= NEXT_BOOLEAN(b); |
|
629 jboolean filter = NEXT_BOOLEAN(b); |
|
630 jlong pSrc = NEXT_LONG(b); |
|
631 jdouble xp0 = NEXT_DOUBLE(b); |
|
632 jdouble xp1 = NEXT_DOUBLE(b); |
|
633 jdouble xp3 = NEXT_DOUBLE(b); |
|
634 jdouble yp0 = NEXT_DOUBLE(b); |
|
635 jdouble yp1 = NEXT_DOUBLE(b); |
|
636 jdouble yp3 = NEXT_DOUBLE(b); |
|
637 /*OGLPaints_SetTexturePaint(oglc, useMask, pSrc, filter, |
|
638 xp0, xp1, xp3, |
|
639 yp0, yp1, yp3);*/ |
|
640 } |
|
641 break; |
|
642 |
|
643 // BufferedImageOp-related ops |
|
644 case sun_java2d_pipe_BufferedOpCodes_ENABLE_CONVOLVE_OP: |
|
645 { |
|
646 jlong pSrc = NEXT_LONG(b); |
|
647 jboolean edgeZero = NEXT_BOOLEAN(b); |
|
648 jint kernelWidth = NEXT_INT(b); |
|
649 jint kernelHeight = NEXT_INT(b); |
|
650 /*OGLBufImgOps_EnableConvolveOp(oglc, pSrc, edgeZero, |
|
651 kernelWidth, kernelHeight, b);*/ |
|
652 SKIP_BYTES(b, kernelWidth * kernelHeight * sizeof(jfloat)); |
|
653 } |
|
654 break; |
|
655 case sun_java2d_pipe_BufferedOpCodes_DISABLE_CONVOLVE_OP: |
|
656 { |
|
657 //OGLBufImgOps_DisableConvolveOp(oglc); |
|
658 } |
|
659 break; |
|
660 case sun_java2d_pipe_BufferedOpCodes_ENABLE_RESCALE_OP: |
|
661 { |
|
662 jlong pSrc = NEXT_LONG(b); |
|
663 jboolean nonPremult = NEXT_BOOLEAN(b); |
|
664 jint numFactors = 4; |
|
665 unsigned char *scaleFactors = b; |
|
666 unsigned char *offsets = (b + numFactors * sizeof(jfloat)); |
|
667 /*OGLBufImgOps_EnableRescaleOp(oglc, pSrc, nonPremult, |
|
668 scaleFactors, offsets);*/ |
|
669 SKIP_BYTES(b, numFactors * sizeof(jfloat) * 2); |
|
670 } |
|
671 break; |
|
672 case sun_java2d_pipe_BufferedOpCodes_DISABLE_RESCALE_OP: |
|
673 { |
|
674 //OGLBufImgOps_DisableRescaleOp(oglc); |
|
675 } |
|
676 break; |
|
677 case sun_java2d_pipe_BufferedOpCodes_ENABLE_LOOKUP_OP: |
|
678 { |
|
679 jlong pSrc = NEXT_LONG(b); |
|
680 jboolean nonPremult = NEXT_BOOLEAN(b); |
|
681 jboolean shortData = NEXT_BOOLEAN(b); |
|
682 jint numBands = NEXT_INT(b); |
|
683 jint bandLength = NEXT_INT(b); |
|
684 jint offset = NEXT_INT(b); |
|
685 jint bytesPerElem = shortData ? sizeof(jshort):sizeof(jbyte); |
|
686 void *tableValues = b; |
|
687 /*OGLBufImgOps_EnableLookupOp(oglc, pSrc, nonPremult, shortData, |
|
688 numBands, bandLength, offset, |
|
689 tableValues);*/ |
|
690 SKIP_BYTES(b, numBands * bandLength * bytesPerElem); |
|
691 } |
|
692 break; |
|
693 case sun_java2d_pipe_BufferedOpCodes_DISABLE_LOOKUP_OP: |
|
694 { |
|
695 //OGLBufImgOps_DisableLookupOp(oglc); |
|
696 } |
|
697 break; |
|
698 |
|
699 default: |
|
700 J2dRlsTraceLn1(J2D_TRACE_ERROR, |
|
701 "OGLRenderQueue_flushBuffer: invalid opcode=%d", opcode); |
|
702 /*if (oglc != NULL) { |
|
703 RESET_PREVIOUS_OP(); |
|
704 }*/ |
|
705 return 0; |
|
706 } |
|
707 // TODO : Below logic need to be refined more if any more opcodes |
|
708 // we need to consider |
|
709 /*if ((opcode != sun_java2d_pipe_BufferedOpCodes_DRAW_LINE) && |
|
710 (opcode != sun_java2d_pipe_BufferedOpCodes_SET_COLOR) && |
|
711 //(opcode != sun_java2d_pipe_BufferedOpCodes_FILL_PARALLELOGRAM) && |
|
712 //(opcode != sun_java2d_pipe_BufferedOpCodes_DRAW_PARALLELOGRAM) && |
|
713 (opcode != sun_java2d_pipe_BufferedOpCodes_SET_SURFACES)) { |
|
714 // We should not read int as it can cause under/overflow if |
|
715 // coming data is not int |
|
716 //jint x = NEXT_INT(b); |
|
717 continue; |
|
718 }*/ |
|
719 |
|
720 /*J2dTraceLn2(J2D_TRACE_VERBOSE, |
|
721 "MetalRenderQueue_flushBuffer: opcode=%d, rem=%d", |
|
722 opcode, (end-b));*/ |
|
723 |
|
724 /*switch (opcode) { |
|
725 |
|
726 // draw ops |
|
727 case sun_java2d_pipe_BufferedOpCodes_DRAW_LINE: |
|
728 { |
|
729 //fprintf(stdout, "MetalRenderQueue_flushBuffer_DrawLine\n");fflush(stdout); |
|
730 jint x1 = NEXT_INT(b); |
|
731 jint y1 = NEXT_INT(b); |
|
732 jint x2 = NEXT_INT(b); |
|
733 jint y2 = NEXT_INT(b); |
|
734 MetalRenderer_DrawLine(mtlc, x1, y1, x2, y2); |
|
735 } |
|
736 break; |
|
737 |
|
738 case sun_java2d_pipe_BufferedOpCodes_SET_COLOR: |
|
739 { |
|
740 //fprintf(stdout, "MetalRenderQueue_flushBuffer_SetColor\n");fflush(stdout); |
|
741 jint color = NEXT_INT(b); |
|
742 MetalRenderer_SetColor(mtlc, color); |
|
743 } |
|
744 break; |
|
745 |
|
746 |
|
747 case sun_java2d_pipe_BufferedOpCodes_DRAW_PARALLELOGRAM: |
|
748 { |
|
749 jfloat x11 = NEXT_FLOAT(b); |
|
750 jfloat y11 = NEXT_FLOAT(b); |
|
751 jfloat dx21 = NEXT_FLOAT(b); |
|
752 jfloat dy21 = NEXT_FLOAT(b); |
|
753 jfloat dx12 = NEXT_FLOAT(b); |
|
754 jfloat dy12 = NEXT_FLOAT(b); |
|
755 jfloat lwr21 = NEXT_FLOAT(b); |
|
756 jfloat lwr12 = NEXT_FLOAT(b); |
|
757 MetalRenderer_DrawParallelogram(mtlc, |
|
758 x11, y11, |
|
759 dx21, dy21, |
|
760 dx12, dy12, |
|
761 lwr21, lwr12); |
|
762 } |
|
763 break; |
|
764 |
|
765 case sun_java2d_pipe_BufferedOpCodes_FILL_PARALLELOGRAM: |
|
766 { |
|
767 jfloat x11 = NEXT_FLOAT(b); |
|
768 jfloat y11 = NEXT_FLOAT(b); |
|
769 jfloat dx21 = NEXT_FLOAT(b); |
|
770 jfloat dy21 = NEXT_FLOAT(b); |
|
771 jfloat dx12 = NEXT_FLOAT(b); |
|
772 jfloat dy12 = NEXT_FLOAT(b); |
|
773 MetalRenderer_FillParallelogram(mtlc, |
|
774 x11, y11, |
|
775 dx21, dy21, |
|
776 dx12, dy12); |
|
777 } |
|
778 break; |
|
779 |
|
780 case sun_java2d_pipe_BufferedOpCodes_SET_SURFACES: |
|
781 { |
|
782 //fprintf(stdout, "MetalRenderQueue_flushBuffer_SetSurfaces\n");fflush(stdout); |
|
783 jlong pSrc = NEXT_LONG(b); |
|
784 jlong pDst = NEXT_LONG(b); |
|
785 if (oglc != NULL) { |
|
786 RESET_PREVIOUS_OP(); |
|
787 } |
|
788 oglc = OGLContext_SetSurfaces(env, pSrc, pDst); |
|
789 dstOps = (MetalSDOps *)jlong_to_ptr(pDst); |
|
790 } |
|
791 break; |
|
792 |
|
793 default: |
|
794 J2dRlsTraceLn1(J2D_TRACE_ERROR, |
|
795 "MetalRenderQueue_flushBuffer: invalid opcode=%d", opcode); |
|
796 if (oglc != NULL) { |
|
797 RESET_PREVIOUS_OP(); |
|
798 } |
|
799 return 0; |
|
800 }*/ |
|
801 } |
|
802 |
|
803 // Render everything to offscreen surface data |
|
804 MetalRenderer_Flush(); |
|
805 |
|
806 // Render to on-screen |
|
807 MetalRenderer_blitToScreenDrawable(); |
|
808 |
|
809 return 1; |
|
810 } |
|
811 |
|
812 /** |
|
813 * Returns a pointer to the "current" context, as set by the last SET_SURFACES |
|
814 * or SET_SCRATCH_SURFACE operation. |
|
815 */ |
|
816 /*MetalContext * |
|
817 MetalRenderQueue_GetCurrentContext() |
|
818 { |
|
819 return mtlc; |
|
820 }*/ |
|
821 |
|
822 /** |
|
823 * Returns a pointer to the "current" destination surface, as set by the last |
|
824 * SET_SURFACES operation. |
|
825 */ |
|
826 MetalSDOps* |
|
827 MetalRenderQueue_GetCurrentDestination() |
|
828 { |
|
829 return dstOps; |
|
830 } |
|
831 |
|
832 #endif /* !HEADLESS */ |
|