1 /* 2 * Copyright (c) 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 "MTLPaints.h" 29 30 #include "MTLClip.h" 31 32 #include "common.h" 33 34 #include "sun_java2d_SunGraphics2D.h" 35 #include "sun_java2d_pipe_BufferedPaints.h" 36 #import "MTLComposite.h" 37 38 #define RGBA_TO_V4(c) \ 39 { \ 40 (((c) >> 16) & (0xFF))/255.0f, \ 41 (((c) >> 8) & 0xFF)/255.0f, \ 42 ((c) & 0xFF)/255.0f, \ 43 (((c) >> 24) & 0xFF)/255.0f \ 44 } 45 46 static MTLRenderPipelineDescriptor * templateRenderPipelineDesc = nil; 47 static MTLRenderPipelineDescriptor * templateTexturePipelineDesc = nil; 48 static MTLRenderPipelineDescriptor * templateAATexturePipelineDesc = nil; 49 50 static void initTemplatePipelineDescriptors() { 51 if (templateRenderPipelineDesc != nil && templateTexturePipelineDesc != nil) 52 return; 53 54 MTLVertexDescriptor *vertDesc = [[MTLVertexDescriptor new] autorelease]; 55 vertDesc.attributes[VertexAttributePosition].format = MTLVertexFormatFloat2; 56 vertDesc.attributes[VertexAttributePosition].offset = 0; 57 vertDesc.attributes[VertexAttributePosition].bufferIndex = MeshVertexBuffer; 58 vertDesc.layouts[MeshVertexBuffer].stride = sizeof(struct Vertex); 59 vertDesc.layouts[MeshVertexBuffer].stepRate = 1; 60 vertDesc.layouts[MeshVertexBuffer].stepFunction = MTLVertexStepFunctionPerVertex; 61 62 templateRenderPipelineDesc = [[MTLRenderPipelineDescriptor new] autorelease]; 63 templateRenderPipelineDesc.sampleCount = 1; 64 templateRenderPipelineDesc.vertexDescriptor = vertDesc; 65 templateRenderPipelineDesc.colorAttachments[0].pixelFormat = MTLPixelFormatBGRA8Unorm; 66 templateRenderPipelineDesc.label = @"template_render"; 67 68 templateTexturePipelineDesc = [[templateRenderPipelineDesc copy] autorelease]; 69 templateTexturePipelineDesc.vertexDescriptor.attributes[VertexAttributeTexPos].format = MTLVertexFormatFloat2; 70 templateTexturePipelineDesc.vertexDescriptor.attributes[VertexAttributeTexPos].offset = 2*sizeof(float); 71 templateTexturePipelineDesc.vertexDescriptor.attributes[VertexAttributeTexPos].bufferIndex = MeshVertexBuffer; 72 templateTexturePipelineDesc.vertexDescriptor.layouts[MeshVertexBuffer].stride = sizeof(struct TxtVertex); 73 templateTexturePipelineDesc.vertexDescriptor.layouts[MeshVertexBuffer].stepRate = 1; 74 templateTexturePipelineDesc.vertexDescriptor.layouts[MeshVertexBuffer].stepFunction = MTLVertexStepFunctionPerVertex; 75 templateTexturePipelineDesc.label = @"template_texture"; 76 77 templateAATexturePipelineDesc = [[templateTexturePipelineDesc copy] autorelease]; 78 templateAATexturePipelineDesc.colorAttachments[0].sourceRGBBlendFactor = MTLBlendFactorOne; 79 templateAATexturePipelineDesc.colorAttachments[0].sourceAlphaBlendFactor = MTLBlendFactorOne; 80 templateAATexturePipelineDesc.colorAttachments[0].destinationRGBBlendFactor = MTLBlendFactorOneMinusSourceAlpha; 81 templateAATexturePipelineDesc.colorAttachments[0].destinationAlphaBlendFactor = MTLBlendFactorOneMinusSourceAlpha; 82 templateAATexturePipelineDesc.label = @"template_aa_texture"; 83 84 } 85 86 @implementation MTLPaint { 87 // TODO: remove paintState, split into heirarchy of Paint-objects (i.e. PaintColor, PaintGrad, e.t.c) 88 jint _paintState; 89 90 // color-mode 91 jint _color; 92 93 // lin-grad-mode 94 jdouble _p0; 95 jdouble _p1; 96 jdouble _p3; 97 jboolean _cyclic; 98 jint _pixel1; 99 jint _pixel2; 100 jboolean _useMask; 101 102 // texture paint 103 id<MTLTexture> _paintTexture; 104 struct AnchorData _anchor; 105 } 106 107 - (id)init { 108 self = [super init]; 109 if (self) { 110 _paintState = sun_java2d_SunGraphics2D_PAINT_UNDEFINED; 111 } 112 return self; 113 } 114 115 - (BOOL)isEqual:(MTLPaint *)other { 116 if (self == other) 117 return YES; 118 if (_paintState == sun_java2d_SunGraphics2D_PAINT_UNDEFINED) 119 return _paintState == other->_paintState; 120 if (_paintState != other->_paintState) 121 return NO; 122 if (_paintState == sun_java2d_SunGraphics2D_PAINT_GRADIENT) { 123 return _p0 == other->_p0 124 && _p1 == other->_p1 125 && _p3 == other->_p3 126 && _pixel1 == other->_pixel1 127 && _pixel2 == other->_pixel2; 128 } 129 if (_paintState == sun_java2d_SunGraphics2D_PAINT_ALPHACOLOR) { 130 return _color == other->_color; 131 } 132 if (_paintState == sun_java2d_SunGraphics2D_PAINT_TEXTURE) { 133 return _paintTexture == other->_paintTexture 134 && _anchor.xParams[0] == other->_anchor.xParams[0] 135 && _anchor.xParams[1] == other->_anchor.xParams[1] 136 && _anchor.xParams[2] == other->_anchor.xParams[2] 137 && _anchor.yParams[0] == other->_anchor.yParams[0] 138 && _anchor.yParams[1] == other->_anchor.yParams[1] 139 && _anchor.yParams[2] == other->_anchor.yParams[2]; 140 } 141 142 J2dTraceLn1(J2D_TRACE_ERROR, "Unimplemented paint mode %d", _paintState); 143 return NO; 144 } 145 146 - (void)copyFrom:(MTLPaint *)other { 147 _paintState = other->_paintState; 148 if (other->_paintState == sun_java2d_SunGraphics2D_PAINT_UNDEFINED) 149 return; 150 151 if (other->_paintState == sun_java2d_SunGraphics2D_PAINT_GRADIENT) { 152 _p0 = other->_p0; 153 _p1 = other->_p1; 154 _p3 = other->_p3; 155 _pixel1 = other->_pixel1; 156 _pixel2 = other->_pixel2; 157 return; 158 } 159 if (_paintState == sun_java2d_SunGraphics2D_PAINT_ALPHACOLOR) { 160 _color = other->_color; 161 return; 162 } 163 164 if (_paintState == sun_java2d_SunGraphics2D_PAINT_TEXTURE) { 165 _color = other->_color; 166 _paintTexture = other->_paintTexture; 167 _anchor = other->_anchor; 168 return; 169 } 170 171 J2dTraceLn1(J2D_TRACE_ERROR, "Unsupported paint mode %d", _paintState); 172 } 173 174 - (NSString *)getDescription { 175 if (_paintState == sun_java2d_SunGraphics2D_PAINT_ALPHACOLOR) { 176 return [NSString stringWithFormat:@"[r=%d g=%d b=%d a=%d]", (_color >> 16) & (0xFF), (_color >> 8) & 0xFF, (_color) & 0xFF, (_color >> 24) & 0xFF]; 177 } 178 179 if (_paintState == sun_java2d_SunGraphics2D_PAINT_GRADIENT) { 180 return [NSString stringWithFormat:@"gradient"]; 181 } 182 183 if (_paintState == sun_java2d_SunGraphics2D_PAINT_TEXTURE) { 184 return [NSString stringWithFormat:@"texture_paint"]; 185 } 186 187 return @"unknown-paint"; 188 } 189 190 - (jint)getColor { 191 return _color; 192 } 193 194 - (void)reset { 195 _paintState = sun_java2d_SunGraphics2D_PAINT_UNDEFINED; 196 _paintTexture = nil; 197 _anchor.xParams[0] = _anchor.xParams[1] = _anchor.xParams[2] = 0.0f; 198 _anchor.yParams[0] = _anchor.yParams[1] = _anchor.yParams[2] = 0.0f; 199 } 200 201 - (void)setColor:(jint)pixelColor { 202 _paintState = sun_java2d_SunGraphics2D_PAINT_ALPHACOLOR; 203 _color = pixelColor; 204 } 205 206 - (void)setGradientUseMask:(jboolean)useMask 207 cyclic:(jboolean)cyclic 208 p0:(jdouble)p0 209 p1:(jdouble)p1 210 p3:(jdouble)p3 211 pixel1:(jint)pixel1 212 pixel2:(jint)pixel2 213 { 214 //TODO Resolve gradient distribution problem 215 //TODO Implement useMask 216 //TODO Implement cyclic 217 //fprintf(stderr, 218 // "MTLPaints_SetGradientPaint useMask=%d cyclic=%d " 219 // "p0=%f p1=%f p3=%f pix1=%d pix2=%d\n", useMask, cyclic, 220 // p0, p1, p3, pixel1, pixel2); 221 222 _paintState = sun_java2d_SunGraphics2D_PAINT_GRADIENT; 223 _useMask = useMask; 224 _pixel1 = pixel1; 225 _pixel2 = pixel2; 226 _p0 = p0; 227 _p1 = p1; 228 _p3 = p3; 229 _cyclic = cyclic; 230 } 231 232 - (void)setLinearGradient:(jboolean)useMask 233 linear:(jboolean)linear 234 cycleMethod:(jboolean)cycleMethod 235 numStops:(jint)numStops 236 p0:(jfloat)p0 237 p1:(jfloat)p1 238 p3:(jfloat)p3 239 fractions:(void *)fractions 240 pixels:(void *)pixels 241 { 242 J2dTraceLn(J2D_TRACE_ERROR, "setLinearGradient: UNIMPLEMENTED"); 243 [self setColor:0]; 244 } 245 246 - (void)setRadialGradient:(jboolean)useMask 247 linear:(jboolean)linear 248 cycleMethod:(jboolean)cycleMethod 249 numStops:(jint)numStops 250 m00:(jfloat)m00 251 m01:(jfloat)m01 252 m02:(jfloat)m02 253 m10:(jfloat)m10 254 m11:(jfloat)m11 255 m12:(jfloat)m12 256 focusX:(jfloat)focusX 257 fractions:(void *)fractions 258 pixels:(void *)pixels 259 { 260 J2dTraceLn(J2D_TRACE_ERROR, "setRadialGradient: UNIMPLEMENTED"); 261 [self setColor:0]; 262 } 263 264 - (void)setTexture:(jboolean)useMask 265 textureID:(id<MTLTexture>)textureID 266 filter:(jboolean)filter 267 xp0:(jdouble)xp0 268 xp1:(jdouble)xp1 269 xp3:(jdouble)xp3 270 yp0:(jdouble)yp0 271 yp1:(jdouble)yp1 272 yp3:(jdouble)yp3 273 { 274 _paintState = sun_java2d_SunGraphics2D_PAINT_TEXTURE; 275 _paintTexture = textureID; 276 277 _anchor.xParams[0] = xp0; 278 _anchor.xParams[1] = xp1; 279 _anchor.xParams[2] = xp3; 280 281 _anchor.yParams[0] = yp0; 282 _anchor.yParams[1] = yp1; 283 _anchor.yParams[2] = yp3; 284 } 285 286 static id<MTLSamplerState> samplerNearestClamp = nil; 287 static id<MTLSamplerState> samplerLinearClamp = nil; 288 static id<MTLSamplerState> samplerNearestRepeat = nil; 289 static id<MTLSamplerState> samplerLinearRepeat = nil; 290 291 void initSamplers(id<MTLDevice> device) { 292 // TODO: move this code into SamplerManager (need implement) 293 294 if (samplerNearestClamp != nil) 295 return; 296 297 MTLSamplerDescriptor *samplerDescriptor = [MTLSamplerDescriptor new]; 298 299 samplerDescriptor.rAddressMode = MTLSamplerAddressModeClampToEdge; 300 samplerDescriptor.sAddressMode = MTLSamplerAddressModeClampToEdge; 301 samplerDescriptor.tAddressMode = MTLSamplerAddressModeClampToEdge; 302 303 samplerDescriptor.minFilter = MTLSamplerMinMagFilterNearest; 304 samplerDescriptor.magFilter = MTLSamplerMinMagFilterNearest; 305 samplerNearestClamp = [device newSamplerStateWithDescriptor:samplerDescriptor]; 306 307 samplerDescriptor.minFilter = MTLSamplerMinMagFilterLinear; 308 samplerDescriptor.magFilter = MTLSamplerMinMagFilterLinear; 309 samplerLinearClamp = [device newSamplerStateWithDescriptor:samplerDescriptor]; 310 311 samplerDescriptor.rAddressMode = MTLSamplerAddressModeRepeat; 312 samplerDescriptor.sAddressMode = MTLSamplerAddressModeRepeat; 313 samplerDescriptor.tAddressMode = MTLSamplerAddressModeRepeat; 314 315 samplerDescriptor.minFilter = MTLSamplerMinMagFilterNearest; 316 samplerDescriptor.magFilter = MTLSamplerMinMagFilterNearest; 317 samplerNearestRepeat = [device newSamplerStateWithDescriptor:samplerDescriptor]; 318 319 samplerDescriptor.minFilter = MTLSamplerMinMagFilterLinear; 320 samplerDescriptor.magFilter = MTLSamplerMinMagFilterLinear; 321 samplerLinearRepeat = [device newSamplerStateWithDescriptor:samplerDescriptor]; 322 } 323 324 static void setTxtUniforms( 325 id<MTLRenderCommandEncoder> encoder, int color, int mode, int interpolation, bool repeat, jfloat extraAlpha, 326 const SurfaceRasterFlags * srcFlags, const SurfaceRasterFlags * dstFlags 327 ) { 328 struct TxtFrameUniforms uf = {RGBA_TO_V4(color), mode, srcFlags->isOpaque, dstFlags->isOpaque, interpolation}; 329 [encoder setFragmentBytes:&uf length:sizeof(uf) atIndex:FrameUniformBuffer]; 330 331 id<MTLSamplerState> sampler; 332 if (repeat) { 333 sampler = interpolation == INTERPOLATION_BILINEAR ? samplerLinearRepeat : samplerNearestRepeat; 334 } else { 335 sampler = interpolation == INTERPOLATION_BILINEAR ? samplerLinearClamp : samplerNearestClamp; 336 } 337 [encoder setFragmentSamplerState:sampler atIndex:0]; 338 } 339 340 // TODO: need support hints for all shaders 341 342 // For the current paint mode: 343 // 1. Selects vertex+fragment shaders (and corresponding pipelineDesc) and set pipelineState 344 // 2. Set vertex and fragment buffers 345 - (void)setPipelineState:(id<MTLRenderCommandEncoder>)encoder 346 composite:(MTLComposite *)composite 347 isStencilUsed:(jboolean)isStencilUsed 348 isTexture:(jboolean)isTexture 349 interpolation:(int)interpolation 350 isAA:(jboolean)isAA 351 srcFlags:(const SurfaceRasterFlags *)srcFlags 352 dstFlags:(const SurfaceRasterFlags *)dstFlags 353 pipelineStateStorage:(MTLPipelineStatesStorage *)pipelineStateStorage 354 { 355 initTemplatePipelineDescriptors(); 356 357 const bool stencil = isStencilUsed == JNI_TRUE; 358 359 id<MTLRenderPipelineState> pipelineState = nil; 360 if (isTexture) { 361 362 if (_paintState == sun_java2d_SunGraphics2D_PAINT_TEXTURE) { 363 pipelineState = [pipelineStateStorage getPipelineState:templateTexturePipelineDesc 364 vertexShaderId:@"vert_txt_tp" 365 fragmentShaderId:@"frag_txt_tp" 366 compositeRule:[composite getRule] 367 isAA:JNI_FALSE 368 srcFlags:srcFlags 369 dstFlags:dstFlags 370 stencilNeeded:stencil]; 371 [encoder setVertexBytes:&_anchor length:sizeof(_anchor) atIndex:FrameUniformBuffer]; 372 [encoder setFragmentTexture:_paintTexture atIndex: 1]; 373 374 setTxtUniforms(encoder, 0, 0, interpolation, YES, [composite getExtraAlpha], srcFlags, dstFlags); 375 } else if (_paintState == sun_java2d_SunGraphics2D_PAINT_GRADIENT) { 376 pipelineState = [pipelineStateStorage getPipelineState:templateTexturePipelineDesc 377 vertexShaderId:@"vert_txt_grad" 378 fragmentShaderId:@"frag_txt_grad" 379 compositeRule:[composite getRule] 380 isAA:JNI_FALSE 381 srcFlags:srcFlags 382 dstFlags:dstFlags 383 stencilNeeded:stencil]; 384 struct GradFrameUniforms uf = { 385 {_p0, _p1, _p3}, 386 RGBA_TO_V4(_pixel1), 387 RGBA_TO_V4(_pixel2)}; 388 [encoder setFragmentBytes: &uf length:sizeof(uf) atIndex:0]; 389 390 } else { 391 if (isAA) { 392 pipelineState = [pipelineStateStorage 393 getPipelineState:templateAATexturePipelineDesc 394 vertexShaderId:@"vert_txt" 395 fragmentShaderId:@"aa_frag_txt" 396 compositeRule:[composite getRule] 397 isAA:JNI_FALSE 398 srcFlags:srcFlags 399 dstFlags:dstFlags 400 stencilNeeded:stencil]; 401 402 } else { 403 pipelineState = 404 [pipelineStateStorage getPipelineState:templateTexturePipelineDesc 405 vertexShaderId:@"vert_txt" 406 fragmentShaderId:@"frag_txt" 407 compositeRule:[composite getRule] 408 composite:composite 409 isAA:JNI_FALSE 410 srcFlags:srcFlags 411 dstFlags:dstFlags 412 stencilNeeded:stencil]; 413 } 414 415 setTxtUniforms(encoder, _color, _paintState == sun_java2d_SunGraphics2D_PAINT_ALPHACOLOR ? 1 : 0, interpolation, NO, [composite getExtraAlpha], srcFlags, dstFlags); 416 } 417 } else { 418 if (_paintState == sun_java2d_SunGraphics2D_PAINT_ALPHACOLOR) { 419 pipelineState = [pipelineStateStorage getPipelineState:templateRenderPipelineDesc 420 vertexShaderId:@"vert_col" 421 fragmentShaderId:@"frag_col" 422 compositeRule:[composite getRule] 423 isAA:isAA 424 srcFlags:srcFlags 425 dstFlags:dstFlags 426 stencilNeeded:stencil]; 427 428 struct FrameUniforms uf = {RGBA_TO_V4(_color)}; 429 [encoder setVertexBytes:&uf length:sizeof(uf) atIndex:FrameUniformBuffer]; 430 } else if (_paintState == sun_java2d_SunGraphics2D_PAINT_GRADIENT) { 431 pipelineState = [pipelineStateStorage getPipelineState:templateRenderPipelineDesc 432 vertexShaderId:@"vert_grad" 433 fragmentShaderId:@"frag_grad" 434 compositeRule:[composite getRule] 435 isAA:isAA 436 srcFlags:srcFlags 437 dstFlags:dstFlags 438 stencilNeeded:stencil]; 439 440 struct GradFrameUniforms uf = { 441 {_p0, _p1, _p3}, 442 RGBA_TO_V4(_pixel1), 443 RGBA_TO_V4(_pixel2)}; 444 [encoder setFragmentBytes: &uf length:sizeof(uf) atIndex:0]; 445 } else if (_paintState == sun_java2d_SunGraphics2D_PAINT_TEXTURE) { 446 pipelineState = [pipelineStateStorage getPipelineState:templateRenderPipelineDesc 447 vertexShaderId:@"vert_tp" 448 fragmentShaderId:@"frag_tp" 449 compositeRule:[composite getRule] 450 isAA:isAA 451 srcFlags:srcFlags 452 dstFlags:dstFlags 453 stencilNeeded:stencil]; 454 455 [encoder setVertexBytes:&_anchor length:sizeof(_anchor) atIndex:FrameUniformBuffer]; 456 [encoder setFragmentTexture:_paintTexture atIndex: 0]; 457 } 458 } 459 460 [encoder setRenderPipelineState:pipelineState]; 461 } 462 463 464 // For the current paint mode: and for XOR composite - a separate method is added as fragment shader differ in some cases 465 // 1. Selects vertex+fragment shaders (and corresponding pipelineDesc) and set pipelineState 466 // 2. Set vertex and fragment buffers 467 - (void)setXorModePipelineState:(id<MTLRenderCommandEncoder>)encoder 468 composite:(MTLComposite *)composite 469 isStencilUsed:(jboolean)isStencilUsed 470 isTexture:(jboolean)isTexture 471 interpolation:(int)interpolation 472 srcFlags:(const SurfaceRasterFlags *)srcFlags 473 dstFlags:(const SurfaceRasterFlags *)dstFlags 474 pipelineStateStorage:(MTLPipelineStatesStorage *)pipelineStateStorage { 475 initTemplatePipelineDescriptors(); 476 477 const bool stencil = isStencilUsed == JNI_TRUE; 478 jint xorColor = (jint) [composite getXorColor]; 479 480 id<MTLRenderPipelineState> pipelineState = nil; 481 if (isTexture) { 482 pipelineState = [pipelineStateStorage getXorModePipelineState:templateTexturePipelineDesc 483 vertexShaderId:@"vert_txt" 484 fragmentShaderId:@"frag_txt" 485 srcFlags:srcFlags 486 dstFlags:dstFlags 487 stencilNeeded:stencil]; 488 const int col = _paintState == sun_java2d_SunGraphics2D_PAINT_ALPHACOLOR ? _color ^ xorColor : 0 ^ xorColor; 489 setTxtUniforms(encoder, col, _paintState == sun_java2d_SunGraphics2D_PAINT_ALPHACOLOR ? 1 : 0, interpolation, NO, [composite getExtraAlpha], srcFlags, dstFlags); 490 [encoder setFragmentBytes:&xorColor length:sizeof(xorColor) atIndex: 0]; 491 } else { 492 if (_paintState == sun_java2d_SunGraphics2D_PAINT_ALPHACOLOR) { 493 494 pipelineState = [pipelineStateStorage getXorModePipelineState:templateRenderPipelineDesc 495 vertexShaderId:@"vert_col" 496 fragmentShaderId:@"frag_col" 497 srcFlags:srcFlags 498 dstFlags:dstFlags 499 stencilNeeded:stencil]; 500 501 // Calculate _color ^ xorColor for RGB components 502 // This color gets XORed with destination framebuffer pixel color 503 struct FrameUniforms uf = {RGBA_TO_V4(_color ^ xorColor)}; 504 [encoder setVertexBytes:&uf length:sizeof(uf) atIndex:FrameUniformBuffer]; 505 506 } else if (_paintState == sun_java2d_SunGraphics2D_PAINT_GRADIENT) { 507 508 pipelineState = [pipelineStateStorage getXorModePipelineState:templateRenderPipelineDesc 509 vertexShaderId:@"vert_grad" 510 fragmentShaderId:@"frag_grad" 511 srcFlags:srcFlags 512 dstFlags:dstFlags 513 stencilNeeded:stencil]; 514 515 struct GradFrameUniforms uf = { 516 {_p0, _p1, _p3}, 517 RGBA_TO_V4(_pixel1 ^ xorColor), 518 RGBA_TO_V4(_pixel2 ^ xorColor)}; 519 [encoder setFragmentBytes: &uf length:sizeof(uf) atIndex:0]; 520 } else if (_paintState == sun_java2d_SunGraphics2D_PAINT_TEXTURE) { 521 522 pipelineState = [pipelineStateStorage getXorModePipelineState:templateRenderPipelineDesc 523 vertexShaderId:@"vert_tp" 524 fragmentShaderId:@"frag_tp_xorMode" 525 srcFlags:srcFlags 526 dstFlags:dstFlags 527 stencilNeeded:stencil]; 528 529 [encoder setVertexBytes:&_anchor length:sizeof(_anchor) atIndex:FrameUniformBuffer]; 530 [encoder setFragmentTexture:_paintTexture atIndex: 0]; 531 [encoder setFragmentBytes:&xorColor length:sizeof(xorColor) atIndex: 0]; 532 } 533 } 534 [encoder setRenderPipelineState:pipelineState]; 535 } 536 537 @end 538 539 /************************* GradientPaint support ****************************/ 540 541 static void 542 MTLPaints_InitGradientTexture() 543 { 544 //TODO 545 J2dTraceLn(J2D_TRACE_INFO, "MTLPaints_InitGradientTexture -- :TODO"); 546 } 547 548 /****************** Shared MultipleGradientPaint support ********************/ 549 550 /** 551 * These constants are identical to those defined in the 552 * MultipleGradientPaint.CycleMethod enum; they are copied here for 553 * convenience (ideally we would pull them directly from the Java level, 554 * but that entails more hassle than it is worth). 555 */ 556 #define CYCLE_NONE 0 557 #define CYCLE_REFLECT 1 558 #define CYCLE_REPEAT 2 559 560 /** 561 * The following constants are flags that can be bitwise-or'ed together 562 * to control how the MultipleGradientPaint shader source code is generated: 563 * 564 * MULTI_CYCLE_METHOD 565 * Placeholder for the CycleMethod enum constant. 566 * 567 * MULTI_LARGE 568 * If set, use the (slower) shader that supports a larger number of 569 * gradient colors; otherwise, use the optimized codepath. See 570 * the MAX_FRACTIONS_SMALL/LARGE constants below for more details. 571 * 572 * MULTI_USE_MASK 573 * If set, apply the alpha mask value from texture unit 0 to the 574 * final color result (only used in the MaskFill case). 575 * 576 * MULTI_LINEAR_RGB 577 * If set, convert the linear RGB result back into the sRGB color space. 578 */ 579 #define MULTI_CYCLE_METHOD (3 << 0) 580 #define MULTI_LARGE (1 << 2) 581 #define MULTI_USE_MASK (1 << 3) 582 #define MULTI_LINEAR_RGB (1 << 4) 583 584 /** 585 * This value determines the size of the array of programs for each 586 * MultipleGradientPaint type. This value reflects the maximum value that 587 * can be represented by performing a bitwise-or of all the MULTI_* 588 * constants defined above. 589 */ 590 #define MAX_PROGRAMS 32 591 592 /** Evaluates to true if the given bit is set on the local flags variable. */ 593 #define IS_SET(flagbit) \ 594 (((flags) & (flagbit)) != 0) 595 596 /** Composes the given parameters as flags into the given flags variable.*/ 597 #define COMPOSE_FLAGS(flags, cycleMethod, large, useMask, linear) \ 598 do { \ 599 flags |= ((cycleMethod) & MULTI_CYCLE_METHOD); \ 600 if (large) flags |= MULTI_LARGE; \ 601 if (useMask) flags |= MULTI_USE_MASK; \ 602 if (linear) flags |= MULTI_LINEAR_RGB; \ 603 } while (0) 604 605 /** Extracts the CycleMethod enum value from the given flags variable. */ 606 #define EXTRACT_CYCLE_METHOD(flags) \ 607 ((flags) & MULTI_CYCLE_METHOD) 608 609 /** 610 * The maximum number of gradient "stops" supported by the fragment shader 611 * and related code. When the MULTI_LARGE flag is set, we will use 612 * MAX_FRACTIONS_LARGE; otherwise, we use MAX_FRACTIONS_SMALL. By having 613 * two separate values, we can have one highly optimized shader (SMALL) that 614 * supports only a few fractions/colors, and then another, less optimal 615 * shader that supports more stops. 616 */ 617 #define MAX_FRACTIONS sun_java2d_pipe_BufferedPaints_MULTI_MAX_FRACTIONS 618 #define MAX_FRACTIONS_LARGE MAX_FRACTIONS 619 #define MAX_FRACTIONS_SMALL 4 620 621 /** 622 * The maximum number of gradient colors supported by all of the gradient 623 * fragment shaders. Note that this value must be a power of two, as it 624 * determines the size of the 1D texture created below. It also must be 625 * greater than or equal to MAX_FRACTIONS (there is no strict requirement 626 * that the two values be equal). 627 */ 628 #define MAX_COLORS 16 629 630 /** 631 * The handle to the gradient color table texture object used by the shaders. 632 */ 633 static jint multiGradientTexID = 0; 634 635 /** 636 * This is essentially a template of the shader source code that can be used 637 * for either LinearGradientPaint or RadialGradientPaint. It includes the 638 * structure and some variables that are common to each; the remaining 639 * code snippets (for CycleMethod, ColorSpaceType, and mask modulation) 640 * are filled in prior to compiling the shader at runtime depending on the 641 * paint parameters. See MTLPaints_CreateMultiGradProgram() for more details. 642 */ 643 static const char *multiGradientShaderSource = 644 // gradient texture size (in texels) 645 "const int TEXTURE_SIZE = %d;" 646 // maximum number of fractions/colors supported by this shader 647 "const int MAX_FRACTIONS = %d;" 648 // size of a single texel 649 "const float FULL_TEXEL = (1.0 / float(TEXTURE_SIZE));" 650 // size of half of a single texel 651 "const float HALF_TEXEL = (FULL_TEXEL / 2.0);" 652 // texture containing the gradient colors 653 "uniform sampler1D colors;" 654 // array of gradient stops/fractions 655 "uniform float fractions[MAX_FRACTIONS];" 656 // array of scale factors (one for each interval) 657 "uniform float scaleFactors[MAX_FRACTIONS-1];" 658 // (placeholder for mask variable) 659 "%s" 660 // (placeholder for Linear/RadialGP-specific variables) 661 "%s" 662 "" 663 "void main(void)" 664 "{" 665 " float dist;" 666 // (placeholder for Linear/RadialGradientPaint-specific code) 667 " %s" 668 "" 669 " float tc;" 670 // (placeholder for CycleMethod-specific code) 671 " %s" 672 "" 673 // calculate interpolated color 674 " vec4 result = texture1D(colors, tc);" 675 "" 676 // (placeholder for ColorSpace conversion code) 677 " %s" 678 "" 679 // (placeholder for mask modulation code) 680 " %s" 681 "" 682 // modulate with gl_Color in order to apply extra alpha 683 " gl_FragColor = result * gl_Color;" 684 "}"; 685 686 /** 687 * This code takes a "dist" value as input (as calculated earlier by the 688 * LGP/RGP-specific code) in the range [0,1] and produces a texture 689 * coordinate value "tc" that represents the position of the chosen color 690 * in the one-dimensional gradient texture (also in the range [0,1]). 691 * 692 * One naive way to implement this would be to iterate through the fractions 693 * to figure out in which interval "dist" falls, and then compute the 694 * relative distance between the two nearest stops. This approach would 695 * require an "if" check on every iteration, and it is best to avoid 696 * conditionals in fragment shaders for performance reasons. Also, one might 697 * be tempted to use a break statement to jump out of the loop once the 698 * interval was found, but break statements (and non-constant loop bounds) 699 * are not natively available on most graphics hardware today, so that is 700 * a non-starter. 701 * 702 * The more optimal approach used here avoids these issues entirely by using 703 * an accumulation function that is equivalent to the process described above. 704 * The scaleFactors array is pre-initialized at enable time as follows: 705 * scaleFactors[i] = 1.0 / (fractions[i+1] - fractions[i]); 706 * 707 * For each iteration, we subtract fractions[i] from dist and then multiply 708 * that value by scaleFactors[i]. If we are within the target interval, 709 * this value will be a fraction in the range [0,1] indicating the relative 710 * distance between fraction[i] and fraction[i+1]. If we are below the 711 * target interval, this value will be negative, so we clamp it to zero 712 * to avoid accumulating any value. If we are above the target interval, 713 * the value will be greater than one, so we clamp it to one. Upon exiting 714 * the loop, we will have accumulated zero or more 1.0's and a single 715 * fractional value. This accumulated value tells us the position of the 716 * fragment color in the one-dimensional gradient texture, i.e., the 717 * texcoord called "tc". 718 */ 719 static const char *texCoordCalcCode = 720 "int i;" 721 "float relFraction = 0.0;" 722 "for (i = 0; i < MAX_FRACTIONS-1; i++) {" 723 " relFraction +=" 724 " clamp((dist - fractions[i]) * scaleFactors[i], 0.0, 1.0);" 725 "}" 726 // we offset by half a texel so that we find the linearly interpolated 727 // color between the two texel centers of interest 728 "tc = HALF_TEXEL + (FULL_TEXEL * relFraction);"; 729 730 /** Code for NO_CYCLE that gets plugged into the CycleMethod placeholder. */ 731 static const char *noCycleCode = 732 "if (dist <= 0.0) {" 733 " tc = 0.0;" 734 "} else if (dist >= 1.0) {" 735 " tc = 1.0;" 736 "} else {" 737 // (placeholder for texcoord calculation) 738 " %s" 739 "}"; 740 741 /** Code for REFLECT that gets plugged into the CycleMethod placeholder. */ 742 static const char *reflectCode = 743 "dist = 1.0 - (abs(fract(dist * 0.5) - 0.5) * 2.0);" 744 // (placeholder for texcoord calculation) 745 "%s"; 746 747 /** Code for REPEAT that gets plugged into the CycleMethod placeholder. */ 748 static const char *repeatCode = 749 "dist = fract(dist);" 750 // (placeholder for texcoord calculation) 751 "%s"; 752 753 static void 754 MTLPaints_InitMultiGradientTexture() 755 { 756 J2dTraceLn(J2D_TRACE_INFO, "MTLPaints_InitMultiGradientTexture -- :TODO"); 757 } 758 759 /** 760 * Compiles and links the MultipleGradientPaint shader program. If 761 * successful, this function returns a handle to the newly created 762 * shader program; otherwise returns 0. 763 */ 764 static void* 765 MTLPaints_CreateMultiGradProgram(jint flags, 766 char *paintVars, char *distCode) 767 { 768 769 //TODO 770 J2dTraceLn(J2D_TRACE_INFO, "MTLPaints_CreateMultiGradProgram -- :TODO"); 771 772 return NULL; 773 } 774 775 /** 776 * Called from the MTLPaints_SetLinear/RadialGradientPaint() methods 777 * in order to setup the fraction/color values that are common to both. 778 */ 779 static void 780 MTLPaints_SetMultiGradientPaint(void* multiGradProgram, 781 jint numStops, 782 void *pFractions, void *pPixels) 783 { 784 //TODO 785 J2dTraceLn(J2D_TRACE_INFO, "MTLPaints_SetMultiGradientPaint -- :TODO"); 786 787 } 788 789 /********************** LinearGradientPaint support *************************/ 790 791 /** 792 * The handles to the LinearGradientPaint fragment program objects. The 793 * index to the array should be a bitwise-or'ing of the MULTI_* flags defined 794 * above. Note that most applications will likely need to initialize one 795 * or two of these elements, so the array is usually sparsely populated. 796 */ 797 static void* linearGradPrograms[MAX_PROGRAMS]; 798 799 /** 800 * Compiles and links the LinearGradientPaint shader program. If successful, 801 * this function returns a handle to the newly created shader program; 802 * otherwise returns 0. 803 */ 804 static void* 805 MTLPaints_CreateLinearGradProgram(jint flags) 806 { 807 char *paintVars; 808 char *distCode; 809 810 J2dTraceLn1(J2D_TRACE_INFO, 811 "MTLPaints_CreateLinearGradProgram", 812 flags); 813 814 /* 815 * To simplify the code and to make it easier to upload a number of 816 * uniform values at once, we pack a bunch of scalar (float) values 817 * into vec3 values below. Here's how the values are related: 818 * 819 * params.x = p0 820 * params.y = p1 821 * params.z = p3 822 * 823 * yoff = dstOps->yOffset + dstOps->height 824 */ 825 paintVars = 826 "uniform vec3 params;" 827 "uniform float yoff;"; 828 distCode = 829 // note that gl_FragCoord is in window space relative to the 830 // lower-left corner, so we have to flip the y-coordinate here 831 "vec3 fragCoord = vec3(gl_FragCoord.x, yoff-gl_FragCoord.y, 1.0);" 832 "dist = dot(params, fragCoord);"; 833 834 return MTLPaints_CreateMultiGradProgram(flags, paintVars, distCode); 835 } 836 837 /********************** RadialGradientPaint support *************************/ 838 839 /** 840 * The handles to the RadialGradientPaint fragment program objects. The 841 * index to the array should be a bitwise-or'ing of the MULTI_* flags defined 842 * above. Note that most applications will likely need to initialize one 843 * or two of these elements, so the array is usually sparsely populated. 844 */ 845 static void* radialGradPrograms[MAX_PROGRAMS]; 846 847 /** 848 * Compiles and links the RadialGradientPaint shader program. If successful, 849 * this function returns a handle to the newly created shader program; 850 * otherwise returns 0. 851 */ 852 static void* 853 MTLPaints_CreateRadialGradProgram(jint flags) 854 { 855 char *paintVars; 856 char *distCode; 857 858 J2dTraceLn1(J2D_TRACE_INFO, 859 "MTLPaints_CreateRadialGradProgram", 860 flags); 861 862 /* 863 * To simplify the code and to make it easier to upload a number of 864 * uniform values at once, we pack a bunch of scalar (float) values 865 * into vec3 and vec4 values below. Here's how the values are related: 866 * 867 * m0.x = m00 868 * m0.y = m01 869 * m0.z = m02 870 * 871 * m1.x = m10 872 * m1.y = m11 873 * m1.z = m12 874 * 875 * precalc.x = focusX 876 * precalc.y = yoff = dstOps->yOffset + dstOps->height 877 * precalc.z = 1.0 - (focusX * focusX) 878 * precalc.w = 1.0 / precalc.z 879 */ 880 paintVars = 881 "uniform vec3 m0;" 882 "uniform vec3 m1;" 883 "uniform vec4 precalc;"; 884 885 /* 886 * The following code is derived from Daniel Rice's whitepaper on 887 * radial gradient performance (attached to the bug report for 6521533). 888 * Refer to that document as well as the setup code in the Java-level 889 * BufferedPaints.setRadialGradientPaint() method for more details. 890 */ 891 distCode = 892 // note that gl_FragCoord is in window space relative to the 893 // lower-left corner, so we have to flip the y-coordinate here 894 "vec3 fragCoord =" 895 " vec3(gl_FragCoord.x, precalc.y - gl_FragCoord.y, 1.0);" 896 "float x = dot(fragCoord, m0);" 897 "float y = dot(fragCoord, m1);" 898 "float xfx = x - precalc.x;" 899 "dist = (precalc.x*xfx + sqrt(xfx*xfx + y*y*precalc.z))*precalc.w;"; 900 901 return MTLPaints_CreateMultiGradProgram(flags, paintVars, distCode); 902 } 903 904 #endif /* !HEADLESS */