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 <jlong.h>

    29 #include <jni_util.h>

    30 #include <math.h>

    31 #include <Foundation/NSObjCRuntime.h>

    32 

    33 #include "sun_java2d_metal_MetalRenderer.h"

    34 

    35 #include "MetalRenderer.h"

    36 #include "MetalRenderQueue.h"

    37 #include "MetalSurfaceData.h"

    38 #import "shaders/MetalShaderTypes.h"

    39 #include "Trace.h"

    40 #include "MetalLayer.h"

    41 #import "VertexDataManager.h"

    42 

    43 

    44 // TODO : Current Color, Gradient etc should have its own class

    45 static float drawColor[4] = {0.0, 0.0, 0.0, 0.0};

    46 static int ClipRectangle[4] = {0, 0, 0, 0};

    47 // The current size of our view so we can use this in our render pipeline

    48 // static unsigned int viewportSize[2] = {0, 0};

    49 

    50 void

    51 MetalRenderer_DrawLine(MetalContext *mtlc, jint x1, jint y1, jint x2, jint y2)

    52 {

    53     //J2dTraceLn(J2D_TRACE_INFO, "OGLRenderer_DrawLine");

    54 

    55     //RETURN_IF_NULL(mtlc);

    56 

    57     //CHECK_PREVIOUS_OP(GL_LINES);

    58   

    59     float P1_X, P1_Y;

    60     float P2_X, P2_Y;

    61      

    62     if (y1 == y2) {

    63         // horizontal

    64         float fx1 = (float)x1;

    65         float fx2 = (float)x2;

    66         float fy  = ((float)y1) + 0.2f;

    67 

    68         if (x1 > x2) {

    69             float t = fx1; fx1 = fx2; fx2 = t;

    70         }

    71 

    72         P1_X = fx1+0.2f;

    73         P1_Y = fy;

    74         P2_X = fx2+1.2f;

    75         P2_Y = fy;

    76     } else if (x1 == x2) {

    77         // vertical

    78         float fx  = ((float)x1) + 0.2f;

    79         float fy1 = (float)y1;

    80         float fy2 = (float)y2;

    81 

    82         if (y1 > y2) {

    83             float t = fy1; fy1 = fy2; fy2 = t;

    84         }

    85 

    86         P1_X = fx;

    87         P1_Y = fy1+0.2f;

    88         P2_X = fx; 

    89         P2_Y = fy2+1.2f;

    90     } else {

    91         // diagonal

    92         float fx1 = (float)x1;

    93         float fy1 = (float)y1;

    94         float fx2 = (float)x2;

    95         float fy2 = (float)y2;

    96 

    97         if (x1 < x2) {

    98             fx1 += 0.2f;

    99             fx2 += 1.0f;

   100         } else {

   101             fx1 += 0.8f;

   102             fx2 -= 0.2f;

   103         }

   104 

   105         if (y1 < y2) {

   106             fy1 += 0.2f;

   107             fy2 += 1.0f;

   108         } else {

   109             fy1 += 0.8f;

   110             fy2 -= 0.2f;

   111         }

   112 

   113         P1_X = fx1;

   114         P1_Y = fy1;

   115         P2_X = fx2;

   116         P2_Y = fy2;

   117     }

   118     

   119     // The (x1, y1) & (x2, y2) are in coordinate system :

   120     //     Top Left (0, 0) : Bottom Right (width and height)

   121     //

   122     // Metal rendering coordinate system is :

   123     //     Top Left (-1.0, 1.0) : Bottom Right (1.0, -1.0)

   124     //

   125     // This coordinate transformation happens in shader code.

   126        

   127     MetalVertex lineVertexData[] =

   128     {

   129         { {P1_X, P1_Y, 0.0, 1.0}, {drawColor[0], drawColor[1], drawColor[2], drawColor[3]} },

   130         { {P2_X, P2_Y, 0.0, 1.0}, {drawColor[0], drawColor[1], drawColor[2], drawColor[3]} }

   131     };

   132     

   133     //NSLog(@"Drawline ----- x1 : %f, y1 : %f------ x2 : %f, y2 = %f", x1/halfWidth, y1/halfHeight,  x2/halfWidth, y2/halfHeight); 

   134 

   135     VertexDataManager_addLineVertexData(lineVertexData[0], lineVertexData[1]);

   136 }

   137 

   138 

   139 

   140 void

   141 MetalRenderer_DrawParallelogram(MetalContext *mtlc,

   142                               jfloat fx11, jfloat fy11,

   143                               jfloat dx21, jfloat dy21,

   144                               jfloat dx12, jfloat dy12,

   145                               jfloat lwr21, jfloat lwr12)

   146 {

   147     // dx,dy for line width in the "21" and "12" directions.

   148     jfloat ldx21 = dx21 * lwr21;

   149     jfloat ldy21 = dy21 * lwr21;

   150     jfloat ldx12 = dx12 * lwr12;

   151     jfloat ldy12 = dy12 * lwr12;

   152 

   153     // calculate origin of the outer parallelogram

   154     jfloat ox11 = fx11 - (ldx21 + ldx12) / 2.0f;

   155     jfloat oy11 = fy11 - (ldy21 + ldy12) / 2.0f;

   156 

   157     /*J2dTraceLn8(J2D_TRACE_INFO,

   158                 "OGLRenderer_DrawParallelogram "

   159                 "(x=%6.2f y=%6.2f "

   160                 "dx1=%6.2f dy1=%6.2f lwr1=%6.2f "

   161                 "dx2=%6.2f dy2=%6.2f lwr2=%6.2f)",

   162                 fx11, fy11,

   163                 dx21, dy21, lwr21,

   164                 dx12, dy12, lwr12);*/

   165 

   166     // RETURN_IF_NULL(oglc);

   167 

   168     // CHECK_PREVIOUS_OP(GL_QUADS);

   169 

   170     // Only need to generate 4 quads if the interior still

   171     // has a hole in it (i.e. if the line width ratio was

   172     // less than 1.0)

   173     if (lwr21 < 1.0f && lwr12 < 1.0f) {

   174 

   175         // Note: "TOP", "BOTTOM", "LEFT" and "RIGHT" here are

   176         // relative to whether the dxNN variables are positive

   177         // and negative.  The math works fine regardless of

   178         // their signs, but for conceptual simplicity the

   179         // comments will refer to the sides as if the dxNN

   180         // were all positive.  "TOP" and "BOTTOM" segments

   181         // are defined by the dxy21 deltas.  "LEFT" and "RIGHT"

   182         // segments are defined by the dxy12 deltas.

   183 

   184         // Each segment includes its starting corner and comes

   185         // to just short of the following corner.  Thus, each

   186         // corner is included just once and the only lengths

   187         // needed are the original parallelogram delta lengths

   188         // and the "line width deltas".  The sides will cover

   189         // the following relative territories:

   190         //

   191         //     T T T T T R

   192         //      L         R

   193         //       L         R

   194         //        L         R

   195         //         L         R

   196         //          L B B B B B

   197 

   198         // TOP segment, to left side of RIGHT edge

   199         // "width" of original pgram, "height" of hor. line size

   200         fx11 = ox11;

   201         fy11 = oy11;

   202         FILL_PGRAM(fx11, fy11, dx21, dy21, ldx12, ldy12);

   203 

   204         // RIGHT segment, to top of BOTTOM edge

   205         // "width" of vert. line size , "height" of original pgram

   206         fx11 = ox11 + dx21;

   207         fy11 = oy11 + dy21;

   208         FILL_PGRAM(fx11, fy11, ldx21, ldy21, dx12, dy12);

   209 

   210         // BOTTOM segment, from right side of LEFT edge

   211         // "width" of original pgram, "height" of hor. line size

   212         fx11 = ox11 + dx12 + ldx21;

   213         fy11 = oy11 + dy12 + ldy21;

   214         FILL_PGRAM(fx11, fy11, dx21, dy21, ldx12, ldy12);

   215 

   216         // LEFT segment, from bottom of TOP edge

   217         // "width" of vert. line size , "height" of inner pgram

   218         fx11 = ox11 + ldx12;

   219         fy11 = oy11 + ldy12;

   220         FILL_PGRAM(fx11, fy11, ldx21, ldy21, dx12, dy12);

   221     } else {

   222         // The line width ratios were large enough to consume

   223         // the entire hole in the middle of the parallelogram

   224         // so we can just issue one large quad for the outer

   225         // parallelogram.

   226         dx21 += ldx21;

   227         dy21 += ldy21;

   228         dx12 += ldx12;

   229         dy12 += ldy12;

   230         FILL_PGRAM(ox11, oy11, dx21, dy21, dx12, dy12);

   231     }

   232 }

   233 

   234 

   235 void

   236 MetalRenderer_FillParallelogram(MetalContext *mtlc,

   237                               jfloat fx11, jfloat fy11,

   238                               jfloat dx21, jfloat dy21,

   239                               jfloat dx12, jfloat dy12)

   240 {

   241     /*J2dTraceLn6(J2D_TRACE_INFO,

   242                 "OGLRenderer_FillParallelogram "

   243                 "(x=%6.2f y=%6.2f "

   244                 "dx1=%6.2f dy1=%6.2f "

   245                 "dx2=%6.2f dy2=%6.2f)",

   246                 fx11, fy11,

   247                 dx21, dy21,

   248                 dx12, dy12);

   249 

   250     RETURN_IF_NULL(oglc);

   251 

   252     CHECK_PREVIOUS_OP(GL_QUADS);*/

   253 

   254     FILL_PGRAM(fx11, fy11, dx21, dy21, dx12, dy12);

   255 }

   256 

   257 

   258 void FILL_PGRAM(float fx11, float fy11, float dx21, float dy21, float dx12, float dy12) {

   259 

   260     MetalRenderer_DrawQuad(fx11, fy11, 

   261                             fx11 + dx21, fy11 + dy21,

   262                             fx11 + dx21 + dx12, fy11 + dy21 + dy12,

   263                             fx11 + dx12, fy11 + dy12);

   264 } 

   265 

   266 

   267 

   268 void MetalRenderer_DrawQuad(float x1, float y1, float x2, float y2, float x3, float y3, float x4, float y4) {

   269    

   270     // Draw two triangles with given 4 vertices

   271   

   272     // The (x1, y1) & (x2, y2) are in coordinate system : 

   273     //     Top Left (0, 0) : Bottom Right (width and height)

   274     //

   275     // Metal rendering coordinate system is :

   276     //     Top Left (-1.0, 1.0) : Bottom Right (1.0, -1.0)

   277     //

   278     // This coordinate transformation happens in shader code. 

   279 

   280     MetalVertex QuadVertexData[] =

   281     {

   282         { {x1, y1, 0.0, 1.0}, {drawColor[0], drawColor[1], drawColor[2], drawColor[3]} },

   283         { {x2, y2, 0.0, 1.0}, {drawColor[0], drawColor[1], drawColor[2], drawColor[3]} },

   284         { {x3, y3, 0.0, 1.0}, {drawColor[0], drawColor[1], drawColor[2], drawColor[3]} },

   285         { {x4, y4, 0.0, 1.0}, {drawColor[0], drawColor[1], drawColor[2], drawColor[3]} },

   286     };

   287 

   288     VertexDataManager_addQuadVertexData(QuadVertexData[0], QuadVertexData[1], QuadVertexData[2], QuadVertexData[3]);

   289 }

   290 

   291 

   292 void MetalRenderer_SetColor(MetalContext *mtlc, jint color) {

   293     //J2dTraceLn(J2D_TRACE_INFO, "MetalRenderer_SetColor");

   294     unsigned char r = (unsigned char)(color >> 16);

   295     unsigned char g = (unsigned char)(color >>  8);

   296     unsigned char b = (unsigned char)(color >>  0);

   297     unsigned char a = 0xff;

   298     

   299     drawColor[0] = r/255.0;

   300     drawColor[1] = g/255.0;

   301     drawColor[2] = b/255.0;

   302     drawColor[3] = 1.0;

   303     

   304     NSLog(@"MetalRenderer SetColor  ----- (%d, %d, %d, %d)", r, g, b, a);

   305 }

   306 

   307 

   308 void MetalRenderer_DrawRect(MetalContext *mtlc,

   309                           jint x, jint y, jint w, jint h) {

   310     //J2dTraceLn(J2D_TRACE_INFO, "OGLRenderer_DrawRect");

   311 

   312     if (w < 0 || h < 0) {

   313         return;

   314     }

   315 

   316     //RETURN_IF_NULL(oglc);

   317 

   318     if (w < 2 || h < 2) {

   319         // If one dimension is less than 2 then there is no

   320         // gap in the middle - draw a solid filled rectangle.

   321         //CHECK_PREVIOUS_OP(GL_QUADS);

   322         //GLRECT_BODY_XYWH(x, y, w+1, h+1);

   323         MetalRenderer_FillRect(mtlc, x, y, w+1, h+1);

   324     } else {

   325         jint fx1 = (jint) (((float)x) + 0.2f);

   326         jint fy1 = (jint) (((float)y) + 0.2f);

   327         jint fx2 = fx1 + w;

   328         jint fy2 = fy1 + h;

   329 

   330         // Avoid drawing the endpoints twice.

   331         // Also prefer including the endpoints in the

   332         // horizontal sections which draw pixels faster.

   333 

   334         // top

   335         MetalRenderer_DrawLine(mtlc, fx1, fy1, fx2+1, fy1);

   336         

   337         // right

   338         MetalRenderer_DrawLine(mtlc, fx2, fy1+1, fx2, fy2);

   339 

   340         // bottom

   341         MetalRenderer_DrawLine(mtlc, fx1, fy2, fx2+1, fy2);

   342 

   343 

   344         // left

   345         MetalRenderer_DrawLine(mtlc, fx1, fy1+1, fx1, fy2);

   346     }

   347 }

   348 

   349 

   350 void

   351 MetalRenderer_FillRect(MetalContext *mtlc, jint x, jint y, jint w, jint h)

   352 {

   353     //J2dTraceLn(J2D_TRACE_INFO, "MetalRenderer_FillRect");

   354 

   355     if (w <= 0 || h <= 0) {

   356         return;

   357     }

   358 

   359     //RETURN_IF_NULL(oglc);

   360 

   361     //CHECK_PREVIOUS_OP(GL_QUADS);

   362     //GLRECT_BODY_XYWH(x, y, w, h);

   363 

   364     

   365     MetalRenderer_DrawQuad(x, y, x, y+h, x+w, y+h, x+w, y);

   366 

   367     //NSLog(@"MetalRenderer_FillRect: X, Y(%f, %f) with width, height(%f, %f)", (float)x, (float)y, (float)w, (float)h);

   368 }

   369 

   370 // TODO : I think, this should go to metal context

   371 void MetalRenderer_SetRectClip(MetalContext *mtlc, jint x1, jint y1, jint x2, jint y2) {

   372 

   373     jint width = x2 - x1;

   374     jint height = y2 - y1;

   375 

   376     J2dTraceLn4(J2D_TRACE_INFO,

   377                 "MetalRenderer_SetRectClip: x=%d y=%d w=%d h=%d",

   378                 x1, y1, width, height);

   379 

   380     //RETURN_IF_NULL(dstOps);

   381     //RETURN_IF_NULL(oglc);

   382     //CHECK_PREVIOUS_OP(OGL_STATE_CHANGE);

   383 

   384     if ((width < 0) || (height < 0)) {

   385         // use an empty scissor rectangle when the region is empty

   386         width = 0;

   387         height = 0;

   388     }

   389 

   390     //j2d_glDisable(GL_DEPTH_TEST);

   391     //j2d_glEnable(GL_SCISSOR_TEST);

   392 

   393     // the scissor rectangle is specified using the lower-left

   394     // origin of the clip region (in the framebuffer's coordinate

   395     // space), so we must account for the x/y offsets of the

   396     // destination surface

   397     /*j2d_glScissor(dstOps->xOffset + x1,

   398                   dstOps->yOffset + dstOps->height - (y1 + height),

   399                   width, height);*/

   400 

   401     MetalSDOps *dstOps = MetalRenderQueue_GetCurrentDestination();  

   402 

   403     ClipRectangle[0] = x1;//dstOps->xOffset + x1;

   404     ClipRectangle[1] = y1;//dstOps->yOffset + dstOps->height - (y1 + height);

   405     ClipRectangle[2] = width;

   406     ClipRectangle[3] = height; 

   407 

   408 }

   409 

   410 void MetalRenderer_Flush() {

   411 

   412     MetalSDOps* dstOps = MetalRenderQueue_GetCurrentDestination();  

   413     MetalLayer* mtlLayer = dstOps->layer;

   414 

   415     unsigned int viewportSize[2] = {mtlLayer.textureWidth, mtlLayer.textureHeight};

   416 

   417     //Create a render pass descriptor

   418     MTLRenderPassDescriptor* mtlRenderPassDescriptor = [MTLRenderPassDescriptor renderPassDescriptor];

   419         

   420     //Set the SurfaceData offscreen texture as target texture for the rendering pipeline

   421     mtlRenderPassDescriptor.colorAttachments[0].texture = dstOps->mtlTexture;

   422 

   423     mtlRenderPassDescriptor.colorAttachments[0].loadAction = MTLLoadActionClear;

   424     mtlRenderPassDescriptor.colorAttachments[0].clearColor = MTLClearColorMake(0.8, 0.8, 0.8, 1.0);

   425     mtlRenderPassDescriptor.colorAttachments[0].storeAction = MTLStoreActionStore;

   426 

   427     id<MTLCommandBuffer> mtlCommandBuffer = [dstOps->configInfo->commandQueue commandBuffer];

   428     id<MTLRenderCommandEncoder> renderEncoder = [mtlCommandBuffer renderCommandEncoderWithDescriptor:mtlRenderPassDescriptor];

   429 

   430     // Configure render enconder with the pipeline state

   431     [renderEncoder setRenderPipelineState:mtlLayer.renderPipelineState];

   432 

   433     // Whatever outside this rectangle won't be drawn

   434     // TODO : ClipRectangle should be part of MetalContext or some state maintaining class

   435     NSLog(@"Setting Rect Clip : %d, %d, %d, %d", ClipRectangle[0], ClipRectangle[1], ClipRectangle[2], ClipRectangle[3]);

   436     MTLScissorRect clip = {ClipRectangle[0], ClipRectangle[1], ClipRectangle[2], ClipRectangle[3]};

   437     [renderEncoder setScissorRect:clip];

   438 

   439     // ---------------------------------------------------------

   440     // DRAW primitives from VertexDataManager

   441     // ---------------------------------------------------------    

   442     [renderEncoder setVertexBuffer:VertexDataManager_getVertexBuffer() offset:0 atIndex:0]; // 0th index 

   443     

   444     [renderEncoder setVertexBytes: &viewportSize

   445                            length: sizeof(viewportSize)

   446                           atIndex: 1]; // 1st index

   447 

   448     MetalPrimitiveData** allPrimitives = VertexDataManager_getAllPrimitives();

   449 

   450     int totalPrimitives = VertexDataManager_getNoOfPrimitives();

   451     for (int i = 0; i < totalPrimitives; i++ ) {

   452         MetalPrimitiveData* p = allPrimitives[i];

   453 

   454         NSLog(@"----------------------------------------------");

   455         NSLog(@"Encoding primitive %d", i);

   456         NSLog(@"indexCount %d", p->no_of_indices);

   457         NSLog(@"indexBufferOffset %d", p->offset_in_index_buffer);

   458         NSLog(@"primitiveInstances %d", p->primitiveInstances);    

   459         NSLog(@"----------------------------------------------");

   460 

   461 

   462         [renderEncoder drawIndexedPrimitives: p->type

   463                                   indexCount: (NSUInteger)p->no_of_indices 

   464                                    indexType: (MTLIndexType)MTLIndexTypeUInt16

   465                                  indexBuffer: (id<MTLBuffer>)VertexDataManager_getIndexBuffer() 

   466                            indexBufferOffset: (NSUInteger)p->offset_in_index_buffer 

   467                                instanceCount: (NSUInteger)p->primitiveInstances];

   468     }

   469 

   470     //--------------------------------------------------  

   471 

   472     [renderEncoder endEncoding];

   473    

   474     [mtlCommandBuffer commit];

   475 

   476     [mtlCommandBuffer waitUntilCompleted];

   477 }

   478 

   479 

   480 void MetalRenderer_blitToScreenDrawable() {

   481  

   482     MetalSDOps* dstOps = MetalRenderQueue_GetCurrentDestination();  

   483     MetalLayer* mtlLayer = dstOps->layer;

   484     

   485     @autoreleasepool {

   486         id <CAMetalDrawable> frameDrawable = [mtlLayer nextDrawable];

   487 

   488         id<MTLCommandBuffer> commandBuffer = [dstOps->configInfo->commandQueue commandBuffer];

   489     

   490         id<MTLBlitCommandEncoder> blitEncoder = [commandBuffer blitCommandEncoder];

   491    

   492         //[blitEncoder synchronizeResource:_texture];

   493 

   494         [blitEncoder copyFromTexture:dstOps->mtlTexture

   495                      sourceSlice:0

   496                      sourceLevel:0

   497                      sourceOrigin:MTLOriginMake(ClipRectangle[0], ClipRectangle[1], 0)

   498                      sourceSize:MTLSizeMake(dstOps->mtlTexture.width - ClipRectangle[0], dstOps->mtlTexture.height - ClipRectangle[1], 1)

   499                      toTexture:frameDrawable.texture

   500                      destinationSlice:0

   501                      destinationLevel:0

   502                      destinationOrigin:MTLOriginMake(0, 0, 0)];

   503        

   504         [blitEncoder endEncoding];

   505     

   506         [commandBuffer presentDrawable:frameDrawable];

   507     

   508         [commandBuffer commit];

   509     

   510         [commandBuffer waitUntilCompleted];

   511     }

   512 }

   513 

   514 #endif