Logo Search packages:      
Sourcecode: zatacka version File versions  Download package

SDL_prim.c

/*
 * SDL_prim.c
 *
 * Copyright (C) 2003-2005 Ryan McGuigan <ryan@tempestgames.com>
 *
 * See the included 'COPYING' file for license information.
 *
 * Simple SDL Primitive C functions.  My goal while writing this
 * was to keep everything as simple as possible, both in the design
 * of these functions and in the usage of these functions.
 *
 * I hope someone finds this useful.
 *
 * Adapted to compile without warning on g++ -W -Wall -O2 by tdd@insia.org
 * (20050413)
 *
 */


#include "SDL_prim.h"


/*
 * simple pixel drawing function.
 *
 * tests to be sure pixel is within bounds of the surface, so you
 * can draw off the surface to your hearts content
 *
 * it's probably not good practice to be drawing off the surface though...
 *
 */
inline
void SDL_putPixel(SDL_Surface *surf, int x, int y, Uint32 clr)
{
      int Bpp = surf->format->BytesPerPixel;
      Uint8 *p;

      if (! (x < 0 || x >= surf->w || y < 0 || y >= surf->h) )
      {
            p = (Uint8*)surf->pixels + y * surf->pitch + x * Bpp;

            switch(Bpp) {
            case 1:
                  *p = clr;
                  break;

            case 2:
                  *(Uint16*)p = clr;
                  break;

            case 3:
                  if (SDL_BYTEORDER == SDL_BIG_ENDIAN) {
                        p[0] = (clr >> 16) & 0xff;
                        p[1] = (clr >> 8) & 0xff;
                        p[2] = clr & 0xff;
                  } else {
                        p[0] = clr & 0xff;
                        p[1] = (clr >> 8) & 0xff;
                        p[2] = (clr >> 16) & 0xff;
                  }
                  break;

            case 4:
                  *(Uint32*)p = clr;
                  break;
            }
      }
}


/*
 * returns pointer to pixel at x, y
 */
inline
Uint8* SDL_getPixel(SDL_Surface *surf, int x, int y)
{
      if (! (x < 0 || x >= surf->w || y < 0 || y >= surf->h) )
            return (Uint8*)surf->pixels + y * surf->pitch + x * surf->format->BytesPerPixel;
      else
            return 0;
}


/*
 * slow pixel blending function
 *
 * called from SDL_blendPixel for 8 bit surfaces.
 * may be useful for something else, I dunno.
 *
 */
inline
void __slow_SDL_blendPixel( SDL_Surface *surf, int x, int y, Uint32 clr,
                            Uint8 alpha)
{
      Uint8 *p;
      Uint8 r, g, b, r2, g2, b2;

      if ( (p = SDL_getPixel(surf, x, y)) ) {
            SDL_GetRGB(clr, surf->format, &r, &g, &b);
            SDL_GetRGB(*p, surf->format, &r2, &g2, &b2);

            /* The 3 following lines use explicit cast now - tdd */
            r = r2 + (int) (( r - r2 ) * ( alpha / 255.0 ));
            g = g2 + (int) (( g - g2 ) * ( alpha / 255.0 ));
            b = b2 + (int) (( b - b2 ) * ( alpha / 255.0 ));

            clr = SDL_MapRGB(surf->format, r, g, b);

            SDL_putPixel(surf, x, y, clr);
      }
}


/*
 * blends pixel onto surface according to alpha
 */
