home *** CD-ROM | disk | FTP | other *** search
/ The Fred Fish Collection 1.5 / ffcollection-1-5-1992-11.iso / ff_progs / prog_oth / m2amiga.lzh / M2AMIGA / DEFS / GRAPHICS.DEF < prev    next >
Encoding:
Modula Definition  |  1991-08-16  |  20.1 KB  |  772 lines
  1. DEFINITION MODULE Graphics;
  2.  
  3. FROM SYSTEM IMPORT
  4.  ADDRESS,BITSET,BYTE,LONGSET,WORD;
  5. FROM Hardware IMPORT
  6.  bltnodePtr;
  7. FROM Exec IMPORT
  8.  Interrupt,Library,List,Message,MinList,Node,SignalSemaphore,
  9.  SignalSemaphorePtr,TaskPtr,UByte;
  10.  
  11. TYPE
  12.  AnimCompPtr=POINTER TO AnimComp;
  13.  AnimObPtr=POINTER TO AnimOb;
  14.  AreaInfoPtr=POINTER TO AreaInfo;
  15.  BitMapPtr=POINTER TO BitMap;
  16.  BobPtr=POINTER TO Bob;
  17.  ClipRectPtr=POINTER TO ClipRect;
  18.  CollTablePtr=POINTER TO CollTable;
  19.  ColorMapPtr=POINTER TO ColorMap;
  20.  CopinitPtr=POINTER TO Copinit;
  21.  CopInsPtr=POINTER TO CopIns;
  22.  CopListPtr=POINTER TO CopList;
  23.  CprlistPtr=POINTER TO Cprlist;
  24.  DBufPacketPtr=POINTER TO DBufPacket;
  25.  GelsInfoPtr=POINTER TO GelsInfo;
  26.  IsrvstrPtr=POINTER TO IsrvstrPtr;
  27.  LayerPtr=POINTER TO Layer;
  28.  LayerInfoPtr=POINTER TO LayerInfo;
  29.  RasInfoPtr=POINTER TO RasInfo;
  30.  RastPortPtr=POINTER TO RastPort;
  31.  RectanglePtr=POINTER TO Rectangle;
  32.  RegionPtr=POINTER TO Region;
  33.  RegionRectanglePtr=POINTER TO RegionRectangle;
  34.  SimpleSpritePtr=POINTER TO SimpleSprite;
  35.  TextAttrPtr=POINTER TO TextAttr;
  36.  TextFontPtr=POINTER TO TextFont;
  37.  TmpRasPtr=POINTER TO TmpRas;
  38.  UCopListPtr=POINTER TO UCopList;
  39.  ViewPtr=POINTER TO View;
  40.  ViewPortPtr=POINTER TO ViewPort;
  41.  VSpritePtr=POINTER TO VSprite;
  42.  
  43.  Rectangle=RECORD
  44.   minX: INTEGER;
  45.   minY: INTEGER;
  46.   maxX: INTEGER;
  47.   maxY: INTEGER;
  48.  END;
  49.  Layer=RECORD
  50.   front: LayerPtr;
  51.   back: LayerPtr;
  52.   clipRect: ClipRectPtr;
  53.   rp: RastPortPtr;
  54.   bounds: Rectangle;
  55.   reserved: ARRAY [0..3] OF BYTE;
  56.   priority: CARDINAL;
  57.   flags: CARDINAL;
  58.   superBitMap: BitMapPtr;
  59.   superClipRect: ClipRectPtr;
  60.   window: ADDRESS;
  61.   scrollX: INTEGER;
  62.   scrollY: INTEGER;
  63.   cr: ClipRectPtr;
  64.   cr2: ClipRectPtr;
  65.   crnew: ClipRectPtr;
  66.   superSaveClipRects: ClipRectPtr;
  67.   cliprects: ClipRectPtr;
  68.   layerInfo: LayerInfoPtr;
  69.   lock: SignalSemaphore;
  70.   reserved3: ARRAY [0..7] OF BYTE;
  71.   clipRegion: RegionPtr;
  72.   saveClipRects: RegionPtr;
  73.   reserved2: ARRAY [0..21] OF BYTE;
  74.   damageList: RegionPtr;
  75.  END;
  76.  ClipRect=RECORD
  77.   next: ClipRectPtr;
  78.   prev: ClipRectPtr;
  79.   lobs: LayerPtr;
  80.   bitMap: BitMapPtr;
  81.   bounds: Rectangle;
  82.   p1: ClipRectPtr;
  83.   p2: ClipRectPtr;
  84.   reserved: LONGINT;
  85.   flags: LONGINT;
  86.  END;
  87.  
  88. CONST
  89.  needsNoConcealedRasters=01H; 
  90.  isLessX=1;
  91.  isLessY=2;
  92.  isGrtrX=4;
  93.  isGrtrY=8;
  94. (* collision procedures are called as proc(gelptr,collMask); *)
  95.  borderHit=0;
  96.  topHit=1;
  97.  bottomHit=2;
  98.  leftHit=4;
  99.  rightHit=8;
  100.  
  101. CONST
  102. (* CopIns.opCode *)
  103.  move=0;
  104.  wait=1;
  105.  next=2;
  106. (* flags for CopIns.opCode *)
  107.  sht=14;
  108.  lof=15;
  109.  
  110. TYPE
  111.  CopIns=RECORD
  112.   CASE opCode: CARDINAL OF
  113.   | move:
  114.    destAddr: INTEGER;
  115.    destData: INTEGER;
  116.   | wait:
  117.    vWaitPos: INTEGER;
  118.    hWaitPos: INTEGER;
  119.   | next:
  120.    nxtlist: CopListPtr;
  121.   END;
  122.  END;
  123.  Cprlist=RECORD
  124.   next: CprlistPtr;
  125.   start: ADDRESS;
  126.   maxCount: INTEGER;
  127.  END;
  128.  CopList=RECORD
  129.   next: CopListPtr;
  130.   copList: CopListPtr;
  131.   viewPort: ViewPortPtr;
  132.   copIns: CopInsPtr;
  133.   copPtr: CopInsPtr;
  134.   copLStart: ADDRESS;
  135.   copSStart: ADDRESS;
  136.   count: INTEGER;
  137.   maxCount: INTEGER;
  138.   dyOffset: INTEGER;
  139.  END;
  140.  UCopList=RECORD
  141.   next: UCopListPtr;
  142.   firstCopList: CopListPtr;
  143.   copList: CopListPtr;
  144.  END;
  145.  Copinit=RECORD
  146.   diagstrt: ARRAY [0..3] OF CARDINAL;
  147.   sprstrtup: ARRAY [0..(2*8*2)+2+(2*2)+2-1] OF CARDINAL;
  148.   sprstop: ARRAY [0..1] OF CARDINAL;
  149.  END;
  150.  
  151. CONST
  152. (* display control register bplcon0,see <display.h> *)
  153.  interlace=04H;
  154.  pf2pri=40H;
  155.  colorOn=200H;
  156.  dblpf=400H;
  157.  holdnmodify=800H;
  158.  m640=08000H;
  159.  plnCntMsk=07H;
  160.  plnCntShft=12;
  161.  
  162.  fineScroll=0FH;
  163.  fineScrollShift=04H;
  164.  fineScrollMask=0FH;
  165.  vrtclPos=01FFH;
  166.  vrtclPosShift=07H;
  167.  horizPos=07FH;
  168.  dftchMask=0FFH;
  169.  vposrlof=08000H;
  170.  
  171.  ringtrigger=01H;
  172.  anfracsize=06H;
  173.  animhalf=020H;
  174.  
  175.  b2Norm=0;
  176.  b2Swap=1;
  177.  b2Bobber=2;
  178.  
  179. TYPE
  180.  VSpriteFlags=(vsprite,saveBack,overlay,mustDraw,vf4,vf5,vf6,vf7,backSaved,
  181.   bobUpdate,gelGone,vsOverflow);
  182.  VSpriteFlagSet=SET OF VSpriteFlags;
  183.  VSprite=RECORD
  184.   nextVSprite: VSpritePtr;
  185.   prevVSprite: VSpritePtr;
  186.   drawPath: VSpritePtr;
  187.   clearPath: VSpritePtr;
  188.   oldY: INTEGER;
  189.   oldX: INTEGER;
  190.   flags: VSpriteFlagSet;
  191.   y: INTEGER;
  192.   x: INTEGER;
  193.   height: INTEGER;
  194.   width: INTEGER;
  195.   depth: INTEGER;
  196.   meMask: BITSET;
  197.   hitMask: BITSET;
  198.   imageData: ADDRESS;
  199.   borderLine: ADDRESS;
  200.   collMask: ADDRESS;
  201.   sprColors: ADDRESS;
  202.   vsBob: BobPtr;
  203.   planePick: UByte;
  204.   planeOnOff: UByte;
  205.  END;
  206.  BobFlags=(saveBob,bobIsComp,bf2,bf3,bf4,bf5,bf6,bf7,bWaiting,bDrawn,bobsAway,
  207.   bobNix,savePreserve,outStep);
  208.  BobFlagSet=SET OF BobFlags;
  209.  Bob=RECORD
  210.   flags: BobFlagSet;
  211.   saveBuffer: ADDRESS;
  212.   imageShadow: ADDRESS;
  213.   before: BobPtr;
  214.   after: BobPtr;
  215.   bobVSprite: VSpritePtr;
  216.   bobComp: AnimCompPtr;
  217.   dBuffer: DBufPacketPtr;
  218.  END;
  219.  AnimComp=RECORD
  220.   flags: INTEGER;
  221.   timer: INTEGER;
  222.   timeSet: INTEGER;
  223.   nextComp: AnimCompPtr;
  224.   prevComp: AnimCompPtr;
  225.   nextSeq: AnimCompPtr;
  226.   prevSeq: AnimCompPtr;
  227.   animCRoutine: ADDRESS;
  228.   yTrans: INTEGER;
  229.   xTrans: INTEGER;
  230.   headOb: AnimObPtr;
  231.   animBob: BobPtr;
  232.  END;
  233.  AnimOb=RECORD
  234.   nextOb: AnimObPtr;
  235.   prevOb: AnimObPtr;
  236.   clock: LONGINT;
  237.   anOldY: INTEGER;
  238.   anOldX: INTEGER;
  239.   anY: INTEGER;
  240.   anX: INTEGER;
  241.   yVel: INTEGER;
  242.   xVel: INTEGER;
  243.   yAccel: INTEGER;
  244.   xAccel: INTEGER;
  245.   ringYTrans: INTEGER;
  246.   ringXTrans: INTEGER;
  247.   animORoutine: ADDRESS;
  248.   headComp: AnimCompPtr;
  249.  END;
  250.  DBufPacket=RECORD
  251.   bufY: INTEGER;
  252.   bufX: INTEGER;
  253.   bufPath: VSpritePtr;
  254.   bufBuffer: ADDRESS;
  255.  END;
  256.  CollTable=RECORD
  257.   collPtrs: ARRAY [0..15] OF ADDRESS
  258.  END;
  259.  BitMap=RECORD
  260.   bytesPerRow: CARDINAL;
  261.   rows: CARDINAL;
  262.   flags: UByte;
  263.   depth: UByte;
  264.   pad: CARDINAL;
  265.   planes: ARRAY [0..7] OF ADDRESS;
  266.  END;
  267.  GfxBase=RECORD
  268.   libNode: Library;
  269.   actiView: ViewPtr;
  270.   copinit: CopinitPtr;
  271.   cia: ADDRESS;
  272.   blitter: ADDRESS;
  273.   loFlist: ADDRESS;
  274.   shFlist: ADDRESS;
  275.   blthd: bltnodePtr;
  276.   blttl: bltnodePtr;
  277.   bsblthd: bltnodePtr;
  278.   bsblttl: bltnodePtr;
  279.   vbsrv: Interrupt;
  280.   timsrv: Interrupt;
  281.   bltsrv: Interrupt;
  282.   textFonts: List;
  283.   defaultFont: TextFontPtr;
  284.   modes: BITSET;
  285.   vBlank: UByte;
  286.   debug: BYTE;
  287.   beamSync: INTEGER;
  288.   bplcon0: BITSET;
  289.   spriteReserved: UByte;
  290.   bytereserved: BYTE;
  291.   flags: BITSET;
  292.   blitLock: INTEGER;
  293.   blitNest: INTEGER;
  294.   blitWaitQ: List;
  295.   blitOwner: TaskPtr;
  296.   waitQ: List;
  297.   displayFlags: BITSET;
  298.   simpleSprites: ADDRESS;
  299.   maxDisplayRow: CARDINAL;
  300.   maxDisplayColumn: CARDINAL;
  301.   normalDisplayRows: CARDINAL;
  302.   normalDisplayColumns: CARDINAL;
  303.   normalDPMX: CARDINAL;
  304.   normalDPMY: CARDINAL;
  305.   lastChanceMemory: SignalSemaphorePtr;
  306.   lcMptr: ADDRESS;
  307.   microsPerLine: CARDINAL;
  308.   reserved: ARRAY [0..1] OF LONGCARD;
  309.  END;
  310.  GfxBasePtr=POINTER TO GfxBase;
  311.  
  312. CONST
  313. (* GfxBase.displayFlags *)
  314.  ntsc=1;
  315.  genloc=2;
  316.  pal=4;
  317.  
  318.  blitMsgFault=4;
  319.  
  320. TYPE
  321.  Isrvstr=RECORD
  322.   node: Node;
  323.   iptr: IsrvstrPtr;
  324.   code: ADDRESS;
  325.   ccode: ADDRESS;
  326.   carg: INTEGER;
  327.  END;
  328.  LayerFlags=(layerSimple,layerSmart,layerSuper,lf3,layerUpdating,lf5,
  329.   layerBackdrop,layerRefresh,layerClipRectsLost);
  330.  LayerFlagSet=SET OF LayerFlags;
  331.  LayerInfo=RECORD
  332.   layer: LayerPtr;
  333.   lp: LayerPtr;
  334.   obs: LayerPtr;
  335.   freeClipRects: MinList;
  336.   lock: SignalSemaphore;
  337.   head: List;
  338.   longreserved: LONGINT;
  339.   flags: LayerFlagSet;
  340.   count: UByte;
  341.   lockLayersCount: UByte;
  342.   layerInfoExtraSize: CARDINAL;
  343.   blitbuff: ADDRESS;
  344.   layerInfoExtra: ADDRESS;
  345.  END;
  346.  
  347. CONST
  348.  lmnRegion=-1;
  349.  newLayerInfoCalled=01H;
  350.  alertLayersNoMem=083010000H;
  351.  
  352. TYPE
  353.  AreaInfo=RECORD
  354.   vctrTbl: ADDRESS;
  355.   vctrPtr: ADDRESS;
  356.   flagTbl: ADDRESS;
  357.   flagPtr: ADDRESS;
  358.   count: INTEGER;
  359.   maxCount: INTEGER;
  360.   firstX: INTEGER;
  361.   firstY: INTEGER;
  362.  END;
  363.  TmpRas=RECORD
  364.   rasPtr: ADDRESS;
  365.   size: LONGINT;
  366.  END;
  367.  GelsInfo=RECORD
  368.   sprRsrvd: BYTE;
  369.   flags: BYTE;
  370.   gelHead: VSpritePtr;
  371.   gelTail: VSpritePtr;
  372.   nextLine: ADDRESS;
  373.   lastColor: ADDRESS;
  374.   collHandler: CollTablePtr;
  375.   leftmost: INTEGER;
  376.   rightmost: INTEGER;
  377.   topmost: INTEGER;
  378.   bottommost: INTEGER;
  379.   firstBlissObj: ADDRESS;
  380.   lastBlissObj: ADDRESS;
  381.  END;
  382.  DrawModes=(dm0,complement,inversvid);
  383.  DrawModeSet=SET OF DrawModes;
  384.  FontStyles=(underlined,bold,italic,extended);
  385.  FontStyleSet=SET OF FontStyles;
  386.  FontFlags=(romFont,diskFont,revPath,tallDot,wideDot,proportional,
  387.   designed,removed);
  388.  FontFlagSet=SET OF FontFlags;
  389.  RastPortFlags=(firstDot,oneDot,dBuffer,areaOutline,rpf4,noCrossFill,
  390.   rpf6,rpf7,rpf8);
  391.  RastPortFlagSet=SET OF RastPortFlags;
  392.  RastPort=RECORD
  393.   layer: LayerPtr;
  394.   bitMap: BitMapPtr;
  395.   areaPtrn: ADDRESS;
  396.   tmpRas: TmpRasPtr;
  397.   areaInfo: AreaInfoPtr;
  398.   gelsInfo: GelsInfoPtr;
  399.   mask: UByte;
  400.   fgPen: UByte;
  401.   bgPen: UByte;
  402.   aOlPen: UByte;
  403.   drawMode: DrawModeSet;
  404.   areaPtSz: UByte;
  405.   linPatCnt: UByte;
  406.   dummy: BYTE;
  407.   flags: RastPortFlagSet;
  408.   linePtrn: CARDINAL;
  409.   x: INTEGER;
  410.   y: INTEGER;
  411.   minterms: ARRAY [0..7] OF BYTE;
  412.   penWidth: INTEGER;
  413.   penHeight: INTEGER;
  414.   font: TextFontPtr;
  415.   algoStyle: FontStyleSet;
  416.   txFlags: FontFlagSet;
  417.   txHeight: CARDINAL;
  418.   txWidth: CARDINAL;
  419.   txBaseline: CARDINAL;
  420.   txSpacing: INTEGER;
  421.   user: ADDRESS;
  422.   longreserved: ARRAY [0..1] OF LONGINT;
  423.   wordreserved: ARRAY [0..6] OF WORD;
  424.   reserved: ARRAY [0..7] OF BYTE;
  425.  END;
  426.  
  427. CONST
  428.  jam1=DrawModeSet{};
  429.  jam2=DrawModeSet{dm0};
  430.  spriteAttached=080H;
  431.  normalFont=FontStyleSet{};
  432.  
  433. TYPE
  434.  RegionRectangle=RECORD
  435.   next: RegionRectanglePtr;
  436.   prev: RegionRectanglePtr;
  437.   bounds: Rectangle;
  438.  END;
  439.  Region=RECORD
  440.   bounds: Rectangle;
  441.   regionRectangle: RegionRectanglePtr;
  442.  END;
  443.  SimpleSprite=RECORD
  444.   posctldata: ADDRESS;
  445.   height: CARDINAL;
  446.   x: CARDINAL;
  447.   y: CARDINAL;
  448.   num: CARDINAL;
  449.  END;
  450.  TextAttr=RECORD
  451.   name: ADDRESS;
  452.   ySize: CARDINAL;
  453.   style: FontStyleSet;
  454.   flags: FontFlagSet;
  455.  END;
  456.  TextFont=RECORD
  457.   message: Message;
  458.   ySize: CARDINAL;
  459.   style: FontStyleSet;
  460.   flags: FontFlagSet;
  461.   xSize: CARDINAL;
  462.   baseline: CARDINAL;
  463.   boldSmear: CARDINAL;
  464.   accessors: CARDINAL;
  465.   loChar: CHAR;
  466.   hiChar: CHAR;
  467.   charData: ADDRESS;
  468.   modulo: CARDINAL;
  469.   charLoc: ADDRESS;
  470.   charSpace: ADDRESS;
  471.   charKern: ADDRESS;
  472.  END;
  473.  ColorMap=RECORD
  474.   flags: UByte;
  475.   type: UByte ;
  476.   count: CARDINAL;
  477.   colorTable: ADDRESS;
  478.  END;
  479.  ViewModes=(vm0,genlocVideo,lace,vm3,vm4,vm5,pfba,extraHalfbrite,genlocAudio,
  480.   vm9,dualpf,ham,vm12,vpHide,sprites,hires);
  481.  ViewModeSet=SET OF ViewModes;
  482.  ViewPort=RECORD
  483.   next: ViewPortPtr;
  484.   colorMap: ColorMapPtr;
  485.   dspIns: CopListPtr;
  486.   sprIns: CopListPtr;
  487.   clrIns: CopListPtr;
  488.   uCopIns: UCopListPtr;
  489.   dWidth: INTEGER;
  490.   dHeight: INTEGER;
  491.   dxOffset: INTEGER;
  492.   dyOffset: INTEGER;
  493.   modes: ViewModeSet;
  494.   reserved: CARDINAL;
  495.   rasInfo: RasInfoPtr;
  496.  END;
  497.  View=RECORD
  498.   viewPort: ViewPortPtr;
  499.   lofCprList: CprlistPtr;
  500.   shfCprList: CprlistPtr;
  501.   dyOffset: INTEGER;
  502.   dxOffset: INTEGER;
  503.   modes: ViewModeSet;
  504.  END;
  505.  RasInfo=RECORD
  506.   next: RasInfoPtr;
  507.   bitMap: BitMapPtr;
  508.   rxOffset: INTEGER;
  509.   ryOffset: INTEGER;
  510.  END;
  511.  
  512. PROCEDURE AddAnimOb(anOb: AnimObPtr;
  513.                     anKey: ADDRESS;
  514.                     rp: RastPortPtr);
  515. PROCEDURE AddBob(Bob: BobPtr;
  516.                  rp: RastPortPtr);
  517. PROCEDURE AddFont(textFont: TextFontPtr);
  518. PROCEDURE AddVSprite(vs: VSpritePtr;
  519.                      rp: RastPortPtr);
  520. PROCEDURE AllocRaster(width: CARDINAL;
  521.                       height: CARDINAL): ADDRESS;
  522. PROCEDURE AndRectRegion(region: RegionPtr;
  523.                         rectangle: RectanglePtr);
  524. PROCEDURE AndRegionRegion(region1: RegionPtr;
  525.                           region2: RegionPtr): BOOLEAN;
  526. PROCEDURE Animate(anKey: ADDRESS; rp: RastPortPtr);
  527. PROCEDURE AreaDraw(rp: RastPortPtr;
  528.                    x: INTEGER;
  529.                    y: INTEGER): LONGINT;
  530. PROCEDURE AreaEllipse(rp: RastPortPtr;
  531.                       cX: INTEGER;
  532.                       cY: INTEGER;
  533.                       a: INTEGER;
  534.                       b: INTEGER): LONGINT;
  535. PROCEDURE AreaEnd(rp: RastPortPtr): LONGINT;
  536. PROCEDURE AreaMove(rp: RastPortPtr;
  537.                    x: INTEGER;
  538.                    y: INTEGER): LONGINT;
  539. PROCEDURE AskFont(rp: RastPortPtr;
  540.                   textAttr: TextAttrPtr);
  541. PROCEDURE AskSoftStyle(rp: RastPortPtr): FontStyleSet;
  542. PROCEDURE AttemptLockLayerRom(layer: LayerPtr): BOOLEAN;
  543. PROCEDURE BltBitMap(srcBitMap: BitMapPtr;
  544.                     srcX: INTEGER;
  545.                     srcY: INTEGER;
  546.                     dstBitMap: BitMapPtr;
  547.                     dstX: INTEGER;
  548.                     dstY: INTEGER;
  549.                     sizeX: INTEGER;
  550.                     sizeY: INTEGER;
  551.                     minterm: BYTE;
  552.                     mask: BYTE;
  553.                     tempA: ADDRESS): LONGCARD;
  554. PROCEDURE BltBitMapRastPort(srcbm: BitMapPtr;
  555.                             srcX: INTEGER;
  556.                             srcY: INTEGER;
  557.                             destRp: RastPortPtr;
  558.                             destX: INTEGER;
  559.                             destY: INTEGER;
  560.                             sizeX: INTEGER;
  561.                             sizeY: INTEGER;
  562.                             minterm: BYTE);
  563. PROCEDURE BltClear(memBlock: ADDRESS;
  564.                    bytecount: LONGCARD;
  565.                    flags: LONGCARD);
  566. PROCEDURE BltMaskBitMapRastPort(srcbm: BitMapPtr;
  567.                                 srcX: INTEGER;
  568.                                 srcY: INTEGER;
  569.                                 destRp: RastPortPtr;
  570.                                 destX: INTEGER;
  571.                                 destY: INTEGER;
  572.                                 sizeX: INTEGER;
  573.                                 sizeY: INTEGER;
  574.                                 minterm: BYTE;
  575.                                 bltmask: ADDRESS);
  576. PROCEDURE BltPattern(rp: RastPortPtr;
  577.                      mask: ADDRESS;
  578.                      xl: INTEGER;
  579.                      yl: INTEGER;
  580.                      maxX: INTEGER;
  581.                      maxY: INTEGER;
  582.                      bytecnt: INTEGER);
  583. PROCEDURE BltTemplate(srcTemplate: ADDRESS;
  584.                       srcX: INTEGER;
  585.                       srcMod: INTEGER;
  586.                       rp: RastPortPtr;
  587.                       dstX: INTEGER;
  588.                       dstY: INTEGER;
  589.                       sizeX: INTEGER;
  590.                       sizeY: INTEGER);
  591. PROCEDURE CBump(c: UCopListPtr);
  592. PROCEDURE ChangeSprite(vp: ViewPortPtr;
  593.                        s: SimpleSpritePtr;
  594.                        newdata: ADDRESS);
  595. PROCEDURE ClearEOL(rp: RastPortPtr);
  596. PROCEDURE ClearRectRegion(region: RegionPtr;
  597.                           rectangle: RectanglePtr): LONGINT;
  598. PROCEDURE ClearRegion(region: RegionPtr);
  599. PROCEDURE ClearScreen(rp: RastPortPtr);
  600. PROCEDURE ClipBlit(src: RastPortPtr;
  601.                    srcX: INTEGER;
  602.                    srcY: INTEGER;
  603.                    dest: RastPortPtr;
  604.                    destX: INTEGER;
  605.                    destY: INTEGER;
  606.                    xSize: INTEGER;
  607.                    ySize: INTEGER;
  608.                    minterm: BYTE);
  609. PROCEDURE CloseFont(font: TextFontPtr);
  610. PROCEDURE CMove(c: UCopListPtr;
  611.                 a: ADDRESS;
  612.                 v: INTEGER);
  613. PROCEDURE CopySBitMap(layer: LayerPtr);
  614. PROCEDURE CWait(c: UCopListPtr;
  615.                 v: INTEGER;
  616.                 h: INTEGER);
  617. PROCEDURE DisownBlitter();
  618. PROCEDURE DisposeRegion(region: RegionPtr);
  619. PROCEDURE DoCollision(rp: RastPortPtr);
  620. PROCEDURE Draw(rp: RastPortPtr;
  621.                x: INTEGER;
  622.                y: INTEGER);
  623. PROCEDURE DrawEllipse(rp: RastPortPtr;
  624.                       cX: INTEGER;
  625.                       cY: INTEGER;
  626.                       a: INTEGER;
  627.                       b: INTEGER);
  628. PROCEDURE DrawGList(rp: RastPortPtr;
  629.                     vp: ViewPortPtr);
  630. PROCEDURE Flood(rp: RastPortPtr;
  631.                 mode: LONGCARD;
  632.                 x: INTEGER;
  633.                 y: INTEGER): LONGINT;
  634. PROCEDURE FreeColorMap(colorMap: ColorMapPtr);
  635. PROCEDURE FreeCopList(coplist: CopListPtr);
  636. PROCEDURE FreeCprList(cprlist: CprlistPtr);
  637. PROCEDURE FreeGBuffers(anOb: AnimObPtr;
  638.                        rp: RastPortPtr;
  639.                        db: BOOLEAN);
  640. PROCEDURE FreeRaster(p: ADDRESS;
  641.                      width: CARDINAL;
  642.                      height: CARDINAL);
  643. PROCEDURE FreeSprite(pick: INTEGER);
  644. PROCEDURE FreeVPortCopLists(vp: ViewPortPtr);
  645. PROCEDURE GetColorMap(entries: LONGINT): ColorMapPtr;
  646. PROCEDURE GetGBuffers(anOb: AnimObPtr;
  647.                       rp: RastPortPtr;
  648.                       db: BOOLEAN): BOOLEAN;
  649. PROCEDURE GetRGB4(colorMap: ColorMapPtr;
  650.                   entry: LONGINT): LONGCARD;
  651. PROCEDURE GetSprite(sprite: SimpleSpritePtr;
  652.                     pick: INTEGER): INTEGER;
  653. (*PRIVATE*) PROCEDURE GraphicsReserved1(): LONGINT;
  654. (*PRIVATE*) PROCEDURE GraphicsReserved2(): LONGINT;
  655. PROCEDURE InitArea(VAR areainfo: AreaInfo;
  656.                    buffer: ADDRESS;
  657.                    maxvectors: INTEGER);
  658. PROCEDURE InitBitMap(VAR bm: BitMap;
  659.                      depth: INTEGER;
  660.              width: INTEGER;
  661.                      height: INTEGER);
  662. PROCEDURE InitGels(head: VSpritePtr;
  663.                    tail: VSpritePtr;
  664.                    gInfo: GelsInfoPtr);
  665. PROCEDURE InitGMasks(anOb: AnimObPtr);
  666. PROCEDURE InitMasks(vs: VSpritePtr);
  667. PROCEDURE InitRastPort(VAR rp: RastPort);
  668. PROCEDURE InitTmpRas(VAR tmpras: TmpRas;
  669.                      buffer: ADDRESS;
  670.                      size: LONGINT);
  671. PROCEDURE InitView(VAR view: View);
  672. PROCEDURE InitVPort(VAR vp: ViewPort);
  673. PROCEDURE LoadRGB4(vp: ViewPortPtr;
  674.                    colors: ADDRESS;
  675.                    count: INTEGER);
  676. PROCEDURE LoadView(view: ViewPtr);
  677. PROCEDURE LockLayerRom(layer: LayerPtr);
  678. PROCEDURE MakeVPort(view: ViewPtr;
  679.                     viewport: ViewPortPtr);
  680. PROCEDURE Move(rp: RastPortPtr;
  681.                x: INTEGER;
  682.                y: INTEGER);
  683. PROCEDURE MoveSprite(vp: ViewPortPtr;
  684.                      sprite: SimpleSpritePtr;
  685.                      x: INTEGER;
  686.                      y: INTEGER);
  687. PROCEDURE MrgCop(view: ViewPtr);
  688. PROCEDURE NewRegion(): RegionPtr;
  689. PROCEDURE OpenFont(textAttr: TextAttrPtr): TextFontPtr;
  690. PROCEDURE OrRectRegion(region: RegionPtr;
  691.                        rectangle: RectanglePtr): LONGINT;
  692. PROCEDURE OrRegionRegion(region1: RegionPtr;
  693.                          region2: RegionPtr): LONGINT;
  694. PROCEDURE OwnBlitter();
  695. PROCEDURE PolyDraw(rp: RastPortPtr;
  696.                    count: INTEGER;
  697.                    array: ADDRESS);
  698. PROCEDURE QBlit(bp: bltnodePtr);
  699. PROCEDURE QBSBlit(bsp: bltnodePtr);
  700. PROCEDURE ReadPixel(rp: RastPortPtr;
  701.                     x: INTEGER;
  702.                     y: INTEGER): LONGINT;
  703. PROCEDURE RectFill(rp: RastPortPtr;
  704.                    xMin: INTEGER;
  705.                    yMin: INTEGER;
  706.                    xMax: INTEGER;
  707.                    yMax: INTEGER);
  708. PROCEDURE RemFont(textFont: TextFontPtr);
  709. PROCEDURE RemIBob(bob: BobPtr;
  710.                   rp: RastPortPtr;
  711.                   vp: ViewPortPtr);
  712. PROCEDURE RemVSprite(vs: VSpritePtr);
  713. PROCEDURE ScrollRaster(rp: RastPortPtr;
  714.                        dx: INTEGER;
  715.                        dy: INTEGER;
  716.                        xMin: INTEGER;
  717.                        yMin: INTEGER;
  718.                        xMax: INTEGER;
  719.                        yMax: INTEGER);
  720. PROCEDURE ScrollVPort(vp: ViewPortPtr);
  721. PROCEDURE SetAPen(rp: RastPortPtr;
  722.                   pen: CARDINAL);
  723. PROCEDURE SetBPen(rp: RastPortPtr;
  724.                   pen: CARDINAL);
  725. PROCEDURE SetCollision(num: LONGCARD;
  726.                        routine: PROC;
  727.                        gInfo: GelsInfoPtr);
  728. PROCEDURE SetDrMd(rp: RastPortPtr;
  729.                   mode: DrawModeSet);
  730. PROCEDURE SetFont(rp: RastPortPtr;
  731.                   font: TextFontPtr);
  732. PROCEDURE SetRast(rp: RastPortPtr;
  733.                   pen: CARDINAL);
  734. PROCEDURE SetRGB4(vp: ViewPortPtr;
  735.                   n: CARDINAL;
  736.                   r: CARDINAL;
  737.                   g: CARDINAL;
  738.                   b: CARDINAL);
  739. PROCEDURE SetRGB4CM(cm: ColorMapPtr;
  740.                     n: CARDINAL;
  741.                     r: CARDINAL;
  742.                     g: CARDINAL;
  743.                     b: CARDINAL);
  744. PROCEDURE SetSoftStyle(rp: RastPortPtr;
  745.                        style: FontStyleSet;
  746.                        enable: FontStyleSet): FontStyleSet;
  747. PROCEDURE SortGList(rp: RastPortPtr);
  748. PROCEDURE SyncSBitMap(layer: LayerPtr);
  749. PROCEDURE Text(rp: RastPortPtr;
  750.                string: ADDRESS;
  751.                count: INTEGER);
  752. PROCEDURE TextLength(rp: RastPortPtr;
  753.                      string: ADDRESS;
  754.                      count: INTEGER): INTEGER;
  755. PROCEDURE UCopperListInit(copperList: UCopListPtr;
  756.                           num: LONGINT);
  757.  
  758. PROCEDURE UnlockLayerRom(layer: LayerPtr);
  759. PROCEDURE VBeamPos(): LONGINT;
  760. PROCEDURE WaitBlit();
  761. PROCEDURE WaitBOVP(vp: ViewPortPtr);
  762. PROCEDURE WaitTOF();
  763. PROCEDURE WritePixel(rp: RastPortPtr;
  764.                      x: INTEGER;
  765.                      y: INTEGER): LONGINT;
  766. PROCEDURE XorRectRegion(region: RegionPtr;
  767.                         rectangle: RectanglePtr): LONGINT;
  768. PROCEDURE XorRegionRegion(region1: RegionPtr;
  769.                           region2: RegionPtr): LONGINT;
  770.  
  771. END Graphics.
  772.