home *** CD-ROM | disk | FTP | other *** search
/ Fish 'n' More 2 / fishmore-publicdomainlibraryvol.ii1991xetec.iso / fish / code_examples / cmanual_456 / acm3.lzh / LowLevelGraphics / Example9.c < prev    next >
C/C++ Source or Header  |  1991-01-12  |  8KB  |  312 lines
  1. /* Example 9                                                             */
  2. /* This example shows how to flood fill a figure, and how to draw filled */
  3. /* rectangles (both solid as well as filled with single and multi        */
  4. /* coloured patterns).                                                   */
  5.  
  6.  
  7. #include <intuition/intuition.h>
  8. #include <graphics/gfxbase.h>
  9. #include <graphics/gfxmacros.h>
  10.  
  11.  
  12. /* NOTE! We must include the file "gfxmacros.h" inorder to be able to */
  13. /* use the functions (macros) SetOPen() and SetAfPt().                */
  14.  
  15.  
  16. #define WIDTH  320 /* 320 pixels wide (low resolution)                */
  17. #define HEIGHT 200 /* 200 lines high (non interlaced NTSC display)    */ 
  18. #define DEPTH    2 /* 2 BitPlanes should be used, gives four colours. */
  19. #define COLOURS  4 /* 2^2 = 4                                         */
  20.  
  21.  
  22. #define OUTLINE_MODE 0 /* Fill until we find same colour as Outline Pen. */
  23. #define COLOUR_MODE  1 /* Fill until we find another colour.             */
  24.  
  25.  
  26. struct IntuitionBase *IntuitionBase;
  27. struct GfxBase *GfxBase;
  28.  
  29.  
  30. struct View my_view;
  31. struct View *my_old_view;
  32. struct ViewPort my_view_port;
  33. struct RasInfo my_ras_info;
  34. struct BitMap my_bit_map;
  35. struct RastPort my_rast_port;
  36.  
  37.  
  38. UWORD my_color_table[] =
  39. {
  40.   0x000, /* Colour 0, Black */
  41.   0xF00, /* Colour 1, Red   */
  42.   0x0F0, /* Colour 2, Green */
  43.   0x00F  /* Colour 3, Blue  */
  44. };
  45.  
  46.  
  47. /* The coordinates (25) for the PolyDraw() function: */
  48. WORD coordinates[] =
  49. {
  50.     0,   0,
  51.   120,   0,
  52.   120,  40,
  53.   180,  40,
  54.   180,   0,
  55.   300,   0,
  56.   300,  20,
  57.   200,  20,
  58.   200,  60,
  59.   160,  60,
  60.   160, 100,
  61.   280, 100,
  62.   280,  40,
  63.   300,  40,
  64.   300, 120,
  65.     0, 120,
  66.     0,  40,
  67.    20,  40,
  68.    20, 100,
  69.   140, 100,
  70.   140,  60,
  71.   100,  60,
  72.   100,  20,
  73.     0,  20,
  74.     0,   0
  75. };
  76.  
  77.  
  78. /* A heart (1 BitPlane):                                               */
  79. /* An area pattern is always 16 bits wide, and the hight is some power */
  80. /* of two (1, 2, 4, 8, 16, 32, and so on ).                            */
  81. UWORD pattern[] =
  82. {
  83.   0x38E0, /* 0011 1000 1110 0000 */
  84.   0x7DF0, /* 0111 1101 1111 0000 */
  85.   0xFFF8, /* 1111 1111 1111 1000 */
  86.   0xFFF8, /* 1111 1111 1111 1000 */
  87.   0xFFF8, /* 1111 1111 1111 1000 */
  88.   0x7FF0, /* 0111 1111 1111 0000 */
  89.   0x3FE0, /* 0011 1111 1110 0000 */
  90.   0x1FC0, /* 0001 1111 1100 0000 */
  91.   0x0F80, /* 0000 1111 1000 0000 */
  92.   0x0700, /* 0000 0111 0000 0000 */
  93.   0x0200, /* 0000 0010 0000 0000 */
  94.  
  95.   0x0000, /* 0000 0000 0000 0000 */
  96.   0x0000, /* 0000 0000 0000 0000 */
  97.   0x0000, /* 0000 0000 0000 0000 */
  98.   0x0000, /* 0000 0000 0000 0000 */
  99.   0x0000, /* 0000 0000 0000 0000 */
  100. };
  101.  
  102.  
  103. /* A four-coloured pattern: (Black, red, green and blue lines) */
  104. UWORD coloured_pattern[][] =
  105. {
  106.   {
  107.     0x00FF, /* BitPlane 0 */
  108.     0xFF00,
  109.     0x00FF,
  110.     0xFF00
  111.   },
  112.   {
  113.     0x00FF, /* BitPlane 1 */
  114.     0x00FF,
  115.     0xFF00,
  116.     0xFF00
  117.   }
  118. };
  119.  
  120.  
  121. void clean_up();
  122. void main();
  123.  
  124.  
  125. void main()
  126. {
  127.   UWORD *pointer;
  128.   int loop;
  129.   
  130.  
  131.   /* Open the Intuition library: */
  132.   IntuitionBase = (struct IntuitionBase *)
  133.     OpenLibrary( "intuition.library", 0 );
  134.   if( !IntuitionBase )
  135.     clean_up( "Could NOT open the Intuition library!" );
  136.  
  137.   /* Open the Graphics library: */
  138.   GfxBase = (struct GfxBase *)
  139.     OpenLibrary( "graphics.library", 0 );
  140.   if( !GfxBase )
  141.     clean_up( "Could NOT open the Graphics library!" );
  142.  
  143.  
  144.   /* Save the current View, so we can restore it later: */
  145.   my_old_view = GfxBase->ActiView;
  146.  
  147.  
  148.   /* 1. Prepare the View structure, and give it a pointer to */
  149.   /*    the first ViewPort:                                  */
  150.   InitView( &my_view );
  151.   my_view.ViewPort = &my_view_port;
  152.  
  153.  
  154.   /* 2. Prepare the ViewPort structure, and set some important values: */
  155.   InitVPort( &my_view_port );
  156.   my_view_port.DWidth = WIDTH;         /* Set the width.                */
  157.   my_view_port.DHeight = HEIGHT;       /* Set the height.               */
  158.   my_view_port.RasInfo = &my_ras_info; /* Give it a pointer to RasInfo. */
  159.   my_view_port.Modes = NULL;           /* Low resolution.               */
  160.  
  161.  
  162.   /* 3. Get a colour map, link it to the ViewPort, and prepare it: */
  163.   my_view_port.ColorMap = (struct ColorMap *) GetColorMap( COLOURS );
  164.   if( my_view_port.ColorMap == NULL )
  165.     clean_up( "Could NOT get a ColorMap!" );
  166.  
  167.   /* Get a pointer to the colour map: */
  168.   pointer = (UWORD *) my_view_port.ColorMap->ColorTable;
  169.  
  170.   /* Set the colours: */
  171.   for( loop = 0; loop < COLOURS; loop++ )
  172.     *pointer++ = my_color_table[ loop ];
  173.  
  174.  
  175.   /* 4. Prepare the BitMap: */
  176.   InitBitMap( &my_bit_map, DEPTH, WIDTH, HEIGHT );
  177.  
  178.   /* Allocate memory for the Raster: */ 
  179.   for( loop = 0; loop < DEPTH; loop++ )
  180.   {
  181.     my_bit_map.Planes[ loop ] = (PLANEPTR) AllocRaster( WIDTH, HEIGHT );
  182.     if( my_bit_map.Planes[ loop ] == NULL )
  183.       clean_up( "Could NOT allocate enough memory for the raster!" );
  184.  
  185.     /* Clear the display memory with help of the Blitter: */
  186.     BltClear( my_bit_map.Planes[ loop ], RASSIZE( WIDTH, HEIGHT ), 0 );
  187.   }
  188.  
  189.   
  190.   /* 5. Prepare the RasInfo structure: */
  191.   my_ras_info.BitMap = &my_bit_map; /* Pointer to the BitMap structure.  */
  192.   my_ras_info.RxOffset = 0;         /* The top left corner of the Raster */
  193.   my_ras_info.RyOffset = 0;         /* should be at the top left corner  */
  194.                                     /* of the display.                   */
  195.   my_ras_info.Next = NULL;          /* Single playfield - only one       */
  196.                                     /* RasInfo structure is necessary.   */
  197.  
  198.   /* 6. Create the display: */
  199.   MakeVPort( &my_view, &my_view_port );
  200.   MrgCop( &my_view );
  201.  
  202.  
  203.   /* 7. Prepare the RastPort, and give it a pointer to the BitMap. */
  204.   InitRastPort( &my_rast_port );
  205.   my_rast_port.BitMap = &my_bit_map;
  206.   
  207.  
  208.   /* 8. Show the new View: */
  209.   LoadView( &my_view );
  210.  
  211.  
  212.  
  213.   SetDrMd( &my_rast_port, JAM2 ); /* Use Fg and Bg Pen. */
  214.   SetAPen( &my_rast_port, 3 );    /* FgPen:  Blue       */
  215.   SetBPen( &my_rast_port, 2 );    /* BgPen:  Green      */
  216.   SetOPen( &my_rast_port, 3 );    /* BgPen:  Blue       */
  217.  
  218.  
  219.   /* Draw a funny figure in blue colour: */
  220.   Move( &my_rast_port, 0, 0 );
  221.   PolyDraw( &my_rast_port, 25, coordinates );
  222.  
  223.  
  224.   /* Wait 5 seconds: */
  225.   Delay( 50 * 5 );
  226.  
  227.  
  228.   /* Change FgPen colour to red, and fill the figure: */
  229.   SetAPen( &my_rast_port, 1 );    /* FgPen: Red       */
  230.   Flood( &my_rast_port, OUTLINE_MODE, 10, 10 );
  231.  
  232.  
  233.   /* Wait 5 seconds: */
  234.   Delay( 50 * 5 );
  235.   
  236.  
  237.   /* Draw a filled rectangle at the bottom of the display: */
  238.   RectFill( &my_rast_port, 0, 150, 150, 190 );
  239.  
  240.  
  241.   /* Wait 5 seconds: */
  242.   Delay( 50 * 5 );
  243.  
  244.  
  245.   /* Set the are pattern. We will now draw a rectangle filled with a */
  246.   /* lot of  hearts. (The pattern is 16 lines tall which is 2 to the  */
  247.   /* power of 4.)                                                    */
  248.   SetAfPt( &my_rast_port, (USHORT *) pattern, 4);
  249.  
  250.   /* Draw a rectangle filled with hearts at the bottom of the display: */
  251.   RectFill( &my_rast_port, 150, 150, 300, 190 );
  252.  
  253.  
  254.   /* Wait 5 seconds: */
  255.   Delay( 50 * 5 );
  256.  
  257.  
  258.   /* Prepare to fill with a coloured pattern: */
  259.   /* Drawmode JAM2, FgPen colour 255, BgPen 0 */
  260.   SetDrMd( &my_rast_port, JAM2 );
  261.   SetAPen( &my_rast_port, 255 );
  262.   SetBPen( &my_rast_port, 0 );
  263.   SetAfPt( &my_rast_port, (USHORT *) coloured_pattern, -2);
  264.   /* 4 lines = 2^2 -> 2 : Multicolour: -2 */
  265.  
  266.   /* Draw a rectangle filled with four colours: */
  267.   RectFill( &my_rast_port, 0, 150, 300, 190 );
  268.  
  269.  
  270.   /* Wait 5 seconds: */
  271.   Delay( 50 * 5 );
  272.  
  273.  
  274.  
  275.   /* 9. Restore the old View: */
  276.   LoadView( my_old_view );
  277.  
  278.  
  279.   /* Free all allocated resources and leave. */
  280.   clean_up( "THE END" );
  281. }
  282.  
  283.  
  284. /* Returns all allocated resources: */
  285. void clean_up( message )
  286. STRPTR message;
  287. {
  288.   int loop;
  289.  
  290.   /* Free automatically allocated display structures: */
  291.   FreeVPortCopLists( &my_view_port );
  292.   FreeCprList( my_view.LOFCprList );
  293.   
  294.   /* Deallocate the display memory, BitPlane for BitPlane: */
  295.   for( loop = 0; loop < DEPTH; loop++ )
  296.     if( my_bit_map.Planes[ loop ] )
  297.       FreeRaster( my_bit_map.Planes[ loop ], WIDTH, HEIGHT );
  298.  
  299.   /* Deallocate the ColorMap: */
  300.   if( my_view_port.ColorMap ) FreeColorMap( my_view_port.ColorMap );
  301.  
  302.   /* Close the Graphics library: */
  303.   if( GfxBase ) CloseLibrary( GfxBase );
  304.  
  305.   /* Close the Intuition library: */
  306.   if( IntuitionBase ) CloseLibrary( IntuitionBase );
  307.  
  308.   /* Print the message and leave: */
  309.   printf( "%s\n", message ); 
  310.   exit();
  311. }
  312.