Go Premium for a chance to win a PS4. Enter to Win

x
  • Status: Solved
  • Priority: Medium
  • Security: Public
  • Views: 797
  • Last Modified:

DrawLine in DirectDraw

Can someone give me an example of drawing simple lines in DirectDraw and C++. (2D)
0
franceskinm
Asked:
franceskinm
1 Solution
 
AlexVirochovskyCommented:
Small example of using DirectDraw you can find in
http://www.theparticle.com/pgraph.html
In http://www.cs.mcgill.ca/~kshaikh/ComputerGraphicsTutorial.html
Press softvare, lesson 3, display code, you can see, how
display line .
0
 
franceskinmAuthor Commented:
Thank you, but the examples you gave me use DrawPrimitive that goes trough 3D engine (if I understood right). What I wanted was an example of drawing in 2D directly to DirectDraw surface.
0
 
MithanderCommented:
The way I've always done it is to lock a DC.  Use the windows api to draw on it, and release the DC.  I'm not at home right now, so I can't put up some code.  But if you look in the DirectX help for LockDC... Or something like that :)  you should be ok.  This is a pretty slow way to do it, but I don't think anything else is supported.
0
 
FengYuanCommented:
From my book (www.fengyuan.com)

void KLockedSurface::Line(int x0, int y0, int x1, int y1, DWORD color)
{
     int bps       = (bpp+7) / 8;                           // bytes-per-pixel
     BYTE * pPixel = pSurface + pitch * y0 + bps * x0; // first pixel address

     int error;                              // error
     int d_pixel_pos, d_error_pos;   // adjustment to pixel address and error when error>=0
     int d_pixel_neg, d_error_neg;     // adjustment to pixel address and error when error<0
     int dots;                              // number of dots to draw

     {
          int dx, dy, inc_x, inc_y;

          if ( x1 > x0 )
          {      dx = x1 - x0; inc_x =  bps; }
          else
          {     dx = x0 - x1; inc_x = -bps; }

          if ( y1 > y0 )
          {      dy = y1 - y0; inc_y =  pitch; }
          else
          {     dy = y0 - y1; inc_y = -pitch; }

          d_pixel_pos = inc_x + inc_y;    // move x and y
          d_error_pos = (dy - dx) * 2;
     
          if ( d_error_pos < 0 ) // x dominant
          {
               dots        = dx;
               error       = dy*2 - dx;
               d_pixel_neg = inc_x;          // move x only
               d_error_neg = dy * 2;
          }
          else
          {
               dots        = dy;
               error       = dx*2 - dy;
               d_error_pos = - d_error_pos;
               d_pixel_neg = inc_y;          // move y only
               d_error_neg = dx * 2;
          }
     }

     switch ( bps )
     {
          case 1:
               for (; dots>=0; dots--)               // 8-bpp pixel loop
               {
                    pPixel[0] = (BYTE) color;     // draw 8-bpp pixel
               
                    if ( error>=0 )
                    {  pPixel += d_pixel_pos; error  += d_error_pos; }
                    else
                    {  pPixel += d_pixel_neg; error  += d_error_neg; }
               }
               break;

          case 2:
               for (; dots>=0; dots--)               // 16-bpp pixel loop
               {
                    * (WORD *) pPixel = (WORD) color;     // draw 16-bpp pixel
               
                    if ( error>=0 )
                    {  pPixel += d_pixel_pos; error  += d_error_pos; }
                    else
                    {  pPixel += d_pixel_neg; error  += d_error_neg; }
               }
               break;

          case 3:
               for (; dots>=0; dots--)               // 24-bpp pixel loop
               {
                    * (RGBTRIPLE *) pPixel = * (RGBTRIPLE *) & color;     // draw 24-bpp pixel
               
                    if ( error>=0 )
                    {  pPixel += d_pixel_pos; error  += d_error_pos; }
                    else
                    {  pPixel += d_pixel_neg; error  += d_error_neg; }
               }
               break;

          case 4:
               for (; dots>=0; dots--)               // 32-bpp pixel loop
               {
                    * (DWORD *) pPixel = color;     // draw 32-bpp pixel
               
                    if ( error>=0 )
                    {  pPixel += d_pixel_pos; error  += d_error_pos; }
                    else
                    {  pPixel += d_pixel_neg; error  += d_error_neg; }
               }
               break;
     }
}

0

Featured Post

Independent Software Vendors: We Want Your Opinion

We value your feedback.

Take our survey and automatically be enter to win anyone of the following:
Yeti Cooler, Amazon eGift Card, and Movie eGift Card!

Tackle projects and never again get stuck behind a technical roadblock.
Join Now