Kitomas

Simple GDI Paint v1

Apr 25th, 2025
505
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 11.57 KB | None | 0 0
  1. #include <public_stuff.hpp>
  2.  
  3. #include <algorithm>
  4.  
  5. #define gray(_v) MIN((_v)<<4, 255)
  6.  
  7.  
  8.  
  9. #define color_fg color_history[0]
  10. Color8 color_bg = 0b00000000;
  11. Color8 color_history[17];
  12.  
  13. Color8 color_hover = 0;
  14.  
  15. RECT _frame, frame = {CANVAS_W, CANVAS_H, CANVAS_W, CANVAS_H};
  16.  
  17. Fpoint2d mpos = {CANVAS_W/2, CANVAS_H/2};
  18.  
  19. Color8 pixdata[CANVAS_W*CANVAS_H];
  20.  
  21. u32 clear_presses = 0;
  22.  
  23.  
  24.  
  25.  
  26.  
  27. /******************************************************************************/
  28.  
  29. u8 text_hex[16*3] = {
  30.   //0
  31.   0b11111,
  32.   0b10001,
  33.   0b11111,
  34.   //1
  35.   0b00001,
  36.   0b11111,
  37.   0b10001,
  38.   //2
  39.   0b11101,
  40.   0b10101,
  41.   0b10111,
  42.   //3
  43.   0b11111,
  44.   0b10101,
  45.   0b10001,
  46.   //4
  47.   0b11111,
  48.   0b00100,
  49.   0b11100,
  50.   //5
  51.   0b10111,
  52.   0b10101,
  53.   0b11101,
  54.   //6
  55.   0b00111,
  56.   0b00101,
  57.   0b11111,
  58.   //7
  59.   0b11111,
  60.   0b10000,
  61.   0b10000,
  62.   //8
  63.   0b11111,
  64.   0b10101,
  65.   0b11111,
  66.   //9
  67.   0b11111,
  68.   0b10100,
  69.   0b11100,
  70.   //A
  71.   0b11111,
  72.   0b10100,
  73.   0b11111,
  74.   //B
  75.   0b11011,
  76.   0b10101,
  77.   0b11111,
  78.   //C
  79.   0b10001,
  80.   0b10001,
  81.   0b01110,
  82.   //D
  83.   0b01111,
  84.   0b10001,
  85.   0b11111,
  86.   //E
  87.   0b10001,
  88.   0b10101,
  89.   0b11111,
  90.   //F
  91.   0b10000,
  92.   0b10100,
  93.   0b11111,
  94.  
  95. };
  96.  
  97.  
  98.  
  99.  
  100.  
  101. /******************************************************************************/
  102.  
  103. void draw_hex4(s32 x, s32 y, u8 nybble,
  104.                Color8 color)
  105. {
  106.   nybble &= 15; // Must actually be a nybble
  107.   nybble *= 3;  // Each char is 3 bytes
  108.   nybble += 2;  // The first pixel column is the char's 3rd byte
  109.  
  110.   const s32 y_start = y;
  111.  
  112.   for(int _x=0; _x<3; ++_x){
  113.     if(x < 0){  ++x;  continue;  }
  114.     else if(x >= CANVAS_W) break;
  115.  
  116.     u8 column = text_hex[nybble--];
  117.     y = y_start;
  118.  
  119.     for(int _y=0; _y<5; ++_y){
  120.       if(y <= -5){  column >>= 1;  ++y;  continue;  }
  121.       else if(y >= CANVAS_H) break;
  122.  
  123.       if(column&1)
  124.         pixels[PixelCoords(x,y).v] = color;
  125.  
  126.       column >>= 1;
  127.       ++y;
  128.  
  129.     }
  130.  
  131.     ++x;
  132.  
  133.   }
  134.  
  135. }
  136.  
  137.  
  138.  
  139. void draw_hex8(s32 x, s32 y, u8 value,
  140.                Color8 color)
  141. {
  142.   draw_hex4(x  , y, value>>4, color);
  143.   draw_hex4(x+4, y, value&15, color);
  144. }
  145.  
  146.  
  147.  
  148. void push_color(Color8 new_color){
  149.   if(color_history[0].v == new_color.v) return;
  150.  
  151.   for(int i=sizeof(color_history)-1; i>0; --i)
  152.     color_history[i] = color_history[i-1];
  153.  
  154.   color_history[0] = new_color;
  155.  
  156. }
  157.  
  158.  
  159.  
  160. void clear_pixdata(){
  161.   memset(&pixdata->v, color_bg.v, CANVAS_W*CANVAS_H);
  162.  
  163. }
  164.  
  165.  
  166. void draw_line_pixdata(s32 x_0, s32 y_0,
  167.                        s32 x_1, s32 y_1,
  168.                        Color8 color)
  169. {
  170.   const s32 d_x =  abs(x_1 - x_0);
  171.   const s32 d_y = -abs(y_1 - y_0);
  172.   const s32 s_x = (x_0<x_1) ? 1 : -1;
  173.   const s32 s_y = (y_0<y_1) ? 1 : -1;
  174.   const s32 s_y_row = s_y * CANVAS_W;
  175.  
  176.   s32 err = d_x + d_y;
  177.  
  178.   Color8* dst = &pixdata[x_0 + y_0*CANVAS_W];
  179.  
  180.  
  181.  
  182.   while(true){
  183.     if(  (x_0 >= 0)  &&  (x_0 < CANVAS_W)  &&
  184.          (y_0 >= 0)  &&  (y_0 < CANVAS_H)  )
  185.     {
  186.       dst->v = color.v;
  187.     }
  188.  
  189.     if(x_0 == x_1  &&  y_0 == y_1) break;
  190.     const s32 err2 = err<<1;
  191.  
  192.     if(err2 >= d_y){
  193.       err += d_y;
  194.       x_0 += s_x;
  195.       dst += s_x;
  196.     }
  197.  
  198.     if(err2 <= d_x){
  199.       err += d_x;
  200.       y_0 += s_y;
  201.       dst += s_y_row;
  202.     }
  203.  
  204.   }
  205.  
  206. }
  207.  
  208.  
  209.  
  210. void set_color_hover(PixelCoords mpos_addr){
  211.   if(!(mpos.x <  16.0f  &&
  212.        mpos.y >= 64.0f  &&
  213.        mpos.y < (64.0f+8.0f)))
  214.   {
  215.     color_hover = pixels[mpos_addr.v];
  216.   }
  217.  
  218. }
  219.  
  220.  
  221.  
  222. void set_frame(){
  223.   _frame = frame;
  224.  
  225.   if(_frame.left   >= _frame.right){ std::swap(_frame.left  , _frame.right); }
  226.   if(_frame.bottom >= _frame.top  ){ std::swap(_frame.bottom, _frame.top  ); }
  227.  
  228.   _printf("FRAME {WIDTH, HEIGHT} = {%i, %i}\n",
  229.           (s32)(_frame.right - _frame.left   + 1),
  230.           (s32)(_frame.top   - _frame.bottom + 1));
  231.  
  232. }
  233.  
  234.  
  235.  
  236. void draw_rect_colorinc(s32 x, s32 y,
  237.                         s32 w, s32 h)
  238. {
  239.   if(!w || !h) return;
  240.  
  241.   if(x >= CANVAS_W) return;
  242.   if(y >= CANVAS_H) return;
  243.  
  244.   if(x <= -w) return;
  245.   if(y <= -h) return;
  246.  
  247.  
  248.  
  249.   const s32 x_start  =  MAX(x, 0);
  250.   const s32 y_start  =  MAX(y, 0);
  251.  
  252.   const s32 x_upper  =  x + w; // Upper boundary
  253.   const s32 y_upper  =  y + h;
  254.  
  255.   const s32 x_end  =  MIN(x_upper, CANVAS_W);
  256.   const s32 y_end  =  MIN(y_upper, CANVAS_H);
  257.  
  258.  
  259.   #define color (color_inc += 7) //gray( 1+8+((color_inc++)&7) )
  260.   s32 color_inc = 0;
  261.  
  262.   Color8* n_w  =  pixels;
  263.   n_w  +=  MIN(x_start, CANVAS_W-1);
  264.   n_w  +=  MIN(y_start, CANVAS_H-1) * CANVAS_W;
  265.  
  266.   Color8* n_e  =  n_w + ((x_end-x_start)-1);
  267.   Color8* s_w  =  n_w + ((y_end-y_start)-1)*CANVAS_W;
  268.  
  269.  
  270.  
  271.   // From north-west, going down
  272.   if(x >= 0){
  273.     Color8* _n_w  =  n_w;
  274.     for(s32 _y=y_start; _y<y_end; ++_y){
  275.       _n_w->v = color;
  276.       _n_w += CANVAS_W;
  277.     }
  278.  
  279.   }
  280.  
  281.   // From north-west, going right
  282.   if(y >= 0){
  283.     for(x=x_start; x<x_end; ++x)
  284.       (n_w++)->v = color;
  285.  
  286.   }
  287.  
  288.   // From north-east, going down
  289.   if(x_upper < (CANVAS_W+1)){
  290.     for(y=y_start; y<y_end; ++y){
  291.       n_e->v = color;
  292.       n_e += CANVAS_W;
  293.     }
  294.  
  295.   }
  296.  
  297.   // From south-west, going right
  298.   if(y_upper < (CANVAS_H+1)){
  299.     for(x=x_start; x<x_end; ++x)
  300.       (s_w++)->v = color;
  301.  
  302.   }
  303.  
  304.   #undef color
  305.  
  306. }
  307.  
  308.  
  309.  
  310.  
  311.  
  312. int user_main(int argc, char** argv){
  313.   PixelCoords mpos_addr     = 0;
  314.   PixelCoords mpos_addr_old = 0;
  315.   bool fg_cursor = true;
  316.   bool first_frame_set = true;
  317.  
  318.  
  319.  
  320.   while(!win_closed){
  321.     //Handle events
  322.  
  323.     Event evt;
  324.  
  325.     while(pollEvent(&evt))
  326.     switch(evt.type){
  327.       case EVENT_QUIT: return 0; // No break needed
  328.  
  329.  
  330.  
  331.       case EVENT_KEY_DOWN: if(!evt.key.repeat){
  332.         switch(evt.key.vkey){
  333.           case VKEY_1: {
  334.             _select_fg_color:
  335.             if(mpos.x <= 16.0f  &&  mpos.y <= 64.0f)
  336.               push_color(color_hover);
  337.             else if(mpos.x >= 16.0f || mpos.y >= (64.0f+8.0f))
  338.               color_fg = color_hover;
  339.           } break;
  340.  
  341.           case VKEY_2: {
  342.             _select_bg_color:
  343.             color_bg = color_hover;
  344.           } break;
  345.  
  346.           case VKEY_0:
  347.           case VKEY_SPACE:
  348.           {
  349.             if((clear_presses++)&1) clear_pixdata();
  350.           } break;
  351.  
  352.           case VKEY_LBRACKET: {
  353.             if(mpos.x > 16.0f){
  354.               frame.left = (s32)mpos.x;
  355.               frame.top  = (s32)mpos.y;
  356.               if(first_frame_set){
  357.                 frame.right  = frame.left;
  358.                 frame.bottom = frame.top;
  359.                 first_frame_set = false;
  360.               }
  361.               set_frame();
  362.             }
  363.           } break;
  364.           case VKEY_RBRACKET: {
  365.             if(mpos.x > 16.0f){
  366.               frame.right  = (s32)mpos.x;
  367.               frame.bottom = (s32)mpos.y;
  368.               if(first_frame_set){
  369.                 frame.left = frame.right;
  370.                 frame.top  = frame.bottom;
  371.                 first_frame_set = false;
  372.               }
  373.               set_frame();
  374.             }
  375.           } break;
  376.  
  377.           case VKEY_BSLASH: {
  378.           #ifdef _DEBUG
  379.             Point2d dims = {_frame.right - _frame.left   + 1,
  380.                             _frame.top   - _frame.bottom + 1};
  381.  
  382.             printf("// First line is: \"w, h, transparency, 0,0,0,0,0\"\n");
  383.             printf("const unsigned char exported_image[] = { ");
  384.             //printf("const Color8 exported_image[] = { ");
  385.  
  386.             printf("%i, %i, 0x%02X, 0,0,0,0,0, // %i Bytes",
  387.                    dims.x,dims.y, color_bg.v, 8+dims.x*dims.y);
  388.  
  389.             for(s32 y=_frame.bottom; y<=_frame.top; ++y){
  390.               printf("\n  ");
  391.               for(s32 x=_frame.left; x<=_frame.right; ++x)
  392.                 printf("0x%02X, ", pixdata[x + y*CANVAS_W].v);
  393.             }
  394.  
  395.             printf("\n};\n");
  396.           #endif
  397.           } break;
  398.  
  399.           case VKEY_F1:
  400.           case VKEY_BACKSPACE:
  401.           {
  402.             showMessageBox(
  403.               "Controls:\n"
  404.               "Middle click to trap cursor, \"esc\" to release\n"
  405.               "\n"
  406.               "Left click to draw with the current foreground color\n"
  407.               "Right click to draw with the current background color\n"
  408.               "\n"
  409.               "Scroll wheel to increment foreground color\n"
  410.               "\n"
  411.               "One Key (1) OR X2 mouse click: pick foreground color\n"
  412.               "Two Key (2) OR X1 mouse click: pick background color\n"
  413.               "Zero Key (0) OR Space ( ): clear canvas with background color\n"
  414.               "\n"
  415.               "Left Square Bracket  ([): set point A of export frame\n"
  416.               "Right Square Bracket (]): set point B of export frame\n"
  417.               "Backslash (\\): export contents of frame to stdout"
  418.               , "Simple GDI Paint  -  Build time:  " __TIMESTAMP__);
  419.           } break;
  420.  
  421.           default:;
  422.  
  423.         }
  424.       } break;
  425.  
  426.  
  427.  
  428.       case EVENT_MOUSE_DOWN:
  429.         clear_presses = 0;
  430.       case EVENT_MOUSE_MOVED:
  431.       {
  432.         bool mdown = evt.type==EVENT_MOUSE_DOWN;
  433.         mpos_addr_old = mpos_addr;
  434.         mpos.x = evt.mouse.x;
  435.         mpos.y = evt.mouse.y;
  436.         mpos_addr = {(u8)mpos.x, (u8)mpos.y};
  437.  
  438.         u8 button = evt.mouse.button;
  439.         if(button){
  440.           Color8 selected;
  441.           bool draw = true;
  442.           if(     button&MBUTTON_X2 && mdown) goto _select_fg_color;
  443.           else if(button&MBUTTON_X1 && mdown) goto _select_bg_color;
  444.           else if(button&MBUTTON_LEFT){
  445.             if(mpos.x >= 16.0f){ selected = color_fg; fg_cursor= true; }
  446.             else if(mdown){ goto _select_fg_color; }
  447.           } else if(button&MBUTTON_RIGHT){
  448.             if(mpos.x >= 16.0f){ selected = color_bg; fg_cursor=false; }
  449.             else if(mdown){ goto _select_bg_color; }
  450.           }
  451.           else draw = false;
  452.  
  453.           if(draw){
  454.             draw_line_pixdata(mpos_addr_old.x, mpos_addr_old.y,
  455.                               mpos_addr.x, mpos_addr.y, selected);
  456.           }
  457.         }
  458.       } break;
  459.  
  460.  
  461.  
  462.       case EVENT_MOUSE_VWHEEL: {
  463.         color_fg.v += (s32)evt.mouse.dy;
  464.       } break;
  465.  
  466.  
  467.  
  468.       default:;
  469.  
  470.     }
  471.  
  472.  
  473.  
  474.  
  475.  
  476.     /* - DRAW STUFF - */
  477.  
  478.     // Copy pixel data
  479.     memcpy(&pixels->v, &pixdata->v, sizeof(pixdata));
  480.  
  481.     fill_rect(0, 64+8, 8,4, 0b11000111);
  482.  
  483.     // Color history view (including foreground color)
  484.     for(s32 i=0; i<(s32)sizeof(color_history); ++i)
  485.       fill_rect(0, CANVAS_H-4*(i+1), 8, 4, color_history[i]);
  486.  
  487.     // Background color view
  488.     fill_rect(8, CANVAS_H-4, 8, 4, color_bg);
  489.  
  490.     // Grayscale palette view
  491.     for(int y=0; y<=16; ++y)
  492.       fill_rect(8, CANVAS_H-4*(18-y), 8, 4, gray(y));
  493.  
  494.     // Full palette view
  495.     Color8 c = 0;
  496.     for(int y=0; y<64; y+=2)
  497.     for(int x=0; x<16; x+=2)
  498.     {
  499.       int addr = x + y*CANVAS_W;
  500.       pixels[  addr          ] = c.v; // Bottom-left
  501.       pixels[++addr          ] = c.v; // Bottom-right
  502.       pixels[  addr+=CANVAS_W] = c.v; // Top-right
  503.       pixels[--addr          ] = c.v; // Top-left
  504.       ++c.v;
  505.     }
  506.  
  507.     // Frame view
  508.     if(!first_frame_set){
  509.       draw_rect_colorinc(_frame.left-1, _frame.bottom-1,
  510.                          _frame.right - _frame.left   + 3,
  511.                          _frame.top   - _frame.bottom + 3);
  512.     }
  513.  
  514.     // UI border vertical line
  515.     draw_line(16, 0, 16, CANVAS_H, 0b11111111);
  516.  
  517.     // Whatever color the mouse is currently hovered over
  518.     set_color_hover(mpos_addr);
  519.     fill_rect(0, 64, 16, 8, color_hover);
  520.     draw_hex8(1, 64+1, color_hover.v, gray(17-(color_hover.v>>4)));
  521.  
  522.     // Cursor
  523.     pixels[mpos_addr.v] = (fg_cursor) ? color_fg : color_bg;
  524.  
  525.  
  526.  
  527.     // Draws the canvas to the window
  528.     canvas_present(true);
  529.  
  530.  
  531.  
  532.     // Waits for about 16ms to approximate 60fps
  533.     timeSleep(16);
  534.  
  535.   }
  536.  
  537.  
  538.  
  539.   return 0;
  540.  
  541. }
  542.  
Advertisement
Add Comment
Please, Sign In to add comment