API tools faq
paste
Advertisement
TerusTheBird

masker: sdl_gen.c

TerusTheBird
Jan 7th, 2025
65
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C 9.37 KB | Source Code | 0 0
raw download clone embed print report
  1. #ifndef __sdl_gen_c
  2. #define __sdl_gen_c
  3.  
  4. #include "sdl_gen.h"
  5.  
  6. color_t color_new( u8 r, u8 g, u8 b, u8 a ) {
  7.     color_t out;
  8.     out  = r; out <<= 8;
  9.     out |= g; out <<= 8;
  10.     out |= b; out <<= 8;
  11.     out |= a;
  12.     return out;
  13. }
  14.  
  15. size_t fsize( FILE* fp ){
  16.     size_t prev, fs;
  17.     if( fp == NULL ) return 0;
  18.     prev = ftell( fp );
  19.     fseek( fp, 0L, SEEK_END );
  20.     fs = ftell( fp );
  21.     fseek( fp, prev, SEEK_SET );
  22.     return fs;
  23. }
  24.  
  25. u32 color_to_surf( SDL_Surface* surf, color_t color ) {
  26.     if( !surf ) return 0;
  27.     if( !surf->format ) return 0;
  28.     return SDL_MapRGBA(
  29.         surf->format,
  30.         color>>24,
  31.         (color>>16)&0xFF,
  32.         (color>>8)&0xFF,
  33.         color&0xFF
  34.     );
  35. }
  36.  
  37. u32 surf_to_color( SDL_Surface* surf, u32 color_sdl ) {
  38.     u8 r, g, b, a;
  39.     color_t out;
  40.     if( !surf ) return 0;
  41.     if( !surf->format ) return 0;
  42.     SDL_GetRGBA( color_sdl, surf->format, &(r), &(g), &(b), &(a) );
  43.     out = ( ((color_t)r)<<24 )|( ((color_t)r)<<16 )|( ((color_t)r)<<8 )|a;
  44.     return out;
  45. }
  46.  
  47. void SDL_Clear( SDL_Surface* surf, color_t color ) {
  48.     if( surf == NULL ) return;
  49.     if( surf->format == NULL ) return;
  50.     SDL_FillRect( surf, NULL, color_to_surf( surf, color ) );
  51. }
  52.  
  53. void SDL_Clear_rect_easy( SDL_Surface* surf, int x, int y, int w, int h, color_t color ) {
  54.     SDL_Rect r;
  55.     if( surf == NULL ) return;
  56.     if( surf->format == NULL ) return;
  57.     color = color_to_surf( surf, color );
  58.     r.x = x; r.y = y; r.w = w; r.h = h;
  59.     SDL_FillRect( surf, &r, color );
  60. }
  61.  
  62. void SDL_PutPixel( SDL_Surface* surf, long x, long y, color_t color ) {
  63.     u32 color_sdl;
  64.     int bpp; void* p;
  65.     if( surf == NULL ) return;
  66.     if( surf->pixels == NULL ) return;
  67.     if( surf->format == NULL ) return;
  68.     if( x < 0 || x >= surf->w || y < 0 || y >= surf->h ) return;
  69.     color_sdl = color_to_surf( surf, color );
  70.     bpp = surf->format->BytesPerPixel;
  71.     x *= bpp;
  72.     y *= surf->pitch; y += x;
  73.     p = surf->pixels; p += y;
  74.     switch( bpp ) {
  75.         case 1: {
  76.             *(u8*)p = color_sdl;
  77.         } break;
  78.         case 2: {
  79.             *(u16*)p = color_sdl;
  80.         } break;
  81.         case 3: {
  82.             u8* p8;
  83.             p8 = (u8*)p;
  84.             #if SDL_BYTEORDER == SDL_BIG_ENDIAN
  85.             p8[0] = (color_sdl >> 16) & 0xFF;
  86.             p8[1] = (color_sdl >>  8) & 0xFF;
  87.             p8[2] =  color_sdl        & 0xFF;
  88.             #else
  89.             p8[0] =  color_sdl        & 0xFF;
  90.             p8[1] = (color_sdl >>  8) & 0xFF;
  91.             p8[2] = (color_sdl >> 16) & 0xFF;
  92.             #endif
  93.         } break;
  94.         case 4: {
  95.             *(u32*)p = color_sdl;
  96.         } break;
  97.     }
  98. }
  99.  
  100. color_t SDL_GetPixel( SDL_Surface* surf, long x, long y ) {
  101.     u8* px;
  102.     if( !surf ) return c_black;
  103.     if( x < 0 || y < 0 || x >= surf->w || y >= surf->h || surf->pixels == NULL )
  104.         return c_black;
  105.     px = (u8*)surf->pixels; px += ( y * surf->pitch ) + ( x * surf->format->BytesPerPixel );
  106.     if( surf->format->BytesPerPixel == 1 ) {
  107.         return color_new( *px, *px, *px, 255 );
  108.     } else if( surf->format->BytesPerPixel == 3 ) {
  109.         return color_new( px[2], px[1], px[0], 255 );
  110.     } else if( surf->format->BytesPerPixel == 4 ) {
  111.         return color_new( px[3], px[2], px[1], px[0] );
  112.     }
  113.     return c_black;
  114. }
  115.  
  116. #define int_abs( n ) ( (n) < 0 ? -(n) : (n) )
  117.  
  118. void SDL_Line( SDL_Surface* surf, int x1, int y1, int x2, int y2, color_t color ) {
  119.     int dx, dy, sx, sy, err, e2, count;
  120.     if( surf == NULL ) return;
  121.     if( surf->pixels == NULL || surf->w == 0 || surf->h == 0 ) return;
  122.     dx = int_abs( x2 - x1 );
  123.     sx = x1 < x2 ? 1 : -1;
  124.     dy = int_abs( y2 - y1 );
  125.     sy = y1 < y2 ? 1 : -1;
  126.     err = ( dx > dy ? dx : -dy ) / 2;
  127.     count = 0;
  128.     while(1) {
  129.         SDL_PutPixel( surf, x1, y1, color );
  130.         if( ( x1 == x2 && y1 == y2 ) || count > 1000000 )
  131.             break;
  132.         else {
  133.             e2 = err;
  134.             if( e2 > -dx ) { err -= dy; x1 += sx; }
  135.             if( e2 <  dy ) { err += dx; y1 += sy; }
  136.         }
  137.         ++count;
  138.     }
  139. }
  140.  
  141. void SDL_Line_Straight( SDL_Surface* surf, int x, int y, int dx, int dy, int length, color_t color ) {
  142.     if( !surf ) return;
  143.     while( length-- ) {
  144.         SDL_PutPixel( surf, x, y, color );
  145.         x += dx; y += dy;
  146.     }
  147. }
  148.  
  149.  
  150. void SDL_Circle( SDL_Surface* surf, int x0, int y0, int radius, color_t color ) {
  151.     int f, ddF_x, ddF_y, x, y;
  152.     if( !surf ) return;
  153.     f = 1 - radius;
  154.     ddF_x = 0;
  155.     ddF_y = -2 * radius;
  156.     x = 0;
  157.     y = radius;
  158.    
  159.     SDL_PutPixel( surf, x0, y0 + radius, color );
  160.     SDL_PutPixel( surf, x0, y0 - radius, color );
  161.     SDL_PutPixel( surf, x0 + radius, y0, color );
  162.     SDL_PutPixel( surf, x0 - radius, y0, color );
  163.     while( x < y ) {
  164.         if( f >= 0 ) {
  165.             --y;
  166.             ddF_y += 2;
  167.             f += ddF_y;
  168.         }
  169.         ++x;
  170.         ddF_x += 2;
  171.         f += ddF_x + 1;
  172.         SDL_PutPixel( surf, x0 + x, y0 + y, color);
  173.         SDL_PutPixel( surf, x0 - x, y0 + y, color);
  174.         SDL_PutPixel( surf, x0 + x, y0 - y, color);
  175.         SDL_PutPixel( surf, x0 - x, y0 - y, color);
  176.         SDL_PutPixel( surf, x0 + y, y0 + x, color);
  177.         SDL_PutPixel( surf, x0 - y, y0 + x, color);
  178.         SDL_PutPixel( surf, x0 + y, y0 - x, color);
  179.         SDL_PutPixel( surf, x0 - y, y0 - x, color);
  180.     }
  181. }
  182.  
  183.  
  184. SDL_Surface* surf_new( int w, int h ) {
  185.     SDL_Surface* r;
  186.     if( w <= 0 || h <= 0 ) return NULL;
  187.  
  188.     r = SDL_CreateRGBSurface(
  189.         SDL_SWSURFACE,
  190.         w,
  191.         h,
  192.         24,  0,0,0,0
  193. /*#if SDL_BYTEORDER == SDL_BIG_ENDIAN
  194.         0xFF000000,
  195.         0x00FF0000,
  196.         0x0000FF00,
  197.         0x000000FF
  198. #else
  199.         0x000000FF,
  200.         0x0000FF00,
  201.         0x00FF0000,
  202.         0xFF000000
  203. #endif*/
  204.     );
  205.    
  206.     return r;
  207. }
  208.  
  209.  
  210. int scale_surface_rgb24( SDL_Surface* in, SDL_Surface* out ) {
  211.     u32 x, y;
  212.     if( !in ) return -1;
  213.     if( !in->format ) return -2;
  214.     if( in->format->BitsPerPixel != 24 ) return -3;
  215.     if( !out ) return -4;
  216.     if( !out->format ) return -5;
  217.     if( out->format->BitsPerPixel != 24 ) return -6;
  218.     if( in->w == out->w && in->h == out->h ) {
  219.         SDL_BlitSurface( in, NULL, out, NULL );
  220.         return 0;
  221.     }
  222.    
  223.     for( y = 0; y < out->h; ++y ) {
  224.         u32 dy;
  225.         dy = ( y * in->h ) / out->h;
  226.         if( dy >= in->h ) continue;
  227.         for( x = 0; x < out->w; ++x ) {
  228.             u8 c[3];
  229.             u8* px;
  230.             u32 dx;
  231.             dx = ( x * in->w ) / out->w;
  232.             if( dx >= in->w ) continue;
  233.             px = (u8*)in->pixels; px += ( dy * in->pitch ) + ( dx * in->format->BytesPerPixel );
  234.             c[0] = px[0];
  235.             c[1] = px[1];
  236.             c[2] = px[2];
  237.            
  238.             px = (u8*)out->pixels; px += ( y * out->pitch ) + ( x * out->format->BytesPerPixel );
  239.             px[0] = c[0];
  240.             px[1] = c[1];
  241.             px[2] = c[2];
  242.         }
  243.     }
  244.    
  245.     return 0;
  246. }
  247.  
  248.  
  249. SDL_Surface* scale_surface( SDL_Surface* in, SDL_Surface* out, int new_w, int new_h ) {
  250.     int x, y;
  251.     int w2, h2;
  252.     if( !in || new_w <= 0 || new_h <= 0 ) return NULL;
  253.     if( !out ) {
  254.         out = surf_new( new_w, new_h );
  255.         if( !out ) return NULL;
  256.     }
  257.    
  258.     w2 = new_w/2;
  259.     h2 = new_h/2;
  260.     // scale it
  261.     for( y = 0; y < new_h; ++y )
  262.         for( x = 0; x < new_w; ++x )
  263.             SDL_PutPixel( out, x, y,  SDL_GetPixel( in, ( ( ((s64)x) * in->w ) + w2 ) / new_w, ( ( ((s64)y) * in->h ) + h2 ) / new_h ) );
  264.    
  265.     return out;
  266. }
  267.  
  268.  
  269.  
  270. // write out a TGA
  271.  
  272. void file_write_u16le( u16 n, FILE* fp ) {
  273.     if( !fp ) return;
  274.     fputc( n & 0xFF, fp );
  275.     fputc( n >> 8, fp );
  276. }
  277.  
  278. void file_write_zeroes( unsigned int len, FILE* fp ) {
  279.     if( !fp ) return;
  280.     while( len-- ) {
  281.         fputc( 0, fp );
  282.     }
  283. }
  284.  
  285. /*
  286. simple TGA header
  287.   /---------------- uint8_t  pixel type, 2 for direct RGB
  288.   |     /---------- int16_t  X origin, pretty much always 0
  289.   |     | /-------- int16_t  Y origin, pretty much always == height
  290.   |     | | /------ uint16_t width
  291.   |     | | | /---- uint16_t height
  292.   |     | | | | /-- uint8_t  bits-per-pixel
  293.   |     | | | | |/- uint8_t  bit-field: 00S0BBBB   B=bits per alpha  S=screen origin
  294.   |     | | | | ||
  295. 00P00000XXYYWWHHBC
  296.  
  297. values are little-endian
  298. RGBA values are stored as BGRA
  299. */
  300.  
  301. int save_to_tga( SDL_Surface* surf, char* path ) {
  302.     FILE* fp;
  303.     if( !surf ) return -1;
  304.     if( surf->format->BytesPerPixel != 3 ) return -2;
  305.     if( !path ) return -3;
  306.     fp = fopen( path, "wb" );
  307.     if( !fp ) return -4;
  308.    
  309.     file_write_zeroes( 2U, fp );
  310.     fputc( 2U, fp );
  311.     file_write_zeroes( 7U, fp );
  312.     file_write_u16le( surf->h, fp );
  313.     file_write_u16le( surf->w, fp );
  314.     file_write_u16le( surf->h, fp );
  315.     //fputc( surf->format->BytesPerPixel * 8, fp );
  316.     fputc( 24U, fp );
  317.     fputc( 32U , fp ); // 0b00100000
  318.    
  319.     {
  320.     u8* px; u32 y;
  321.     px = (u8*)surf->pixels;
  322.     for( y = 0; y < surf->h; ++y ) {
  323.         fwrite( px, 3, surf->w, fp ); // demb
  324.         px += surf->pitch;
  325.     }
  326.     }
  327.    
  328.     fclose( fp ); fp = NULL;
  329.     return 0;
  330. }
  331.  
  332. #include "color_table.c"
  333.  
  334. u32 pixel_high_gray( rgb96_t c ) {
  335.     u32 n;
  336.     //       1.0 is 4095
  337.     n  = ( U32(c.r) * 1224U ) / 4095U;
  338.     n += ( U32(c.g) * 2404U ) / 4095U;
  339.     n += ( U32(c.b) *  467U ) / 4095U;
  340.     return n;
  341. }
  342.  
  343. rgb96_t pixel_high_get( SDL_Surface* surf, long x, long y ) {
  344.     color_t c;
  345.     rgb96_t r;
  346.     if( !surf ) return RGB96_BLACK;
  347.     // keep it within bounds
  348.     if( x < 0 ) x = 0; if( x >= surf->w ) x = surf->w - 1;
  349.     if( y < 0 ) y = 0; if( y >= surf->h ) y = surf->h - 1;
  350.     c = SDL_GetPixel( surf, x, y );
  351.    
  352.     r.r = srgb_to_linear_table[ ( c >> 24 ) & 0xFF ];
  353.     r.g = srgb_to_linear_table[ ( c >> 16 ) & 0xFF ];
  354.     r.b = srgb_to_linear_table[ ( c >>  8 ) & 0xFF ];
  355.     return r;
  356. }
  357.  
  358.  
  359. int pixel_high_put( SDL_Surface* surf, long x, long y, rgb96_t c ) {
  360.     if( !surf ) return -1;
  361.     // keep it within bounds
  362.     if( x < 0 ) x = 0; if( x >= surf->w ) x = surf->w - 1;
  363.     if( y < 0 ) y = 0; if( y >= surf->h ) y = surf->h - 1;
  364.    
  365.     if( c.r > 0xFFF ) c.r = 0xFFF;
  366.     if( c.g > 0xFFF ) c.g = 0xFFF;
  367.     if( c.b > 0xFFF ) c.b = 0xFFF;
  368.    
  369.     SDL_PutPixel( surf, x, y, color_new(
  370.         linear_to_srgb_table[ c.r ],
  371.         linear_to_srgb_table[ c.g ],
  372.         linear_to_srgb_table[ c.b ],
  373.         255U
  374.     ) );
  375.     return 0;
  376. }
  377.  
  378. rgb96_t pixel_high_add( rgb96_t c1, rgb96_t c2 ) {
  379.     c1.r += c2.r;
  380.     c1.g += c2.g;
  381.     c1.b += c2.b;
  382.     return c1;
  383. }
  384.  
  385. rgb96_t pixel_high_div_n( rgb96_t c1, u32 n ) {
  386.     c1.r /= n;
  387.     c1.g /= n;
  388.     c1.b /= n;
  389.     return c1;
  390. }
  391.  
  392.  
  393. #endif
  394.  
  395.  
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!