inline
void SDL_blendPixel( SDL_Surface *surf, int x, int y, Uint32 clr,
                     Uint8 alpha)
{
      Uint8 *p;
      Uint32 R, G, B;

      if ( (p = SDL_getPixel(surf, x, y)) ) {
            switch(surf->format->BytesPerPixel) {
            case 1:  /* 8 bpp */
                  __slow_SDL_blendPixel(surf, x, y, clr, alpha);
                  break;

            case 2:  /* 16 bpp */
                  R = ( (*(Uint16*)p & surf->format->Rmask) + ( ((clr & surf->format->Rmask) - ((*(Uint16*)p) & surf->format->Rmask)) * alpha >> 8) ) & surf->format->Rmask;
                  G = ( (*(Uint16*)p & surf->format->Gmask) + ( ((clr & surf->format->Gmask) - ((*(Uint16*)p) & surf->format->Gmask)) * alpha >> 8) ) & surf->format->Gmask;
                  B = ( (*(Uint16*)p & surf->format->Bmask) + ( ((clr & surf->format->Bmask) - ((*(Uint16*)p) & surf->format->Bmask)) * alpha >> 8) ) & surf->format->Bmask;
                  *(Uint16*)p = R | G | B;
                  break;

            case 3:  /* 24 bpp */
                  if (SDL_BYTEORDER == SDL_BIG_ENDIAN) {
                        p[0] = ( p[0] + ((((clr >> 16) & 0xff) - p[0]) * alpha >> 8) ) & 0xff;
                        p[1] = ( p[1] + ((((clr >> 8) & 0xff) - p[1]) * alpha >> 8) ) & 0xff;
                        p[2] = ( p[2] + (((clr & 0xff) - p[2]) * alpha >> 8) ) & 0xff;
                  } else {
                        p[0] = ( p[0] + (((clr & 0xff) - p[0]) * alpha >> 8) ) & 0xff;
                        p[1] = ( p[1] + ((((clr >> 8) & 0xff) - p[1]) * alpha >> 8) ) & 0xff;
                        p[2] = ( p[2] + ((((clr >> 16) & 0xff) - p[2]) * alpha >> 8) ) & 0xff;
                  }
                  break;

            case 4:  /* 32 bpp */
                  R = ( (*(Uint32*)p & surf->format->Rmask) + ( ((clr & surf->format->Rmask) - (*(Uint32*)p & surf->format->Rmask)) * alpha >> 8) ) & surf->format->Rmask;
                  G = ( (*(Uint32*)p & surf->format->Gmask) + ( ((clr & surf->format->Gmask) - (*(Uint32*)p & surf->format->Gmask)) * alpha >> 8) ) & surf->format->Gmask;
                  B = ( (*(Uint32*)p & surf->format->Bmask) + ( ((clr & surf->format->Bmask) - (*(Uint32*)p & surf->format->Bmask)) * alpha >> 8) ) & surf->format->Bmask;
                  *(Uint32*)p = R | G | B;
                  break;
            }
      }
}


/*
 * Self explanatory.  draws lines, supports anti-aliasing and
 * alpha blending
 *
 */
void SDL_drawLine_TG( SDL_Surface *surf, int x, int y, int x2, int y2,
                      Uint32 clr, Uint8 alpha, Uint8 flags )
{
      int xaa, yaa, *a, *b, *a2, *b2, da, xd, yd;
      float aa, db;
      float realb;

      /*
       * for the sake of my sanity when i look at this again...
       *
       * xaa:   the x aa offset value, either 1 or 0
       * yaa:   the y aa offset value, either 1 or 0
       * *a:    reference to either x or y, depending on which way we are
       *        drawing.
       * *b:    reference to either x or y, depending on which way we are
       *        drawing.
       * *a2:   reference to either x2 or y2, depending on which way we are
       *        drawing.
       * *b2:   reference to either x2 or y2, depending on which way we are
       *        drawing.
       * x:     starting x value, current x value
       * y:     starting y value, current y value
       * x2:    ending x value
       * y2:    ending y value
       * xd:    distance from x to x2
       * yd:    distance from y to y2
       * da:    change in a for each iteration, either 1 or -1
       * db:    change in b with respect to a
       * realb: real b value, as b is an int, and db is going to be a
       *        fraction
       * aa:    anti-aliasing value, fraction part of realb
       *
       */

      /* find x and y distances */
      xd = x2 - x;
      yd = y2 - y;

      if (abs(xd) >= abs(yd)) {
      /* draw left/right to left/right */
            xaa = 0;
            yaa = 1;
            a = &x;
            b = &y;
            a2 = &x2;
            b2 = &y2;
            db = (float)yd / xd;
      } else {
      /* draw top/bottom to top/bottom */
            xaa = 1;
            yaa = 0;
            a = &y;
            b = &x;
            a2 = &y2;
            b2 = &x2;
            db = (float)xd / yd;
      }

      if (!(alpha < 255 && (flags & SDL_TG_ALPHA)))
            alpha = 255;

      /* left or right? */
      da = (*a <= *a2) ? 1 : -1;
      /* up or down? */
      db *= da;
      /* init realb */
      realb = (float)*b;
      /* we're stopping when we hit *a2, so we have to add +/-1 to it */
      *a2 += da;

      if (flags & SDL_TG_LOCK)
            __SDL_PRIM_LOCKSURFACE(surf)

      for (; *a != *a2; *a += da) {
            /* Explicit cast now - tdd */
            *b = (int) floor(realb + 0.5);

            if (flags & SDL_TG_ANTIALIAS) {
                  aa = (realb + 0.5 - *b) * alpha;
                  SDL_blendPixel(surf, x + xaa, y + yaa, clr, (int)aa);
                  SDL_blendPixel(surf, x - xaa, y - yaa, clr, alpha - (int)aa);
            }

            if (alpha < 255)
                  SDL_blendPixel(surf, x, y, clr, alpha);
            else
                  SDL_putPixel(surf, x, y, clr);

            realb += db;
      }

      if (flags & SDL_TG_LOCK)
            __SDL_PRIM_UNLOCKSURFACE(surf)
}



