home *** CD-ROM | disk | FTP | other *** search
/ Fish 'n' More 2 / fishmore-publicdomainlibraryvol.ii1991xetec.iso / fish / code_examples / cmanual_456 / acm3.lzh / LowLevelGraphics / Example6.c < prev    next >
C/C++ Source or Header  |  1991-01-12  |  9KB  |  311 lines
  1. /* Example 6                                                             */
  2. /* This example demonstrates how to create a ViewPort in dual playfield  */
  3. /* mode. Playfield 1 use four colours and is placed behind playfield 2   */
  4. /* which only use two colours (transparent and grey). Playfield 1 is     */
  5. /* filled with a lot of dots and is scrolled around while playfield 2 is */
  6. /* is not moved and is filled with only five grey rectangles.            */
  7.  
  8.  
  9. #include <intuition/intuition.h>
  10. #include <graphics/gfxbase.h>
  11.  
  12.  
  13. #define DWIDTH   320 /* Display 320 pixels wide (low resolution).     */
  14. #define DHEIGHT  200 /* Display 200 lines tall (NTSC non interlaced). */
  15.  
  16. #define RWIDTH1  600 /* 600 pixels wide.                              */
  17. #define RHEIGHT1 300 /* 300 lines high.                               */
  18. #define DEPTH1     2 /* Playfield one should use 2 BitPlanes.         */
  19.  
  20. #define RWIDTH2  320 /* 320 pixels wide.                              */
  21. #define RHEIGHT2 200 /* 200 lines high.                               */
  22. #define DEPTH2     1 /* Playfield two should use 1 BitPlane.          */
  23.  
  24. #define COLOURS   10 /* PF1: colours 0-3, PF2: colours 8 and 9. (0-9) */
  25.  
  26. #define SPEED      1 /* How many pixels the Raster should be scrolled */
  27.                      /* every time.                                   */
  28.  
  29. #define BOXES      5 /* Draw 5 rectangles in the second playfield.    */
  30.  
  31.  
  32. struct IntuitionBase *IntuitionBase;
  33. struct GfxBase *GfxBase;
  34.  
  35.  
  36. struct View view;
  37. struct View *old_view;
  38. struct ViewPort view_port;
  39.  
  40. /* Playfield 1: */
  41. struct RasInfo ras_info1;
  42. struct BitMap bit_map1;
  43. struct RastPort rast_port1;
  44.  
  45. /* Playfield 2: */
  46. struct RasInfo ras_info2;
  47. struct BitMap bit_map2;
  48. struct RastPort rast_port2;
  49.  
  50.  
  51. UWORD color_table[] =
  52. {
  53.   0x000, /* Colour 0, Black       */
  54.   0xF00, /* Colour 1, Red         */
  55.   0x0F0, /* Colour 2, Green       */
  56.   0x00F, /* Colour 3, Blue        */
  57.   0x000, /* Colour 4, Not used    */
  58.   0x000, /* Colour 5,   - " -     */
  59.   0x000, /* Colour 6,   - " -     */
  60.   0x000, /* Colour 7,   - " -     */
  61.   0x000, /* Colour 8, Transparent */
  62.   0x888  /* Colour 9, Grey        */
  63. };
  64.  
  65.  
  66. UWORD box[ BOXES ][ 4 ] =
  67. {
  68.   /*  Minimum  Maximum */
  69.   /*  X    Y    X    Y */
  70.   {    0,   0,  50,  20 },
  71.   {  150,  30, 260,  50 },
  72.   {  290, 100, 319, 150 },
  73.   {  150, 170, 210, 199 },
  74.   {   20,  70,  90, 170 }
  75. };
  76.  
  77.  
  78. void clean_up();
  79. void main();
  80.  
  81.  
  82. void main()
  83. {
  84.   SHORT deltaX = SPEED;
  85.   SHORT deltaY = SPEED;
  86.   UWORD *pointer;
  87.   int loop;
  88.   
  89.  
  90.   /* Open the Intuition library: */
  91.   IntuitionBase = (struct IntuitionBase *)
  92.     OpenLibrary( "intuition.library", 0 );
  93.   if( !IntuitionBase )
  94.     clean_up( "Could NOT open the Intuition library!" );
  95.  
  96.   /* Open the Graphics library: */
  97.   GfxBase = (struct GfxBase *)
  98.     OpenLibrary( "graphics.library", 0 );
  99.   if( !GfxBase )
  100.     clean_up( "Could NOT open the Graphics library!" );
  101.  
  102.  
  103.  
  104.   /* Save the current View, so we can restore it later: */
  105.   old_view = GfxBase->ActiView;
  106.  
  107.  
  108.  
  109.   /* 1. Prepare the View structure, and give it a pointer to */
  110.   /*    the first ViewPort:                                  */
  111.   InitView( &view );
  112.   view.ViewPort = &view_port;
  113.  
  114.  
  115.  
  116.   /* 2. Prepare the ViewPort structure, and set some important values: */
  117.   InitVPort( &view_port );
  118.   view_port.DWidth = DWIDTH;        /* Set the width.                  */
  119.   view_port.DHeight = DHEIGHT;      /* Set the height.                 */
  120.   view_port.RasInfo = &ras_info1;   /* Give it a pointer to RasInfo.   */
  121.   view_port.Modes = DUALPF|PFBA;    /* Dual playfields, 2 on top of 1. */
  122.  
  123.  
  124.   /* 3. Get a colour map, link it to the ViewPort, and prepare it: */
  125.   view_port.ColorMap = (struct ColorMap *) GetColorMap( COLOURS );
  126.   if( view_port.ColorMap == NULL )
  127.     clean_up( "Could NOT get a ColorMap!" );
  128.  
  129.   /* Get a pointer to the colour map: */
  130.   pointer = (UWORD *) view_port.ColorMap->ColorTable;
  131.  
  132.   /* Set the colours: */
  133.   for( loop = 0; loop < COLOURS; loop++ )
  134.     *pointer++ = color_table[ loop ];
  135.  
  136.  
  137.  
  138.   /* 4. Prepare the BitMaps: */
  139.  
  140.   /* Playfield 1: */
  141.   InitBitMap( &bit_map1, DEPTH1, RWIDTH1, RHEIGHT1 );
  142.   /* Allocate memory for the Raster: */ 
  143.   for( loop = 0; loop < DEPTH1; loop++ )
  144.   {
  145.     bit_map1.Planes[ loop ] = (PLANEPTR) AllocRaster( RWIDTH1, RHEIGHT1 );
  146.     if( bit_map1.Planes[ loop ] == NULL )
  147.       clean_up( "Could NOT allocate enough memory for the raster!" );
  148.  
  149.     /* Clear the display memory with help of the Blitter: */
  150.     BltClear( bit_map1.Planes[ loop ], RASSIZE( RWIDTH1, RHEIGHT1 ), 0 );
  151.   }
  152.  
  153.   /* Playfield 2: */
  154.   InitBitMap( &bit_map2, DEPTH2, RWIDTH2, RHEIGHT2 );
  155.   /* Allocate memory for the Raster: */ 
  156.   for( loop = 0; loop < DEPTH2; loop++ )
  157.   {
  158.     bit_map2.Planes[ loop ] = (PLANEPTR) AllocRaster( RWIDTH2, RHEIGHT2 );
  159.     if( bit_map2.Planes[ loop ] == NULL )
  160.       clean_up( "Could NOT allocate enough memory for the raster!" );
  161.  
  162.     /* Clear the display memory with help of the Blitter: */
  163.     BltClear( bit_map2.Planes[ loop ], RASSIZE( RWIDTH2, RHEIGHT2 ), 0 );
  164.   }
  165.  
  166.  
  167.  
  168.   /* 5. Prepare the RasInfo structures: */
  169.  
  170.   /* Playfield 1: */
  171.   ras_info1.BitMap = &bit_map1; /* Pointer to the BitMap structure.  */
  172.   ras_info1.RxOffset = 0;       /* The top left corner of the Raster */
  173.   ras_info1.RyOffset = 0;       /* should be at the top left corner  */
  174.                                 /* of the display.                   */
  175.   ras_info1.Next = &ras_info2;  /* Link RasInfo1 to RasInfo2.        */
  176.  
  177.   /* Playfield 2: */
  178.   ras_info2.BitMap = &bit_map2; /* Pointer to the BitMap structure.  */
  179.   ras_info2.RxOffset = 0;       /* The top left corner of the Raster */
  180.   ras_info2.RyOffset = 0;       /* should be at the top left corner  */
  181.                                 /* of the display.                   */
  182.   ras_info2.Next = NULL;        /* Last RasInfo structure.           */
  183.  
  184.  
  185.  
  186.   /* 6. Create the display: */
  187.   MakeVPort( &view, &view_port );
  188.   MrgCop( &view );
  189.  
  190.  
  191.  
  192.   /* 7. Prepare the RastPorts, and give them a pointer to each BitMap. */
  193.  
  194.   /* Playfield 1: */
  195.   InitRastPort( &rast_port1 );
  196.   rast_port1.BitMap = &bit_map1;
  197.  
  198.   /* Playfield 2: */
  199.   InitRastPort( &rast_port2 );
  200.   rast_port2.BitMap = &bit_map2;
  201.   
  202.  
  203.  
  204.   /* 8. Show the new View: */
  205.   LoadView( &view );
  206.  
  207.  
  208.  
  209.   /* Playfield 2: */
  210.   /* Set the draw mode to JAM1. FgPen's colour will be used. */
  211.   SetDrMd( &rast_port2, JAM1 );
  212.   /* Use colour 9 (grey): */
  213.   SetAPen( &rast_port2, 9 );
  214.   /* Draw five grey boxes: */
  215.   for( loop = 0; loop < BOXES; loop++ )
  216.     RectFill( &rast_port2, box[ loop ][ 0 ], 
  217.                            box[ loop ][ 1 ],
  218.                            box[ loop ][ 2 ],
  219.                            box[ loop ][ 3 ] );
  220.  
  221.  
  222.   /* Playfield 1: */
  223.   /* Set the draw mode to JAM1. FgPen's colour will be used. */
  224.   SetDrMd( &rast_port1, JAM1 );
  225.   /* PF1: Draw 5000 pixels in four different colours, randomly. */ 
  226.   for( loop = 0; loop < 5000; loop++ )
  227.   {
  228.     /* Set FgPen's colour (0-3): */
  229.     SetAPen( &rast_port1, rand() % 4 );
  230.     /* Write a pixel somewere on the display: */
  231.     WritePixel( &rast_port1, rand() % RWIDTH1, rand() % RHEIGHT1 );
  232.   }
  233.  
  234.   /* Scroll the Raster (PF 1) in all directions for a little while: */
  235.   for( loop = 0; loop < 5000; loop++ )
  236.   {
  237.     ras_info1.RxOffset += deltaX;
  238.     ras_info1.RyOffset += deltaY;
  239.  
  240.     /* The Raster is moved in one direction until the other side is */
  241.     /* reached were we change the direction:                        */ 
  242.  
  243.     /* Have we reached the left side? */
  244.     if( ras_info1.RxOffset <= 0 )
  245.       deltaX = SPEED;
  246.     /* Have we reached the right (Raster width - Display width) side? */
  247.     if( ras_info1.RxOffset >= RWIDTH1 - DWIDTH )
  248.       deltaX = -SPEED;
  249.  
  250.     /* Have we reached the top side? */
  251.     if( ras_info1.RyOffset <= 0 )
  252.       deltaY = SPEED;
  253.     /* Have we reached the bottom (Raster height - Display height) side? */
  254.     if( ras_info1.RyOffset >= RHEIGHT1 - DHEIGHT )
  255.       deltaY = -SPEED;
  256.  
  257.  
  258.     /* Recalculate the display instructions: (If you change any values */
  259.     /* in the display structures the Amiga have to recalculate the     */
  260.     /* entire display instructions. You must therefore call all three  */
  261.     /* display functions: MakeVPort(), MrgCop() and LoadView().)       */
  262.     MakeVPort( &view, &view_port );
  263.     MrgCop( &view );
  264.     LoadView( &view );
  265.   }
  266.  
  267.  
  268.  
  269.   /* 9. Restore the old View: */
  270.   LoadView( old_view );
  271.  
  272.  
  273.   /* Free all allocated resources and leave. */
  274.   clean_up( "THE END" );
  275. }
  276.  
  277.  
  278. /* Returns all allocated resources: */
  279. void clean_up( message )
  280. STRPTR message;
  281. {
  282.   int loop;
  283.  
  284.   /* Free automatically allocated display structures: */
  285.   FreeVPortCopLists( &view_port );
  286.   FreeCprList( view.LOFCprList );
  287.   
  288.   /* Deallocate the display memory, BitPlane for BitPlane: */
  289.   /* Playfield 1: */
  290.   for( loop = 0; loop < DEPTH1; loop++ )
  291.     if( bit_map1.Planes[ loop ] )
  292.       FreeRaster( bit_map1.Planes[ loop ], RWIDTH1, RHEIGHT1 );
  293.   /* Playfield 2: */
  294.   for( loop = 0; loop < DEPTH2; loop++ )
  295.     if( bit_map2.Planes[ loop ] )
  296.       FreeRaster( bit_map2.Planes[ loop ], RWIDTH2, RHEIGHT2 );
  297.  
  298.   /* Deallocate the ColorMap: */
  299.   if( view_port.ColorMap ) FreeColorMap( view_port.ColorMap );
  300.  
  301.   /* Close the Graphics library: */
  302.   if( GfxBase ) CloseLibrary( GfxBase );
  303.  
  304.   /* Close the Intuition library: */
  305.   if( IntuitionBase ) CloseLibrary( IntuitionBase );
  306.  
  307.   /* Print the message and leave: */
  308.   printf( "%s\n", message ); 
  309.   exit();
  310. }
  311.