src/render/software/SDL_blendline.c
author Sam Lantinga
Thu, 03 Feb 2011 02:45:29 -0800
changeset 5163 d72793305335
parent 5140 src/video/SDL_blendline.c@e743b9c3f6d6
child 5166 4d39eeaad00b
permissions -rw-r--r--
Making the API simpler, moved the surface drawing functions to the software renderer.
     1 /*
     2     SDL - Simple DirectMedia Layer
     3     Copyright (C) 1997-2010 Sam Lantinga
     4 
     5     This library is free software; you can redistribute it and/or
     6     modify it under the terms of the GNU Lesser General Public
     7     License as published by the Free Software Foundation; either
     8     version 2.1 of the License, or (at your option) any later version.
     9 
    10     This library is distributed in the hope that it will be useful,
    11     but WITHOUT ANY WARRANTY; without even the implied warranty of
    12     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    13     Lesser General Public License for more details.
    14 
    15     You should have received a copy of the GNU Lesser General Public
    16     License along with this library; if not, write to the Free Software
    17     Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
    18 
    19     Sam Lantinga
    20     slouken@libsdl.org
    21 */
    22 #include "SDL_config.h"
    23 
    24 #include "SDL_draw.h"
    25 #include "SDL_blendline.h"
    26 
    27 
    28 static void
    29 SDL_BlendLine_RGB2(SDL_Surface * dst, int x1, int y1, int x2, int y2,
    30                    SDL_BlendMode blendMode, Uint8 _r, Uint8 _g, Uint8 _b, Uint8 _a,
    31                    SDL_bool draw_end)
    32 {
    33     const SDL_PixelFormat *fmt = dst->format;
    34     unsigned r, g, b, a, inva;
    35 
    36     if (blendMode == SDL_BLENDMODE_BLEND || blendMode == SDL_BLENDMODE_ADD) {
    37         r = DRAW_MUL(_r, _a);
    38         g = DRAW_MUL(_g, _a);
    39         b = DRAW_MUL(_b, _a);
    40         a = _a;
    41     } else {
    42         r = _r;
    43         g = _g;
    44         b = _b;
    45         a = _a;
    46     }
    47     inva = (a ^ 0xff);
    48 
    49     if (y1 == y2) {
    50         switch (blendMode) {
    51         case SDL_BLENDMODE_BLEND:
    52             HLINE(Uint16, DRAW_SETPIXEL_BLEND_RGB, draw_end);
    53             break;
    54         case SDL_BLENDMODE_ADD:
    55             HLINE(Uint16, DRAW_SETPIXEL_ADD_RGB, draw_end);
    56             break;
    57         default:
    58             HLINE(Uint16, DRAW_SETPIXEL_RGB, draw_end);
    59             break;
    60         }
    61     } else if (x1 == x2) {
    62         switch (blendMode) {
    63         case SDL_BLENDMODE_BLEND:
    64             VLINE(Uint16, DRAW_SETPIXEL_BLEND_RGB, draw_end);
    65             break;
    66         case SDL_BLENDMODE_ADD:
    67             VLINE(Uint16, DRAW_SETPIXEL_ADD_RGB, draw_end);
    68             break;
    69         default:
    70             VLINE(Uint16, DRAW_SETPIXEL_RGB, draw_end);
    71             break;
    72         }
    73     } else if (ABS(x1 - x2) == ABS(y1 - y2)) {
    74         switch (blendMode) {
    75         case SDL_BLENDMODE_BLEND:
    76             DLINE(Uint16, DRAW_SETPIXEL_BLEND_RGB, draw_end);
    77             break;
    78         case SDL_BLENDMODE_ADD:
    79             DLINE(Uint16, DRAW_SETPIXEL_ADD_RGB, draw_end);
    80             break;
    81         default:
    82             DLINE(Uint16, DRAW_SETPIXEL_RGB, draw_end);
    83             break;
    84         }
    85     } else {
    86         switch (blendMode) {
    87         case SDL_BLENDMODE_BLEND:
    88             AALINE(x1, y1, x2, y2,
    89                    DRAW_SETPIXELXY2_BLEND_RGB, DRAW_SETPIXELXY2_BLEND_RGB,
    90                    draw_end);
    91             break;
    92         case SDL_BLENDMODE_ADD:
    93             AALINE(x1, y1, x2, y2,
    94                    DRAW_SETPIXELXY2_ADD_RGB, DRAW_SETPIXELXY2_ADD_RGB,
    95                    draw_end);
    96             break;
    97         default:
    98             AALINE(x1, y1, x2, y2,
    99                    DRAW_SETPIXELXY2_RGB, DRAW_SETPIXELXY2_BLEND_RGB,
   100                    draw_end);
   101             break;
   102         }
   103     }
   104 }
   105 
   106 static void
   107 SDL_BlendLine_RGB555(SDL_Surface * dst, int x1, int y1, int x2, int y2,
   108                      SDL_BlendMode blendMode, Uint8 _r, Uint8 _g, Uint8 _b, Uint8 _a,
   109                      SDL_bool draw_end)
   110 {
   111     const SDL_PixelFormat *fmt = dst->format;
   112     unsigned r, g, b, a, inva;
   113 
   114     if (blendMode == SDL_BLENDMODE_BLEND || blendMode == SDL_BLENDMODE_ADD) {
   115         r = DRAW_MUL(_r, _a);
   116         g = DRAW_MUL(_g, _a);
   117         b = DRAW_MUL(_b, _a);
   118         a = _a;
   119     } else {
   120         r = _r;
   121         g = _g;
   122         b = _b;
   123         a = _a;
   124     }
   125     inva = (a ^ 0xff);
   126 
   127     if (y1 == y2) {
   128         switch (blendMode) {
   129         case SDL_BLENDMODE_BLEND:
   130             HLINE(Uint16, DRAW_SETPIXEL_BLEND_RGB555, draw_end);
   131             break;
   132         case SDL_BLENDMODE_ADD:
   133             HLINE(Uint16, DRAW_SETPIXEL_ADD_RGB555, draw_end);
   134             break;
   135         default:
   136             HLINE(Uint16, DRAW_SETPIXEL_RGB555, draw_end);
   137             break;
   138         }
   139     } else if (x1 == x2) {
   140         switch (blendMode) {
   141         case SDL_BLENDMODE_BLEND:
   142             VLINE(Uint16, DRAW_SETPIXEL_BLEND_RGB555, draw_end);
   143             break;
   144         case SDL_BLENDMODE_ADD:
   145             VLINE(Uint16, DRAW_SETPIXEL_ADD_RGB555, draw_end);
   146             break;
   147         default:
   148             VLINE(Uint16, DRAW_SETPIXEL_RGB555, draw_end);
   149             break;
   150         }
   151     } else if (ABS(x1 - x2) == ABS(y1 - y2)) {
   152         switch (blendMode) {
   153         case SDL_BLENDMODE_BLEND:
   154             DLINE(Uint16, DRAW_SETPIXEL_BLEND_RGB555, draw_end);
   155             break;
   156         case SDL_BLENDMODE_ADD:
   157             DLINE(Uint16, DRAW_SETPIXEL_ADD_RGB555, draw_end);
   158             break;
   159         default:
   160             DLINE(Uint16, DRAW_SETPIXEL_RGB555, draw_end);
   161             break;
   162         }
   163     } else {
   164         switch (blendMode) {
   165         case SDL_BLENDMODE_BLEND:
   166             AALINE(x1, y1, x2, y2,
   167                    DRAW_SETPIXELXY_BLEND_RGB555, DRAW_SETPIXELXY_BLEND_RGB555,
   168                    draw_end);
   169             break;
   170         case SDL_BLENDMODE_ADD:
   171             AALINE(x1, y1, x2, y2,
   172                    DRAW_SETPIXELXY_ADD_RGB555, DRAW_SETPIXELXY_ADD_RGB555,
   173                    draw_end);
   174             break;
   175         default:
   176             AALINE(x1, y1, x2, y2,
   177                    DRAW_SETPIXELXY_RGB555, DRAW_SETPIXELXY_BLEND_RGB555,
   178                    draw_end);
   179             break;
   180         }
   181     }
   182 }
   183 
   184 static void
   185 SDL_BlendLine_RGB565(SDL_Surface * dst, int x1, int y1, int x2, int y2,
   186                      SDL_BlendMode blendMode, Uint8 _r, Uint8 _g, Uint8 _b, Uint8 _a,
   187                      SDL_bool draw_end)
   188 {
   189     const SDL_PixelFormat *fmt = dst->format;
   190     unsigned r, g, b, a, inva;
   191 
   192     if (blendMode == SDL_BLENDMODE_BLEND || blendMode == SDL_BLENDMODE_ADD) {
   193         r = DRAW_MUL(_r, _a);
   194         g = DRAW_MUL(_g, _a);
   195         b = DRAW_MUL(_b, _a);
   196         a = _a;
   197     } else {
   198         r = _r;
   199         g = _g;
   200         b = _b;
   201         a = _a;
   202     }
   203     inva = (a ^ 0xff);
   204 
   205     if (y1 == y2) {
   206         switch (blendMode) {
   207         case SDL_BLENDMODE_BLEND:
   208             HLINE(Uint16, DRAW_SETPIXEL_BLEND_RGB565, draw_end);
   209             break;
   210         case SDL_BLENDMODE_ADD:
   211             HLINE(Uint16, DRAW_SETPIXEL_ADD_RGB565, draw_end);
   212             break;
   213         default:
   214             HLINE(Uint16, DRAW_SETPIXEL_RGB565, draw_end);
   215             break;
   216         }
   217     } else if (x1 == x2) {
   218         switch (blendMode) {
   219         case SDL_BLENDMODE_BLEND:
   220             VLINE(Uint16, DRAW_SETPIXEL_BLEND_RGB565, draw_end);
   221             break;
   222         case SDL_BLENDMODE_ADD:
   223             VLINE(Uint16, DRAW_SETPIXEL_ADD_RGB565, draw_end);
   224             break;
   225         default:
   226             VLINE(Uint16, DRAW_SETPIXEL_RGB565, draw_end);
   227             break;
   228         }
   229     } else if (ABS(x1 - x2) == ABS(y1 - y2)) {
   230         switch (blendMode) {
   231         case SDL_BLENDMODE_BLEND:
   232             DLINE(Uint16, DRAW_SETPIXEL_BLEND_RGB565, draw_end);
   233             break;
   234         case SDL_BLENDMODE_ADD:
   235             DLINE(Uint16, DRAW_SETPIXEL_ADD_RGB565, draw_end);
   236             break;
   237         default:
   238             DLINE(Uint16, DRAW_SETPIXEL_RGB565, draw_end);
   239             break;
   240         }
   241     } else {
   242         switch (blendMode) {
   243         case SDL_BLENDMODE_BLEND:
   244             AALINE(x1, y1, x2, y2,
   245                    DRAW_SETPIXELXY_BLEND_RGB565, DRAW_SETPIXELXY_BLEND_RGB565,
   246                    draw_end);
   247             break;
   248         case SDL_BLENDMODE_ADD:
   249             AALINE(x1, y1, x2, y2,
   250                    DRAW_SETPIXELXY_ADD_RGB565, DRAW_SETPIXELXY_ADD_RGB565,
   251                    draw_end);
   252             break;
   253         default:
   254             AALINE(x1, y1, x2, y2,
   255                    DRAW_SETPIXELXY_RGB565, DRAW_SETPIXELXY_BLEND_RGB565,
   256                    draw_end);
   257             break;
   258         }
   259     }
   260 }
   261 
   262 static void
   263 SDL_BlendLine_RGB4(SDL_Surface * dst, int x1, int y1, int x2, int y2,
   264                    SDL_BlendMode blendMode, Uint8 _r, Uint8 _g, Uint8 _b, Uint8 _a,
   265                    SDL_bool draw_end)
   266 {
   267     const SDL_PixelFormat *fmt = dst->format;
   268     unsigned r, g, b, a, inva;
   269 
   270     if (blendMode == SDL_BLENDMODE_BLEND || blendMode == SDL_BLENDMODE_ADD) {
   271         r = DRAW_MUL(_r, _a);
   272         g = DRAW_MUL(_g, _a);
   273         b = DRAW_MUL(_b, _a);
   274         a = _a;
   275     } else {
   276         r = _r;
   277         g = _g;
   278         b = _b;
   279         a = _a;
   280     }
   281     inva = (a ^ 0xff);
   282 
   283     if (y1 == y2) {
   284         switch (blendMode) {
   285         case SDL_BLENDMODE_BLEND:
   286             HLINE(Uint32, DRAW_SETPIXEL_BLEND_RGB, draw_end);
   287             break;
   288         case SDL_BLENDMODE_ADD:
   289             HLINE(Uint32, DRAW_SETPIXEL_ADD_RGB, draw_end);
   290             break;
   291         default:
   292             HLINE(Uint32, DRAW_SETPIXEL_RGB, draw_end);
   293             break;
   294         }
   295     } else if (x1 == x2) {
   296         switch (blendMode) {
   297         case SDL_BLENDMODE_BLEND:
   298             VLINE(Uint32, DRAW_SETPIXEL_BLEND_RGB, draw_end);
   299             break;
   300         case SDL_BLENDMODE_ADD:
   301             VLINE(Uint32, DRAW_SETPIXEL_ADD_RGB, draw_end);
   302             break;
   303         default:
   304             VLINE(Uint32, DRAW_SETPIXEL_RGB, draw_end);
   305             break;
   306         }
   307     } else if (ABS(x1 - x2) == ABS(y1 - y2)) {
   308         switch (blendMode) {
   309         case SDL_BLENDMODE_BLEND:
   310             DLINE(Uint32, DRAW_SETPIXEL_BLEND_RGB, draw_end);
   311             break;
   312         case SDL_BLENDMODE_ADD:
   313             DLINE(Uint32, DRAW_SETPIXEL_ADD_RGB, draw_end);
   314             break;
   315         default:
   316             DLINE(Uint32, DRAW_SETPIXEL_RGB, draw_end);
   317             break;
   318         }
   319     } else {
   320         switch (blendMode) {
   321         case SDL_BLENDMODE_BLEND:
   322             AALINE(x1, y1, x2, y2,
   323                    DRAW_SETPIXELXY4_BLEND_RGB, DRAW_SETPIXELXY4_BLEND_RGB,
   324                    draw_end);
   325             break;
   326         case SDL_BLENDMODE_ADD:
   327             AALINE(x1, y1, x2, y2,
   328                    DRAW_SETPIXELXY4_ADD_RGB, DRAW_SETPIXELXY4_ADD_RGB,
   329                    draw_end);
   330             break;
   331         default:
   332             AALINE(x1, y1, x2, y2,
   333                    DRAW_SETPIXELXY4_RGB, DRAW_SETPIXELXY4_BLEND_RGB,
   334                    draw_end);
   335             break;
   336         }
   337     }
   338 }
   339 
   340 static void
   341 SDL_BlendLine_RGBA4(SDL_Surface * dst, int x1, int y1, int x2, int y2,
   342                     SDL_BlendMode blendMode, Uint8 _r, Uint8 _g, Uint8 _b, Uint8 _a,
   343                     SDL_bool draw_end)
   344 {
   345     const SDL_PixelFormat *fmt = dst->format;
   346     unsigned r, g, b, a, inva;
   347 
   348     if (blendMode == SDL_BLENDMODE_BLEND || blendMode == SDL_BLENDMODE_ADD) {
   349         r = DRAW_MUL(_r, _a);
   350         g = DRAW_MUL(_g, _a);
   351         b = DRAW_MUL(_b, _a);
   352         a = _a;
   353     } else {
   354         r = _r;
   355         g = _g;
   356         b = _b;
   357         a = _a;
   358     }
   359     inva = (a ^ 0xff);
   360 
   361     if (y1 == y2) {
   362         switch (blendMode) {
   363         case SDL_BLENDMODE_BLEND:
   364             HLINE(Uint32, DRAW_SETPIXEL_BLEND_RGBA, draw_end);
   365             break;
   366         case SDL_BLENDMODE_ADD:
   367             HLINE(Uint32, DRAW_SETPIXEL_ADD_RGBA, draw_end);
   368             break;
   369         default:
   370             HLINE(Uint32, DRAW_SETPIXEL_RGBA, draw_end);
   371             break;
   372         }
   373     } else if (x1 == x2) {
   374         switch (blendMode) {
   375         case SDL_BLENDMODE_BLEND:
   376             VLINE(Uint32, DRAW_SETPIXEL_BLEND_RGBA, draw_end);
   377             break;
   378         case SDL_BLENDMODE_ADD:
   379             VLINE(Uint32, DRAW_SETPIXEL_ADD_RGBA, draw_end);
   380             break;
   381         default:
   382             VLINE(Uint32, DRAW_SETPIXEL_RGBA, draw_end);
   383             break;
   384         }
   385     } else if (ABS(x1 - x2) == ABS(y1 - y2)) {
   386         switch (blendMode) {
   387         case SDL_BLENDMODE_BLEND:
   388             DLINE(Uint32, DRAW_SETPIXEL_BLEND_RGBA, draw_end);
   389             break;
   390         case SDL_BLENDMODE_ADD:
   391             DLINE(Uint32, DRAW_SETPIXEL_ADD_RGBA, draw_end);
   392             break;
   393         default:
   394             DLINE(Uint32, DRAW_SETPIXEL_RGBA, draw_end);
   395             break;
   396         }
   397     } else {
   398         switch (blendMode) {
   399         case SDL_BLENDMODE_BLEND:
   400             AALINE(x1, y1, x2, y2,
   401                    DRAW_SETPIXELXY4_BLEND_RGBA, DRAW_SETPIXELXY4_BLEND_RGBA,
   402                    draw_end);
   403             break;
   404         case SDL_BLENDMODE_ADD:
   405             AALINE(x1, y1, x2, y2,
   406                    DRAW_SETPIXELXY4_ADD_RGBA, DRAW_SETPIXELXY4_ADD_RGBA,
   407                    draw_end);
   408             break;
   409         default:
   410             AALINE(x1, y1, x2, y2,
   411                    DRAW_SETPIXELXY4_RGBA, DRAW_SETPIXELXY4_BLEND_RGBA,
   412                    draw_end);
   413             break;
   414         }
   415     }
   416 }
   417 
   418 static void
   419 SDL_BlendLine_RGB888(SDL_Surface * dst, int x1, int y1, int x2, int y2,
   420                      SDL_BlendMode blendMode, Uint8 _r, Uint8 _g, Uint8 _b, Uint8 _a,
   421                      SDL_bool draw_end)
   422 {
   423     const SDL_PixelFormat *fmt = dst->format;
   424     unsigned r, g, b, a, inva;
   425 
   426     if (blendMode == SDL_BLENDMODE_BLEND || blendMode == SDL_BLENDMODE_ADD) {
   427         r = DRAW_MUL(_r, _a);
   428         g = DRAW_MUL(_g, _a);
   429         b = DRAW_MUL(_b, _a);
   430         a = _a;
   431     } else {
   432         r = _r;
   433         g = _g;
   434         b = _b;
   435         a = _a;
   436     }
   437     inva = (a ^ 0xff);
   438 
   439     if (y1 == y2) {
   440         switch (blendMode) {
   441         case SDL_BLENDMODE_BLEND:
   442             HLINE(Uint32, DRAW_SETPIXEL_BLEND_RGB888, draw_end);
   443             break;
   444         case SDL_BLENDMODE_ADD:
   445             HLINE(Uint32, DRAW_SETPIXEL_ADD_RGB888, draw_end);
   446             break;
   447         default:
   448             HLINE(Uint32, DRAW_SETPIXEL_RGB888, draw_end);
   449             break;
   450         }
   451     } else if (x1 == x2) {
   452         switch (blendMode) {
   453         case SDL_BLENDMODE_BLEND:
   454             VLINE(Uint32, DRAW_SETPIXEL_BLEND_RGB888, draw_end);
   455             break;
   456         case SDL_BLENDMODE_ADD:
   457             VLINE(Uint32, DRAW_SETPIXEL_ADD_RGB888, draw_end);
   458             break;
   459         default:
   460             VLINE(Uint32, DRAW_SETPIXEL_RGB888, draw_end);
   461             break;
   462         }
   463     } else if (ABS(x1 - x2) == ABS(y1 - y2)) {
   464         switch (blendMode) {
   465         case SDL_BLENDMODE_BLEND:
   466             DLINE(Uint32, DRAW_SETPIXEL_BLEND_RGB888, draw_end);
   467             break;
   468         case SDL_BLENDMODE_ADD:
   469             DLINE(Uint32, DRAW_SETPIXEL_ADD_RGB888, draw_end);
   470             break;
   471         default:
   472             DLINE(Uint32, DRAW_SETPIXEL_RGB888, draw_end);
   473             break;
   474         }
   475     } else {
   476         switch (blendMode) {
   477         case SDL_BLENDMODE_BLEND:
   478             AALINE(x1, y1, x2, y2,
   479                    DRAW_SETPIXELXY_BLEND_RGB888, DRAW_SETPIXELXY_BLEND_RGB888,
   480                    draw_end);
   481             break;
   482         case SDL_BLENDMODE_ADD:
   483             AALINE(x1, y1, x2, y2,
   484                    DRAW_SETPIXELXY_ADD_RGB888, DRAW_SETPIXELXY_ADD_RGB888,
   485                    draw_end);
   486             break;
   487         default:
   488             AALINE(x1, y1, x2, y2,
   489                    DRAW_SETPIXELXY_RGB888, DRAW_SETPIXELXY_BLEND_RGB888,
   490                    draw_end);
   491             break;
   492         }
   493     }
   494 }
   495 
   496 static void
   497 SDL_BlendLine_ARGB8888(SDL_Surface * dst, int x1, int y1, int x2, int y2,
   498                        SDL_BlendMode blendMode, Uint8 _r, Uint8 _g, Uint8 _b, Uint8 _a,
   499                        SDL_bool draw_end)
   500 {
   501     const SDL_PixelFormat *fmt = dst->format;
   502     unsigned r, g, b, a, inva;
   503 
   504     if (blendMode == SDL_BLENDMODE_BLEND || blendMode == SDL_BLENDMODE_ADD) {
   505         r = DRAW_MUL(_r, _a);
   506         g = DRAW_MUL(_g, _a);
   507         b = DRAW_MUL(_b, _a);
   508         a = _a;
   509     } else {
   510         r = _r;
   511         g = _g;
   512         b = _b;
   513         a = _a;
   514     }
   515     inva = (a ^ 0xff);
   516 
   517     if (y1 == y2) {
   518         switch (blendMode) {
   519         case SDL_BLENDMODE_BLEND:
   520             HLINE(Uint32, DRAW_SETPIXEL_BLEND_ARGB8888, draw_end);
   521             break;
   522         case SDL_BLENDMODE_ADD:
   523             HLINE(Uint32, DRAW_SETPIXEL_ADD_ARGB8888, draw_end);
   524             break;
   525         default:
   526             HLINE(Uint32, DRAW_SETPIXEL_ARGB8888, draw_end);
   527             break;
   528         }
   529     } else if (x1 == x2) {
   530         switch (blendMode) {
   531         case SDL_BLENDMODE_BLEND:
   532             VLINE(Uint32, DRAW_SETPIXEL_BLEND_ARGB8888, draw_end);
   533             break;
   534         case SDL_BLENDMODE_ADD:
   535             VLINE(Uint32, DRAW_SETPIXEL_ADD_ARGB8888, draw_end);
   536             break;
   537         default:
   538             VLINE(Uint32, DRAW_SETPIXEL_ARGB8888, draw_end);
   539             break;
   540         }
   541     } else if (ABS(x1 - x2) == ABS(y1 - y2)) {
   542         switch (blendMode) {
   543         case SDL_BLENDMODE_BLEND:
   544             DLINE(Uint32, DRAW_SETPIXEL_BLEND_ARGB8888, draw_end);
   545             break;
   546         case SDL_BLENDMODE_ADD:
   547             DLINE(Uint32, DRAW_SETPIXEL_ADD_ARGB8888, draw_end);
   548             break;
   549         default:
   550             DLINE(Uint32, DRAW_SETPIXEL_ARGB8888, 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_ARGB8888, DRAW_SETPIXELXY_BLEND_ARGB8888,
   558                    draw_end);
   559             break;
   560         case SDL_BLENDMODE_ADD:
   561             AALINE(x1, y1, x2, y2,
   562                    DRAW_SETPIXELXY_ADD_ARGB8888, DRAW_SETPIXELXY_ADD_ARGB8888,
   563                    draw_end);
   564             break;
   565         default:
   566             AALINE(x1, y1, x2, y2,
   567                    DRAW_SETPIXELXY_ARGB8888, DRAW_SETPIXELXY_BLEND_ARGB8888,
   568                    draw_end);
   569             break;
   570         }
   571     }
   572 }
   573 
   574 typedef void (*BlendLineFunc) (SDL_Surface * dst,
   575                                int x1, int y1, int x2, int y2,
   576                                SDL_BlendMode blendMode,
   577                                Uint8 r, Uint8 g, Uint8 b, Uint8 a,
   578                                SDL_bool draw_end);
   579 
   580 static BlendLineFunc
   581 SDL_CalculateBlendLineFunc(const SDL_PixelFormat * fmt)
   582 {
   583     switch (fmt->BytesPerPixel) {
   584     case 2:
   585         if (fmt->Rmask == 0x7C00) {
   586             return SDL_BlendLine_RGB555;
   587         } else if (fmt->Rmask == 0xF800) {
   588             return SDL_BlendLine_RGB565;
   589         } else {
   590             return SDL_BlendLine_RGB2;
   591         }
   592         break;
   593     case 4:
   594         if (fmt->Rmask == 0x00FF0000) {
   595             if (fmt->Amask) {
   596                 return SDL_BlendLine_ARGB8888;
   597             } else {
   598                 return SDL_BlendLine_RGB888;
   599             }
   600         } else {
   601             if (fmt->Amask) {
   602                 return SDL_BlendLine_RGBA4;
   603             } else {
   604                 return SDL_BlendLine_RGB4;
   605             }
   606         }
   607     }
   608     return NULL;
   609 }
   610 
   611 int
   612 SDL_BlendLine(SDL_Surface * dst, int x1, int y1, int x2, int y2,
   613               SDL_BlendMode blendMode, Uint8 r, Uint8 g, Uint8 b, Uint8 a)
   614 {
   615     BlendLineFunc func;
   616 
   617     if (!dst) {
   618         SDL_SetError("SDL_BlendLine(): Passed NULL destination surface");
   619         return -1;
   620     }
   621 
   622     func = SDL_CalculateBlendLineFunc(dst->format);
   623     if (!func) {
   624         SDL_SetError("SDL_BlendLine(): Unsupported surface format");
   625         return -1;
   626     }
   627 
   628     /* Perform clipping */
   629     /* FIXME: We don't actually want to clip, as it may change line slope */
   630     if (!SDL_IntersectRectAndLine(&dst->clip_rect, &x1, &y1, &x2, &y2)) {
   631         return 0;
   632     }
   633 
   634     func(dst, x1, y1, x2, y2, blendMode, r, g, b, a, SDL_TRUE);
   635     return 0;
   636 }
   637 
   638 int
   639 SDL_BlendLines(SDL_Surface * dst, const SDL_Point * points, int count,
   640                SDL_BlendMode blendMode, Uint8 r, Uint8 g, Uint8 b, Uint8 a)
   641 {
   642     int i;
   643     int x1, y1;
   644     int x2, y2;
   645     SDL_bool draw_end;
   646     BlendLineFunc func;
   647 
   648     if (!dst) {
   649         SDL_SetError("SDL_BlendLines(): Passed NULL destination surface");
   650         return -1;
   651     }
   652 
   653     func = SDL_CalculateBlendLineFunc(dst->format);
   654     if (!func) {
   655         SDL_SetError("SDL_BlendLines(): Unsupported surface format");
   656         return -1;
   657     }
   658 
   659     for (i = 1; i < count; ++i) {
   660         x1 = points[i-1].x;
   661         y1 = points[i-1].y;
   662         x2 = points[i].x;
   663         y2 = points[i].y;
   664 
   665         /* Perform clipping */
   666         /* FIXME: We don't actually want to clip, as it may change line slope */
   667         if (!SDL_IntersectRectAndLine(&dst->clip_rect, &x1, &y1, &x2, &y2)) {
   668             continue;
   669         }
   670 
   671         /* Draw the end if it was clipped */
   672         draw_end = (x2 != points[i].x || y2 != points[i].y);
   673 
   674         func(dst, x1, y1, x2, y2, blendMode, r, g, b, a, draw_end);
   675     }
   676     if (points[0].x != points[count-1].x || points[0].y != points[count-1].y) {
   677         SDL_BlendPoint(dst, points[count-1].x, points[count-1].y,
   678                        blendMode, r, g, b, a);
   679     }
   680     return 0;
   681 }
   682 
   683 /* vi: set ts=4 sw=4 expandtab: */