/*
 * Circle drawing/filling function.  Uses a more optimized algorithm
 * when drawing non-anti-aliased circles, uses a mathematically correct algo
 * when drawing anti-aliased circles.  After much trial and error, I have
 * removed 100% of pixel overlapping, no more spots in anti-aliased circles.
 *
 */
void SDL_drawCircle_TG( SDL_Surface *surf, int x1, int y1, int r, Uint32 clr,
                        Uint8 alpha, Uint8 flags )
{
      int x = 0, tmp, dy = 0, y = r, r2, aa = 0, fy = 0;
      int r2p = r * r;
      float aatmp;

#     define __CIRCLE_OUTAA \
      { \
            if (x) { \
                  SDL_blendPixel(surf, x1 + x, y1 + y + 1, clr, aa); \
                  SDL_blendPixel(surf, x1 + x, y1 - y - 1, clr, aa); \
            } \
            SDL_blendPixel(surf, x1 - x, y1 + y + 1, clr, aa); \
            SDL_blendPixel(surf, x1 - x, y1 - y - 1, clr, aa); \
      }

#     define __CIRCLE_INAA \
      { \
            if (x) { \
                  SDL_blendPixel(surf, x1 + x, y1 + y - 1, clr, alpha - aa); \
                  SDL_blendPixel(surf, x1 + x, y1 - y + 1, clr, alpha - aa); \
            } \
            SDL_blendPixel(surf, x1 - x, y1 + y - 1, clr, alpha - aa); \
            SDL_blendPixel(surf, x1 - x, y1 - y + 1, clr, alpha - aa); \
      }

#     define __CIRCLE_OUTAA_ROT90 \
      { \
            if (x) { \
                  SDL_blendPixel(surf, x1 + y + 1, y1 + x, clr, aa); \
                  SDL_blendPixel(surf, x1 - y - 1, y1 - x, clr, aa); \
            } \
            SDL_blendPixel(surf, x1 - y - 1, y1 + x, clr, aa); \
            SDL_blendPixel(surf, x1 + y + 1, y1 - x, clr, aa); \
      }

#     define __CIRCLE_INAA_ROT90 \
      { \
            if (x) { \
                  SDL_blendPixel(surf, x1 + y - 1, y1 + x, clr, alpha - aa); \
                  SDL_blendPixel(surf, x1 - y + 1, y1 - x, clr, alpha - aa); \
            } \
            SDL_blendPixel(surf, x1 - y + 1, y1 + x, clr, alpha - aa); \
            SDL_blendPixel(surf, x1 + y - 1, y1 - x, clr, alpha - aa); \
      }

#     define __CIRCLE_BLEND \
      { \
            if (x) { \
                  SDL_blendPixel(surf, x1 + x, y1 + y, clr, alpha); \
                  SDL_blendPixel(surf, x1 + x, y1 - y, clr, alpha); \
            } \
            SDL_blendPixel(surf, x1 - x, y1 + y, clr, alpha); \
            SDL_blendPixel(surf, x1 - x, y1 - y, clr, alpha); \
      }

#     define __CIRCLE_BLEND_ROT90 \
      { \
            if (x) { \
                  SDL_blendPixel(surf, x1 - y, y1 + x, clr, alpha); \
                  SDL_blendPixel(surf, x1 + y, y1 + x, clr, alpha); \
            } \
            SDL_blendPixel(surf, x1 + y, y1 - x, clr, alpha); \
            SDL_blendPixel(surf, x1 - y, y1 - x, clr, alpha); \
      }

#     define __CIRCLE_DRAW \
      { \
            if (x) { \
                  SDL_putPixel(surf, x1 + x, y1 + y, clr); \
                  SDL_putPixel(surf, x1 + x, y1 - y, clr); \
            } \
            SDL_putPixel(surf, x1 - x, y1 + y, clr); \
            SDL_putPixel(surf, x1 - x, y1 - y, clr); \
      }

#     define __CIRCLE_DRAW_ROT90 \
      { \
            if (x) { \
                  SDL_putPixel(surf, x1 - y, y1 + x, clr); \
                  SDL_putPixel(surf, x1 + y, y1 + x, clr); \
            } \
            SDL_putPixel(surf, x1 + y, y1 - x, clr); \
            SDL_putPixel(surf, x1 - y, y1 - x, clr); \
      }

      if (!(alpha < 255 && (flags & SDL_TG_ALPHA)))
            alpha = 255;

      if (r < 6)
            r2 = 0;
      else
            r2 = r / 2;

      if (flags & SDL_TG_LOCK)
            __SDL_PRIM_LOCKSURFACE(surf)

      if (flags & SDL_TG_FILL) {
            if (alpha < 255)
                  SDL_blendPixel(surf, x1, y1, clr, alpha);
            else
                  SDL_putPixel(surf, x1, y1, clr);
      }

      do {
            if (alpha < 255) {
                  __CIRCLE_BLEND
                  __CIRCLE_BLEND_ROT90
            } else {
                  __CIRCLE_DRAW
                  __CIRCLE_DRAW_ROT90
            }

            if (flags & SDL_TG_FILL) {
                  /* Fill the circle... */
                  if (alpha < 255) {
                        for (fy = y - 1; fy >= (x ? x : 1); fy--) {
                              if (x) {
                                    SDL_blendPixel(surf, x1 - x, y1 + fy, clr, alpha);
                                    SDL_blendPixel(surf, x1 - x, y1 - fy, clr, alpha);
                              }
                              SDL_blendPixel(surf, x1 + x, y1 + fy, clr, alpha);
                              SDL_blendPixel(surf, x1 + x, y1 - fy, clr, alpha);

                              if (fy > x) {
                                    if (x) {
                                          SDL_blendPixel(surf, x1 - fy, y1 + x, clr, alpha);
                                          SDL_blendPixel(surf, x1 + fy, y1 + x, clr, alpha);
                                    }
                                    SDL_blendPixel(surf, x1 - fy, y1 - x, clr, alpha);
                                    SDL_blendPixel(surf, x1 + fy, y1 - x, clr, alpha);
                              }
                        }
                  } else {
                        for (fy = y - 1; fy >= (x ? x : 1); fy--) {
                              if (x) {
                                    SDL_putPixel(surf, x1 - x, y1 + fy, clr);
                                    SDL_putPixel(surf, x1 - x, y1 - fy, clr);
                              }
                              SDL_putPixel(surf, x1 + x, y1 + fy, clr);
                              SDL_putPixel(surf, x1 + x, y1 - fy, clr);

                              if (fy > x) {
                                    if (x) {
                                          SDL_putPixel(surf, x1 - fy, y1 + x, clr);
                                          SDL_putPixel(surf, x1 + fy, y1 + x, clr);
                                    }
                                    SDL_putPixel(surf, x1 - fy, y1 - x, clr);
                                    SDL_putPixel(surf, x1 + fy, y1 - x, clr);
                              }
                        }
                  }
            }

            if (flags & SDL_TG_ANTIALIAS) {
                  /*
                   * anti-aliased circle algorithm.  this is
                   * mathematically correct, but fairly expensive.
                   * looks extremely good though.
                   *
                   * this is also very simple, we simply find the y
                   * value with respect to each x value, using a circle
                   * equation.  the anti-alias values are based on the
                   * real y coordinates.
                   */
                  __CIRCLE_OUTAA
                  __CIRCLE_OUTAA_ROT90
                  if (!(flags & SDL_TG_FILL)) {
                        __CIRCLE_INAA
                        if (x < y-1)
                              __CIRCLE_INAA_ROT90
                  }

                  aatmp = sqrt((float)r2p - x*x);
                  /* Explicit cast now - tdd */
                  y = (int) aatmp;
                  aatmp = aatmp - (int)aatmp;
                  /* Explicit cast now - tdd */
                  aa = (int) (aatmp * alpha);
                  x++;
            } else {
                  /*
                   * i came up with this circle drawing algorithm on my
                   * own.  i don't know how it compares to other circle
                   * drawing algos as far as optimization, but this seems
                   * to work pretty well.  it's also pretty damn
                   * simple, which is what i'm all about.
                   */

                  /* move along x axis */
                  x++;

                  /*
                   * adjust y if we're moving too far out of the circle.
                   * the r2 is simply the radius over 2, unless the
                   * radius is less than a particular value(above).
                   * this simply makes the circle look more accurate,
                   * as we're working with integers so it's never exact,
                   * and we don't want to change the y value unless we're
                   * going off by a particular amount.  this also more
                   * closely approximates the above, mathematically
                   * correct, algo.
                   */
                  if (dy)
                        y += dy;
                  tmp = (r2p - x*x - y*y + r2);
                  if (tmp < 0)
                        dy = -1;
                  else if (dy)
                        dy = 0;
            }
      } while (x < y);

      if (x == y) {
            if (alpha < 255)
                  __CIRCLE_BLEND
            else
                  __CIRCLE_DRAW

            if (flags & SDL_TG_ANTIALIAS) {
                  __CIRCLE_OUTAA
                  __CIRCLE_OUTAA_ROT90
            }
      }
      else if (flags & SDL_TG_ANTIALIAS)
            __CIRCLE_OUTAA

      if (flags & SDL_TG_LOCK)
            __SDL_PRIM_UNLOCKSURFACE(surf)
}


