src/render/software/SDL_blendline.c
author Ryan C. Gordon <icculus@icculus.org>
Thu, 13 Oct 2011 01:08:30 -0400
changeset 5981 75caa8a7d559
parent 5535 96594ac5fd1a
child 6138 4c64952a58fb
permissions -rw-r--r--
Fixed a whole slew of compiler warnings that -Wall exposed.
     1 /*
     2   Simple DirectMedia Layer
     3   Copyright (C) 1997-2011 Sam Lantinga <slouken@libsdl.org>
     4 
     5   This software is provided 'as-is', without any express or implied
     6   warranty.  In no event will the authors be held liable for any damages
     7   arising from the use of this software.
     8 
     9   Permission is granted to anyone to use this software for any purpose,
    10   including commercial applications, and to alter it and redistribute it
    11   freely, subject to the following restrictions:
    12 
    13   1. The origin of this software must not be misrepresented; you must not
    14      claim that you wrote the original software. If you use this software
    15      in a product, an acknowledgment in the product documentation would be
    16      appreciated but is not required.
    17   2. Altered source versions must be plainly marked as such, and must not be
    18      misrepresented as being the original software.
    19   3. This notice may not be removed or altered from any source distribution.
    20 */
    21 #include "SDL_config.h"
    22 
    23 #if !SDL_RENDER_DISABLED
    24 
    25 #include "SDL_draw.h"
    26 #include "SDL_blendline.h"
    27 #include "SDL_blendpoint.h"
    28 
    29 
    30 static void
    31 SDL_BlendLine_RGB2(SDL_Surface * dst, int x1, int y1, int x2, int y2,
    32                    SDL_BlendMode blendMode, Uint8 _r, Uint8 _g, Uint8 _b, Uint8 _a,
    33                    SDL_bool draw_end)
    34 {
    35     const SDL_PixelFormat *fmt = dst->format;
    36     unsigned r, g, b, a, inva;
    37 
    38     if (blendMode == SDL_BLENDMODE_BLEND || blendMode == SDL_BLENDMODE_ADD) {
    39         r = DRAW_MUL(_r, _a);
    40         g = DRAW_MUL(_g, _a);
    41         b = DRAW_MUL(_b, _a);
    42         a = _a;
    43     } else {
    44         r = _r;
    45         g = _g;
    46         b = _b;
    47         a = _a;
    48     }
    49     inva = (a ^ 0xff);
    50 
    51     if (y1 == y2) {
    52         switch (blendMode) {
    53         case SDL_BLENDMODE_BLEND:
    54             HLINE(Uint16, DRAW_SETPIXEL_BLEND_RGB, draw_end);
    55             break;
    56         case SDL_BLENDMODE_ADD:
    57             HLINE(Uint16, DRAW_SETPIXEL_ADD_RGB, draw_end);
    58             break;
    59         case SDL_BLENDMODE_MOD:
    60             HLINE(Uint16, DRAW_SETPIXEL_MOD_RGB, draw_end);
    61             break;
    62         default:
    63             HLINE(Uint16, DRAW_SETPIXEL_RGB, draw_end);
    64             break;
    65         }
    66     } else if (x1 == x2) {
    67         switch (blendMode) {
    68         case SDL_BLENDMODE_BLEND:
    69             VLINE(Uint16, DRAW_SETPIXEL_BLEND_RGB, draw_end);
    70             break;
    71         case SDL_BLENDMODE_ADD:
    72             VLINE(Uint16, DRAW_SETPIXEL_ADD_RGB, draw_end);
    73             break;
    74         case SDL_BLENDMODE_MOD:
    75             VLINE(Uint16, DRAW_SETPIXEL_MOD_RGB, draw_end);
    76             break;
    77         default:
    78             VLINE(Uint16, DRAW_SETPIXEL_RGB, draw_end);
    79             break;
    80         }
    81     } else if (ABS(x1 - x2) == ABS(y1 - y2)) {
    82         switch (blendMode) {
    83         case SDL_BLENDMODE_BLEND:
    84             DLINE(Uint16, DRAW_SETPIXEL_BLEND_RGB, draw_end);
    85             break;
    86         case SDL_BLENDMODE_ADD:
    87             DLINE(Uint16, DRAW_SETPIXEL_ADD_RGB, draw_end);
    88             break;
    89         case SDL_BLENDMODE_MOD:
    90             DLINE(Uint16, DRAW_SETPIXEL_MOD_RGB, draw_end);
    91             break;
    92         default:
    93             DLINE(Uint16, DRAW_SETPIXEL_RGB, draw_end);
    94             break;
    95         }
    96     } else {
    97         switch (blendMode) {
    98         case SDL_BLENDMODE_BLEND:
    99             AALINE(x1, y1, x2, y2,
   100                    DRAW_SETPIXELXY2_BLEND_RGB, DRAW_SETPIXELXY2_BLEND_RGB,
   101                    draw_end);
   102             break;
   103         case SDL_BLENDMODE_ADD:
   104             AALINE(x1, y1, x2, y2,
   105                    DRAW_SETPIXELXY2_ADD_RGB, DRAW_SETPIXELXY2_ADD_RGB,
   106                    draw_end);
   107             break;
   108         case SDL_BLENDMODE_MOD:
   109             AALINE(x1, y1, x2, y2,
   110                    DRAW_SETPIXELXY2_MOD_RGB, DRAW_SETPIXELXY2_MOD_RGB,
   111                    draw_end);
   112             break;
   113         default:
   114             AALINE(x1, y1, x2, y2,
   115                    DRAW_SETPIXELXY2_RGB, DRAW_SETPIXELXY2_BLEND_RGB,
   116                    draw_end);
   117             break;
   118         }
   119     }
   120 }
   121 
   122 static void
   123 SDL_BlendLine_RGB555(SDL_Surface * dst, int x1, int y1, int x2, int y2,
   124                      SDL_BlendMode blendMode, Uint8 _r, Uint8 _g, Uint8 _b, Uint8 _a,
   125                      SDL_bool draw_end)
   126 {
   127     unsigned r, g, b, a, inva;
   128 
   129     if (blendMode == SDL_BLENDMODE_BLEND || blendMode == SDL_BLENDMODE_ADD) {
   130         r = DRAW_MUL(_r, _a);
   131         g = DRAW_MUL(_g, _a);
   132         b = DRAW_MUL(_b, _a);
   133         a = _a;
   134     } else {
   135         r = _r;
   136         g = _g;
   137         b = _b;
   138         a = _a;
   139     }
   140     inva = (a ^ 0xff);
   141 
   142     if (y1 == y2) {
   143         switch (blendMode) {
   144         case SDL_BLENDMODE_BLEND:
   145             HLINE(Uint16, DRAW_SETPIXEL_BLEND_RGB555, draw_end);
   146             break;
   147         case SDL_BLENDMODE_ADD:
   148             HLINE(Uint16, DRAW_SETPIXEL_ADD_RGB555, draw_end);
   149             break;
   150         case SDL_BLENDMODE_MOD:
   151             HLINE(Uint16, DRAW_SETPIXEL_MOD_RGB555, draw_end);
   152             break;
   153         default:
   154             HLINE(Uint16, DRAW_SETPIXEL_RGB555, draw_end);
   155             break;
   156         }
   157     } else if (x1 == x2) {
   158         switch (blendMode) {
   159         case SDL_BLENDMODE_BLEND:
   160             VLINE(Uint16, DRAW_SETPIXEL_BLEND_RGB555, draw_end);
   161             break;
   162         case SDL_BLENDMODE_ADD:
   163             VLINE(Uint16, DRAW_SETPIXEL_ADD_RGB555, draw_end);
   164             break;
   165         case SDL_BLENDMODE_MOD:
   166             VLINE(Uint16, DRAW_SETPIXEL_MOD_RGB555, draw_end);
   167             break;
   168         default:
   169             VLINE(Uint16, DRAW_SETPIXEL_RGB555, draw_end);
   170             break;
   171         }
   172     } else if (ABS(x1 - x2) == ABS(y1 - y2)) {
   173         switch (blendMode) {
   174         case SDL_BLENDMODE_BLEND:
   175             DLINE(Uint16, DRAW_SETPIXEL_BLEND_RGB555, draw_end);
   176             break;
   177         case SDL_BLENDMODE_ADD:
   178             DLINE(Uint16, DRAW_SETPIXEL_ADD_RGB555, draw_end);
   179             break;
   180         case SDL_BLENDMODE_MOD:
   181             DLINE(Uint16, DRAW_SETPIXEL_MOD_RGB555, draw_end);
   182             break;
   183         default:
   184             DLINE(Uint16, DRAW_SETPIXEL_RGB555, draw_end);
   185             break;
   186         }
   187     } else {
   188         switch (blendMode) {
   189         case SDL_BLENDMODE_BLEND:
   190             AALINE(x1, y1, x2, y2,
   191                    DRAW_SETPIXELXY_BLEND_RGB555, DRAW_SETPIXELXY_BLEND_RGB555,
   192                    draw_end);
   193             break;
   194         case SDL_BLENDMODE_ADD:
   195             AALINE(x1, y1, x2, y2,
   196                    DRAW_SETPIXELXY_ADD_RGB555, DRAW_SETPIXELXY_ADD_RGB555,
   197                    draw_end);
   198             break;
   199         case SDL_BLENDMODE_MOD:
   200             AALINE(x1, y1, x2, y2,
   201                    DRAW_SETPIXELXY_MOD_RGB555, DRAW_SETPIXELXY_MOD_RGB555,
   202                    draw_end);
   203             break;
   204         default:
   205             AALINE(x1, y1, x2, y2,
   206                    DRAW_SETPIXELXY_RGB555, DRAW_SETPIXELXY_BLEND_RGB555,
   207                    draw_end);
   208             break;
   209         }
   210     }
   211 }
   212 
   213 static void
   214 SDL_BlendLine_RGB565(SDL_Surface * dst, int x1, int y1, int x2, int y2,
   215                      SDL_BlendMode blendMode, Uint8 _r, Uint8 _g, Uint8 _b, Uint8 _a,
   216                      SDL_bool draw_end)
   217 {
   218     unsigned r, g, b, a, inva;
   219 
   220     if (blendMode == SDL_BLENDMODE_BLEND || blendMode == SDL_BLENDMODE_ADD) {
   221         r = DRAW_MUL(_r, _a);
   222         g = DRAW_MUL(_g, _a);
   223         b = DRAW_MUL(_b, _a);
   224         a = _a;
   225     } else {
   226         r = _r;
   227         g = _g;
   228         b = _b;
   229         a = _a;
   230     }
   231     inva = (a ^ 0xff);
   232 
   233     if (y1 == y2) {
   234         switch (blendMode) {
   235         case SDL_BLENDMODE_BLEND:
   236             HLINE(Uint16, DRAW_SETPIXEL_BLEND_RGB565, draw_end);
   237             break;
   238         case SDL_BLENDMODE_ADD:
   239             HLINE(Uint16, DRAW_SETPIXEL_ADD_RGB565, draw_end);
   240             break;
   241         case SDL_BLENDMODE_MOD:
   242             HLINE(Uint16, DRAW_SETPIXEL_MOD_RGB565, draw_end);
   243             break;
   244         default:
   245             HLINE(Uint16, DRAW_SETPIXEL_RGB565, draw_end);
   246             break;
   247         }
   248     } else if (x1 == x2) {
   249         switch (blendMode) {
   250         case SDL_BLENDMODE_BLEND:
   251             VLINE(Uint16, DRAW_SETPIXEL_BLEND_RGB565, draw_end);
   252             break;
   253         case SDL_BLENDMODE_ADD:
   254             VLINE(Uint16, DRAW_SETPIXEL_ADD_RGB565, draw_end);
   255             break;
   256         case SDL_BLENDMODE_MOD:
   257             VLINE(Uint16, DRAW_SETPIXEL_MOD_RGB565, draw_end);
   258             break;
   259         default:
   260             VLINE(Uint16, DRAW_SETPIXEL_RGB565, draw_end);
   261             break;
   262         }
   263     } else if (ABS(x1 - x2) == ABS(y1 - y2)) {
   264         switch (blendMode) {
   265         case SDL_BLENDMODE_BLEND:
   266             DLINE(Uint16, DRAW_SETPIXEL_BLEND_RGB565, draw_end);
   267             break;
   268         case SDL_BLENDMODE_ADD:
   269             DLINE(Uint16, DRAW_SETPIXEL_ADD_RGB565, draw_end);
   270             break;
   271         case SDL_BLENDMODE_MOD:
   272             DLINE(Uint16, DRAW_SETPIXEL_MOD_RGB565, draw_end);
   273             break;
   274         default:
   275             DLINE(Uint16, DRAW_SETPIXEL_RGB565, draw_end);
   276             break;
   277         }
   278     } else {
   279         switch (blendMode) {
   280         case SDL_BLENDMODE_BLEND:
   281             AALINE(x1, y1, x2, y2,
   282                    DRAW_SETPIXELXY_BLEND_RGB565, DRAW_SETPIXELXY_BLEND_RGB565,
   283                    draw_end);
   284             break;
   285         case SDL_BLENDMODE_ADD:
   286             AALINE(x1, y1, x2, y2,
   287                    DRAW_SETPIXELXY_ADD_RGB565, DRAW_SETPIXELXY_ADD_RGB565,
   288                    draw_end);
   289             break;
   290         case SDL_BLENDMODE_MOD:
   291             AALINE(x1, y1, x2, y2,
   292                    DRAW_SETPIXELXY_MOD_RGB565, DRAW_SETPIXELXY_MOD_RGB565,
   293                    draw_end);
   294             break;
   295         default:
   296             AALINE(x1, y1, x2, y2,
   297                    DRAW_SETPIXELXY_RGB565, DRAW_SETPIXELXY_BLEND_RGB565,
   298                    draw_end);
   299             break;
   300         }
   301     }
   302 }
   303 
   304 static void
   305 SDL_BlendLine_RGB4(SDL_Surface * dst, int x1, int y1, int x2, int y2,
   306                    SDL_BlendMode blendMode, Uint8 _r, Uint8 _g, Uint8 _b, Uint8 _a,
   307                    SDL_bool draw_end)
   308 {
   309     const SDL_PixelFormat *fmt = dst->format;
   310     unsigned r, g, b, a, inva;
   311 
   312     if (blendMode == SDL_BLENDMODE_BLEND || blendMode == SDL_BLENDMODE_ADD) {
   313         r = DRAW_MUL(_r, _a);
   314         g = DRAW_MUL(_g, _a);
   315         b = DRAW_MUL(_b, _a);
   316         a = _a;
   317     } else {
   318         r = _r;
   319         g = _g;
   320         b = _b;
   321         a = _a;
   322     }
   323     inva = (a ^ 0xff);
   324 
   325     if (y1 == y2) {
   326         switch (blendMode) {
   327         case SDL_BLENDMODE_BLEND:
   328             HLINE(Uint32, DRAW_SETPIXEL_BLEND_RGB, draw_end);
   329             break;
   330         case SDL_BLENDMODE_ADD:
   331             HLINE(Uint32, DRAW_SETPIXEL_ADD_RGB, draw_end);
   332             break;
   333         case SDL_BLENDMODE_MOD:
   334             HLINE(Uint32, DRAW_SETPIXEL_MOD_RGB, draw_end);
   335             break;
   336         default:
   337             HLINE(Uint32, DRAW_SETPIXEL_RGB, draw_end);
   338             break;
   339         }
   340     } else if (x1 == x2) {
   341         switch (blendMode) {
   342         case SDL_BLENDMODE_BLEND:
   343             VLINE(Uint32, DRAW_SETPIXEL_BLEND_RGB, draw_end);
   344             break;
   345         case SDL_BLENDMODE_ADD:
   346             VLINE(Uint32, DRAW_SETPIXEL_ADD_RGB, draw_end);
   347             break;
   348         case SDL_BLENDMODE_MOD:
   349             VLINE(Uint32, DRAW_SETPIXEL_MOD_RGB, draw_end);
   350             break;
   351         default:
   352             VLINE(Uint32, DRAW_SETPIXEL_RGB, draw_end);
   353             break;
   354         }
   355     } else if (ABS(x1 - x2) == ABS(y1 - y2)) {
   356         switch (blendMode) {
   357         case SDL_BLENDMODE_BLEND:
   358             DLINE(Uint32, DRAW_SETPIXEL_BLEND_RGB, draw_end);
   359             break;
   360         case SDL_BLENDMODE_ADD:
   361             DLINE(Uint32, DRAW_SETPIXEL_ADD_RGB, draw_end);
   362             break;
   363         case SDL_BLENDMODE_MOD:
   364             DLINE(Uint32, DRAW_SETPIXEL_MOD_RGB, draw_end);
   365             break;
   366         default:
   367             DLINE(Uint32, DRAW_SETPIXEL_RGB, draw_end);
   368             break;
   369         }
   370     } else {
   371         switch (blendMode) {
   372         case SDL_BLENDMODE_BLEND:
   373             AALINE(x1, y1, x2, y2,
   374                    DRAW_SETPIXELXY4_BLEND_RGB, DRAW_SETPIXELXY4_BLEND_RGB,
   375                    draw_end);
   376             break;
   377         case SDL_BLENDMODE_ADD:
   378             AALINE(x1, y1, x2, y2,
   379                    DRAW_SETPIXELXY4_ADD_RGB, DRAW_SETPIXELXY4_ADD_RGB,
   380                    draw_end);
   381             break;
   382         case SDL_BLENDMODE_MOD:
   383             AALINE(x1, y1, x2, y2,
   384                    DRAW_SETPIXELXY4_MOD_RGB, DRAW_SETPIXELXY4_MOD_RGB,
   385                    draw_end);
   386             break;
   387         default:
   388             AALINE(x1, y1, x2, y2,
   389                    DRAW_SETPIXELXY4_RGB, DRAW_SETPIXELXY4_BLEND_RGB,
   390                    draw_end);
   391             break;
   392         }
   393     }
   394 }
   395 
   396 static void
   397 SDL_BlendLine_RGBA4(SDL_Surface * dst, int x1, int y1, int x2, int y2,
   398                     SDL_BlendMode blendMode, Uint8 _r, Uint8 _g, Uint8 _b, Uint8 _a,
   399                     SDL_bool draw_end)
   400 {
   401     const SDL_PixelFormat *fmt = dst->format;
   402     unsigned r, g, b, a, inva;
   403 
   404     if (blendMode == SDL_BLENDMODE_BLEND || blendMode == SDL_BLENDMODE_ADD) {
   405         r = DRAW_MUL(_r, _a);
   406         g = DRAW_MUL(_g, _a);
   407         b = DRAW_MUL(_b, _a);
   408         a = _a;
   409     } else {
   410         r = _r;
   411         g = _g;
   412         b = _b;
   413         a = _a;
   414     }
   415     inva = (a ^ 0xff);
   416 
   417     if (y1 == y2) {
   418         switch (blendMode) {
   419         case SDL_BLENDMODE_BLEND:
   420             HLINE(Uint32, DRAW_SETPIXEL_BLEND_RGBA, draw_end);
   421             break;
   422         case SDL_BLENDMODE_ADD:
   423             HLINE(Uint32, DRAW_SETPIXEL_ADD_RGBA, draw_end);
   424             break;
   425         case SDL_BLENDMODE_MOD:
   426             HLINE(Uint32, DRAW_SETPIXEL_MOD_RGBA, draw_end);
   427             break;
   428         default:
   429             HLINE(Uint32, DRAW_SETPIXEL_RGBA, draw_end);
   430             break;
   431         }
   432     } else if (x1 == x2) {
   433         switch (blendMode) {
   434         case SDL_BLENDMODE_BLEND:
   435             VLINE(Uint32, DRAW_SETPIXEL_BLEND_RGBA, draw_end);
   436             break;
   437         case SDL_BLENDMODE_ADD:
   438             VLINE(Uint32, DRAW_SETPIXEL_ADD_RGBA, draw_end);
   439             break;
   440         case SDL_BLENDMODE_MOD:
   441             VLINE(Uint32, DRAW_SETPIXEL_MOD_RGBA, draw_end);
   442             break;
   443         default:
   444             VLINE(Uint32, DRAW_SETPIXEL_RGBA, draw_end);
   445             break;
   446         }
   447     } else if (ABS(x1 - x2) == ABS(y1 - y2)) {
   448         switch (blendMode) {
   449         case SDL_BLENDMODE_BLEND:
   450             DLINE(Uint32, DRAW_SETPIXEL_BLEND_RGBA, draw_end);
   451             break;
   452         case SDL_BLENDMODE_ADD:
   453             DLINE(Uint32, DRAW_SETPIXEL_ADD_RGBA, draw_end);
   454             break;
   455         case SDL_BLENDMODE_MOD:
   456             DLINE(Uint32, DRAW_SETPIXEL_MOD_RGBA, draw_end);
   457             break;
   458         default:
   459             DLINE(Uint32, DRAW_SETPIXEL_RGBA, draw_end);
   460             break;
   461         }
   462     } else {
   463         switch (blendMode) {
   464         case SDL_BLENDMODE_BLEND:
   465             AALINE(x1, y1, x2, y2,
   466                    DRAW_SETPIXELXY4_BLEND_RGBA, DRAW_SETPIXELXY4_BLEND_RGBA,
   467                    draw_end);
   468             break;
   469         case SDL_BLENDMODE_ADD:
   470             AALINE(x1, y1, x2, y2,
   471                    DRAW_SETPIXELXY4_ADD_RGBA, DRAW_SETPIXELXY4_ADD_RGBA,
   472                    draw_end);
   473             break;
   474         case SDL_BLENDMODE_MOD:
   475             AALINE(x1, y1, x2, y2,
   476                    DRAW_SETPIXELXY4_MOD_RGBA, DRAW_SETPIXELXY4_MOD_RGBA,
   477                    draw_end);
   478             break;
   479         default:
   480             AALINE(x1, y1, x2, y2,
   481                    DRAW_SETPIXELXY4_RGBA, DRAW_SETPIXELXY4_BLEND_RGBA,
   482                    draw_end);
   483             break;
   484         }
   485     }
   486 }
   487 
   488 static void
   489 SDL_BlendLine_RGB888(SDL_Surface * dst, int x1, int y1, int x2, int y2,
   490                      SDL_BlendMode blendMode, Uint8 _r, Uint8 _g, Uint8 _b, Uint8 _a,
   491                      SDL_bool draw_end)
   492 {
   493     unsigned r, g, b, a, inva;
   494 
   495     if (blendMode == SDL_BLENDMODE_BLEND || blendMode == SDL_BLENDMODE_ADD) {
   496         r = DRAW_MUL(_r, _a);
   497         g = DRAW_MUL(_g, _a);
   498         b = DRAW_MUL(_b, _a);
   499         a = _a;
   500     } else {
   501         r = _r;
   502         g = _g;
   503         b = _b;
   504         a = _a;
   505     }
   506     inva = (a ^ 0xff);
   507 
   508     if (y1 == y2) {
   509         switch (blendMode) {
   510         case SDL_BLENDMODE_BLEND:
   511             HLINE(Uint32, DRAW_SETPIXEL_BLEND_RGB888, draw_end);
   512             break;
   513         case SDL_BLENDMODE_ADD:
   514             HLINE(Uint32, DRAW_SETPIXEL_ADD_RGB888, draw_end);
   515             break;
   516         case SDL_BLENDMODE_MOD:
   517             HLINE(Uint32, DRAW_SETPIXEL_MOD_RGB888, draw_end);
   518             break;
   519         default:
   520             HLINE(Uint32, DRAW_SETPIXEL_RGB888, draw_end);
   521             break;
   522         }
   523     } else if (x1 == x2) {
   524         switch (blendMode) {
   525         case SDL_BLENDMODE_BLEND:
   526             VLINE(Uint32, DRAW_SETPIXEL_BLEND_RGB888, draw_end);
   527             break;
   528         case SDL_BLENDMODE_ADD:
   529             VLINE(Uint32, DRAW_SETPIXEL_ADD_RGB888, draw_end);
   530             break;
   531         case SDL_BLENDMODE_MOD:
   532             VLINE(Uint32, DRAW_SETPIXEL_MOD_RGB888, draw_end);
   533             break;
   534         default:
   535             VLINE(Uint32, DRAW_SETPIXEL_RGB888, draw_end);
   536             break;
   537         }
   538     } else if (ABS(x1 - x2) == ABS(y1 - y2)) {
   539         switch (blendMode) {
   540         case SDL_BLENDMODE_BLEND:
   541             DLINE(Uint32, DRAW_SETPIXEL_BLEND_RGB888, draw_end);
   542             break;
   543         case SDL_BLENDMODE_ADD:
   544             DLINE(Uint32, DRAW_SETPIXEL_ADD_RGB888, draw_end);
   545             break;
   546         case SDL_BLENDMODE_MOD:
   547             DLINE(Uint32, DRAW_SETPIXEL_MOD_RGB888, draw_end);
   548             break;
   549         default:
   550             DLINE(Uint32, DRAW_SETPIXEL_RGB888, draw_end);
   551             break;
   552         }
   553     } else {
   554         switch (blendMode) {
   555         case SDL_BLENDMODE_BLEND:
   556             AALINE(x1, y1, x2, y2,
   557                    DRAW_SETPIXELXY_BLEND_RGB888, DRAW_SETPIXELXY_BLEND_RGB888,
   558                    draw_end);
   559             break;
   560         case SDL_BLENDMODE_ADD:
   561             AALINE(x1, y1, x2, y2,
   562                    DRAW_SETPIXELXY_ADD_RGB888, DRAW_SETPIXELXY_ADD_RGB888,
   563                    draw_end);
   564             break;
   565         case SDL_BLENDMODE_MOD:
   566             AALINE(x1, y1, x2, y2,
   567                    DRAW_SETPIXELXY_MOD_RGB888, DRAW_SETPIXELXY_MOD_RGB888,
   568                    draw_end);
   569             break;
   570         default:
   571             AALINE(x1, y1, x2, y2,
   572                    DRAW_SETPIXELXY_RGB888, DRAW_SETPIXELXY_BLEND_RGB888,
   573                    draw_end);
   574             break;
   575         }
   576     }
   577 }
   578 
   579 static void
   580 SDL_BlendLine_ARGB8888(SDL_Surface * dst, int x1, int y1, int x2, int y2,
   581                        SDL_BlendMode blendMode, Uint8 _r, Uint8 _g, Uint8 _b, Uint8 _a,
   582                        SDL_bool draw_end)
   583 {
   584     unsigned r, g, b, a, inva;
   585 
   586     if (blendMode == SDL_BLENDMODE_BLEND || blendMode == SDL_BLENDMODE_ADD) {
   587         r = DRAW_MUL(_r, _a);
   588         g = DRAW_MUL(_g, _a);
   589         b = DRAW_MUL(_b, _a);
   590         a = _a;
   591     } else {
   592         r = _r;
   593         g = _g;
   594         b = _b;
   595         a = _a;
   596     }
   597     inva = (a ^ 0xff);
   598 
   599     if (y1 == y2) {
   600         switch (blendMode) {
   601         case SDL_BLENDMODE_BLEND:
   602             HLINE(Uint32, DRAW_SETPIXEL_BLEND_ARGB8888, draw_end);
   603             break;
   604         case SDL_BLENDMODE_ADD:
   605             HLINE(Uint32, DRAW_SETPIXEL_ADD_ARGB8888, draw_end);
   606             break;
   607         case SDL_BLENDMODE_MOD:
   608             HLINE(Uint32, DRAW_SETPIXEL_MOD_ARGB8888, draw_end);
   609             break;
   610         default:
   611             HLINE(Uint32, DRAW_SETPIXEL_ARGB8888, draw_end);
   612             break;
   613         }
   614     } else if (x1 == x2) {
   615         switch (blendMode) {
   616         case SDL_BLENDMODE_BLEND:
   617             VLINE(Uint32, DRAW_SETPIXEL_BLEND_ARGB8888, draw_end);
   618             break;
   619         case SDL_BLENDMODE_ADD:
   620             VLINE(Uint32, DRAW_SETPIXEL_ADD_ARGB8888, draw_end);
   621             break;
   622         case SDL_BLENDMODE_MOD:
   623             VLINE(Uint32, DRAW_SETPIXEL_MOD_ARGB8888, draw_end);
   624             break;
   625         default:
   626             VLINE(Uint32, DRAW_SETPIXEL_ARGB8888, draw_end);
   627             break;
   628         }
   629     } else if (ABS(x1 - x2) == ABS(y1 - y2)) {
   630         switch (blendMode) {
   631         case SDL_BLENDMODE_BLEND:
   632             DLINE(Uint32, DRAW_SETPIXEL_BLEND_ARGB8888, draw_end);
   633             break;
   634         case SDL_BLENDMODE_ADD:
   635             DLINE(Uint32, DRAW_SETPIXEL_ADD_ARGB8888, draw_end);
   636             break;
   637         case SDL_BLENDMODE_MOD:
   638             DLINE(Uint32, DRAW_SETPIXEL_MOD_ARGB8888, draw_end);
   639             break;
   640         default:
   641             DLINE(Uint32, DRAW_SETPIXEL_ARGB8888, draw_end);
   642             break;
   643         }
   644     } else {
   645         switch (blendMode) {
   646         case SDL_BLENDMODE_BLEND:
   647             AALINE(x1, y1, x2, y2,
   648                    DRAW_SETPIXELXY_BLEND_ARGB8888, DRAW_SETPIXELXY_BLEND_ARGB8888,
   649                    draw_end);
   650             break;
   651         case SDL_BLENDMODE_ADD:
   652             AALINE(x1, y1, x2, y2,
   653                    DRAW_SETPIXELXY_ADD_ARGB8888, DRAW_SETPIXELXY_ADD_ARGB8888,
   654                    draw_end);
   655             break;
   656         case SDL_BLENDMODE_MOD:
   657             AALINE(x1, y1, x2, y2,
   658                    DRAW_SETPIXELXY_MOD_ARGB8888, DRAW_SETPIXELXY_MOD_ARGB8888,
   659                    draw_end);
   660             break;
   661         default:
   662             AALINE(x1, y1, x2, y2,
   663                    DRAW_SETPIXELXY_ARGB8888, DRAW_SETPIXELXY_BLEND_ARGB8888,
   664                    draw_end);
   665             break;
   666         }
   667     }
   668 }
   669 
   670 typedef void (*BlendLineFunc) (SDL_Surface * dst,
   671                                int x1, int y1, int x2, int y2,
   672                                SDL_BlendMode blendMode,
   673                                Uint8 r, Uint8 g, Uint8 b, Uint8 a,
   674                                SDL_bool draw_end);
   675 
   676 static BlendLineFunc
   677 SDL_CalculateBlendLineFunc(const SDL_PixelFormat * fmt)
   678 {
   679     switch (fmt->BytesPerPixel) {
   680     case 2:
   681         if (fmt->Rmask == 0x7C00) {
   682             return SDL_BlendLine_RGB555;
   683         } else if (fmt->Rmask == 0xF800) {
   684             return SDL_BlendLine_RGB565;
   685         } else {
   686             return SDL_BlendLine_RGB2;
   687         }
   688         break;
   689     case 4:
   690         if (fmt->Rmask == 0x00FF0000) {
   691             if (fmt->Amask) {
   692                 return SDL_BlendLine_ARGB8888;
   693             } else {
   694                 return SDL_BlendLine_RGB888;
   695             }
   696         } else {
   697             if (fmt->Amask) {
   698                 return SDL_BlendLine_RGBA4;
   699             } else {
   700                 return SDL_BlendLine_RGB4;
   701             }
   702         }
   703     }
   704     return NULL;
   705 }
   706 
   707 int
   708 SDL_BlendLine(SDL_Surface * dst, int x1, int y1, int x2, int y2,
   709               SDL_BlendMode blendMode, Uint8 r, Uint8 g, Uint8 b, Uint8 a)
   710 {
   711     BlendLineFunc func;
   712 
   713     if (!dst) {
   714         SDL_SetError("SDL_BlendLine(): Passed NULL destination surface");
   715         return -1;
   716     }
   717 
   718     func = SDL_CalculateBlendLineFunc(dst->format);
   719     if (!func) {
   720         SDL_SetError("SDL_BlendLine(): Unsupported surface format");
   721         return -1;
   722     }
   723 
   724     /* Perform clipping */
   725     /* FIXME: We don't actually want to clip, as it may change line slope */
   726     if (!SDL_IntersectRectAndLine(&dst->clip_rect, &x1, &y1, &x2, &y2)) {
   727         return 0;
   728     }
   729 
   730     func(dst, x1, y1, x2, y2, blendMode, r, g, b, a, SDL_TRUE);
   731     return 0;
   732 }
   733 
   734 int
   735 SDL_BlendLines(SDL_Surface * dst, const SDL_Point * points, int count,
   736                SDL_BlendMode blendMode, Uint8 r, Uint8 g, Uint8 b, Uint8 a)
   737 {
   738     int i;
   739     int x1, y1;
   740     int x2, y2;
   741     SDL_bool draw_end;
   742     BlendLineFunc func;
   743 
   744     if (!dst) {
   745         SDL_SetError("SDL_BlendLines(): Passed NULL destination surface");
   746         return -1;
   747     }
   748 
   749     func = SDL_CalculateBlendLineFunc(dst->format);
   750     if (!func) {
   751         SDL_SetError("SDL_BlendLines(): Unsupported surface format");
   752         return -1;
   753     }
   754 
   755     for (i = 1; i < count; ++i) {
   756         x1 = points[i-1].x;
   757         y1 = points[i-1].y;
   758         x2 = points[i].x;
   759         y2 = points[i].y;
   760 
   761         /* Perform clipping */
   762         /* FIXME: We don't actually want to clip, as it may change line slope */
   763         if (!SDL_IntersectRectAndLine(&dst->clip_rect, &x1, &y1, &x2, &y2)) {
   764             continue;
   765         }
   766 
   767         /* Draw the end if it was clipped */
   768         draw_end = (x2 != points[i].x || y2 != points[i].y);
   769 
   770         func(dst, x1, y1, x2, y2, blendMode, r, g, b, a, draw_end);
   771     }
   772     if (points[0].x != points[count-1].x || points[0].y != points[count-1].y) {
   773         SDL_BlendPoint(dst, points[count-1].x, points[count-1].y,
   774                        blendMode, r, g, b, a);
   775     }
   776     return 0;
   777 }
   778 
   779 #endif /* !SDL_RENDER_DISABLED */
   780 
   781 /* vi: set ts=4 sw=4 expandtab: */