/*
 * draws triangles
 *
 * this isn't very good, there is a good amount of pixel overlapping, 
 * and there are sometimes pixels dangling off the corners...
 *
 * bleh, fuck it, i'll fix it later
 *
 */
void SDL_drawTriangle_TG(SDL_Surface *surf, int x1, int y1, int x2, int y2,
                         int x3, int y3, Uint32 clr, Uint8 alpha, Uint8 flags)
{
      int x, y, c, xlen, ylen, i, aaoffset;
      float a1, b1, a2, b2, slopea, slopeb, aa, aastep, pb1, pb2;
      float slope1, slope2, slope3;

      /* avoid compiler warnings... */
      aa = 0.0;
      aastep = 0.0;
      aaoffset = 0;

#     define __TRI_DRAW(PB, B, SLOPE) \
      { \
            if (fabs(SLOPE) > 1.0) { \
                  c = (PB) > (B) ? -1 : 1; \
                  if (flags & SDL_TG_ANTIALIAS) { \
                        aastep = alpha / fabs(SLOPE); \
                        aa = alpha; \
                  } \
                    /* Explicit cast now - tdd */ \
                  for (y = (int) (PB); ( c > 0 ? y < floor(B) : y > (B) ); y += c) { \
                        if (alpha < 255) \
                              SDL_blendPixel(surf, x, y, clr, alpha); \
                        else \
                              SDL_putPixel(surf, x, y, clr); \
                        if (flags & SDL_TG_ANTIALIAS) { \
                              SDL_blendPixel(surf, x - 1, y, clr, (int)aa); \
                              SDL_blendPixel(surf, x + 1, y, clr, (int)(alpha - aa)); \
                              aa -= aastep; \
                        } \
                  } \
            } else { \
                  if (alpha < 255) \
                        SDL_blendPixel(surf, x, (int)(B), clr, (int)alpha); \
                  else \
                        SDL_putPixel(surf, x, (int)(B), clr); \
                  if (flags & SDL_TG_ANTIALIAS) { \
                        aa = (B) - (int)(B); \
                        aa *= alpha; \
                        SDL_blendPixel(surf, x, (int)(B) + 1, clr, (int)aa); \
                        SDL_blendPixel(surf, x, (int)(B) - 1, clr, (int)(alpha - aa)); \
                  } \
            } \
      }

#     define __TRI_FILL_AA(PB, B, B2, SLOPE) \
      { \
            if (fabs(SLOPE) > 2.0) { \
                  c = (SLOPE > 0) ? 1 : -1; \
                  if (SLOPE > 0) { \
                        if (SLOPE == slope3) { \
                              aaoffset = 0; \
                              aa = 0; \
                              aastep = alpha / SLOPE; \
                        } \
                        else { \
                              aaoffset = -1; \
                              aa = alpha; \
                              aastep = alpha / SLOPE * -1; \
                        } \
                  } \
                  else { \
                        if (SLOPE == slope3) { \
                              aaoffset = 0; \
                              aa = 0; \
                              aastep = alpha / SLOPE * -1; \
                        } \
                        else { \
                              aaoffset = -1; \
                              aa = alpha; \
                              aastep = alpha / SLOPE; \
                        } \
                  } \
                    /* Explicit cast now - tdd */ \
                  for (y = (int) ((PB) + c); ( c > 0 ? y < floor(B) : y > (B) ); y += c) { \
                        SDL_blendPixel(surf, x + aaoffset, y, clr, (int)aa); \
                        aa += aastep; \
                  } \
            } else { \
                  if (B > B2) \
                        c = 1; \
                  else \
                        c = -1; \
                  aa = fabs( (B) - (int)(B) ); \
                  if (c < 0) \
                        aa = alpha - aa * alpha; \
                  else \
                        aa *= alpha; \
                    /* Explicit cast now - tdd */ \
                  SDL_blendPixel(surf, x, (int) ((B) + c), clr, (int)aa); \
            } \
      }

      if ( !(flags & SDL_TG_ALPHA && alpha < 255) )
            alpha = 255;

      /*
       * sort points by X coordinate so we can split the drawing
       * at a slope change
       */
      while ( !(x1 <= x2 && x1 <= x3) ) {
            x = x1;
            y = y1;
            x1 = x2;
            y1 = y2;
            x2 = x3;
            y2 = y3;
            x3 = x;
            y3 = y;
      }
      while ( !(x2 <= x3) ) {
            x = x2;
            y = y2;
            x2 = x3;
            y2 = y3;
            x3 = x;
            y3 = y;
      }

      xlen = x3 - x1;
      ylen = y3 - y1;
      slope1 = (float)ylen / xlen;

      xlen = x1 - x2;
      ylen = y1 - y2;
      slope2 = (float)ylen / xlen;

      xlen = x2 - x3;
      ylen = y2 - y3;
      slope3 = (float)ylen / xlen;

      a1 = x1;
      a2 = x2;
      b1 = y1;
      b2 = y1;
      slopea = slope1;
      slopeb = slope2;

      pb1 = b1;
      pb2 = b2;

      if (flags & SDL_TG_LOCK)
            __SDL_PRIM_LOCKSURFACE(surf)

      for (i = 0; i <= 1; i++) {
            if ((a1 == x1 && a1 != a2) || (a1 != x1 && a1 - 1 != a2)) {
                    /* Explicit cast now - tdd */
                  for (x = (int) a1; x <= a2; x++) {
                        if (flags & SDL_TG_FILL) {
                              c = ((int)b1 < (int)b2) ? 1 : -1;
                              for (y = (int)b1; (c > 0 ? y <= (int)b2 : y >= (int)b2); y += c) {
                                    if (alpha < 255)
                                          SDL_blendPixel(surf, x, y, clr, alpha);
                                    else
                                          SDL_putPixel(surf, x, y, clr);
                              }
                              if (flags & SDL_TG_ANTIALIAS) {
                                    __TRI_FILL_AA(pb1, b1, b2, slopea)
                                    __TRI_FILL_AA(pb2, b2, b1, slopeb)
                              }
                        }
                        else {
                              __TRI_DRAW(pb1, b1, slopea)
                              __TRI_DRAW(pb2, b2, slopeb)
                        }
                        pb1 = b1;
                        pb2 = b2;

                        b1 += slopea;
                        b2 += slopeb;
                  }
            } else if (!(flags & SDL_TG_FILL)) {
                  if (a1 == x1)
                        SDL_drawLine_TG(surf, x1,y1, x2,y2, clr, alpha, flags);
                  else
                        SDL_drawLine_TG(surf, x2,y2, x3,y3, clr, alpha, flags);
            }

            a1 = x2 + 1;
            a2 = x3;
            b2 = y2;
            slopeb = slope3;
            b2 += slopeb;
      }

      if (flags & SDL_TG_LOCK)
            __SDL_PRIM_UNLOCKSURFACE(surf)
}



Generated by  Doxygen 1.6.0   Back to index