home *** CD-ROM | disk | FTP | other *** search
/ Amiga Format CD 28 / amigaformatcd28.iso / -screenplay- / otherstuff / adoomppc_src / cybergraphics_pragmas.h < prev    next >
C/C++ Source or Header  |  1998-04-23  |  15KB  |  454 lines
  1. #ifndef _PPCPRAGMA_CYBERGRAPHICS_H
  2. #define _PPCPRAGMA_CYBERGRAPHICS_H
  3.  
  4. #ifdef __GNUC__
  5. #ifndef _PPCINLINE__CYBERGRAPHICS_H
  6. #include <powerup/ppcinline/cybergraphics.h>
  7. #endif
  8. #else
  9.  
  10. #ifndef POWERUP_PPCLIB_INTERFACE_H
  11. #include <powerup/ppclib/interface.h>
  12. #endif
  13.  
  14. #ifndef POWERUP_GCCLIB_PROTOS_H
  15. #include <powerup/gcclib/powerup_protos.h>
  16. #endif
  17.  
  18. #ifndef NO_PPCINLINE_STDARG
  19. #define NO_PPCINLINE_STDARG
  20. #endif/* SAS C PPC inlines */
  21.  
  22. #ifndef CYBERGFX_BASE_NAME
  23. #define CYBERGFX_BASE_NAME CyberGfxBase
  24. #endif /* !CYBERGFX_BASE_NAME */
  25.  
  26. #define AllocCModeListTagList(tagList) _AllocCModeListTagList(CYBERGFX_BASE_NAME, tagList)
  27.  
  28. static __inline struct List *
  29. _AllocCModeListTagList(void *CyberGfxBase, struct TagItem *tagList)
  30. {
  31. struct Caos    MyCaos;
  32.     MyCaos.M68kCacheMode        =    IF_CACHEFLUSHALL;
  33. //    MyCaos.M68kStart        =    NULL;
  34. //    MyCaos.M68kSize            =    0;
  35.     MyCaos.PPCCacheMode        =    IF_CACHEFLUSHALL;
  36. //    MyCaos.PPCStart            =    NULL;
  37. //    MyCaos.PPCSize            =    0;
  38.     MyCaos.a1            =    (ULONG) tagList;
  39.     MyCaos.caos_Un.Offset        =    (-0x48);
  40.     MyCaos.a6            =    (ULONG) CyberGfxBase;
  41.     return((APTR)PPCCallOS(&MyCaos));
  42. }
  43.  
  44. #ifndef NO_PPCINLINE_STDARG
  45. #define AllocCModeListTags(tags...) \
  46.     ({ULONG _tags[] = { tags }; AllocCModeListTagList((struct TagItem *)_tags);})
  47. #endif /* !NO_PPCINLINE_STDARG */
  48.  
  49. #define BestCModeIDTagList(tagList) _BestCModeIDTagList(CYBERGFX_BASE_NAME, tagList)
  50.  
  51. static __inline ULONG
  52. _BestCModeIDTagList(void *CyberGfxBase, struct TagItem *tagList)
  53. {
  54. struct Caos    MyCaos;
  55.     MyCaos.M68kCacheMode        =    IF_CACHEFLUSHALL;
  56. //    MyCaos.M68kStart        =    NULL;
  57. //    MyCaos.M68kSize            =    0;
  58.     MyCaos.PPCCacheMode        =    IF_CACHEFLUSHALL;
  59. //    MyCaos.PPCStart            =    NULL;
  60. //    MyCaos.PPCSize            =    0;
  61.     MyCaos.a0            =    (ULONG) tagList;
  62.     MyCaos.caos_Un.Offset        =    (-0x3c);
  63.     MyCaos.a6            =    (ULONG) CyberGfxBase;
  64.     return((ULONG)PPCCallOS(&MyCaos));
  65. }
  66.  
  67. #ifndef NO_PPCINLINE_STDARG
  68. #define BestCModeIDTags(tags...) \
  69.     ({ULONG _tags[] = { tags }; BestCModeIDTagList((struct TagItem *)_tags);})
  70. #endif /* !NO_PPCINLINE_STDARG */
  71.  
  72. #define CModeRequestTagList(requester, tagList) _CModeRequestTagList(CYBERGFX_BASE_NAME, requester, tagList)
  73.  
  74. static __inline ULONG
  75. _CModeRequestTagList(void *CyberGfxBase, struct Requester *requester, struct TagItem *tagList)
  76. {
  77. struct Caos    MyCaos;
  78.     MyCaos.M68kCacheMode        =    IF_CACHEFLUSHALL;
  79. //    MyCaos.M68kStart        =    NULL;
  80. //    MyCaos.M68kSize            =    0;
  81.     MyCaos.PPCCacheMode        =    IF_CACHEFLUSHALL;
  82. //    MyCaos.PPCStart            =    NULL;
  83. //    MyCaos.PPCSize            =    0;
  84.     MyCaos.a0            =    (ULONG) requester;
  85.     MyCaos.a1            =    (ULONG) tagList;
  86.     MyCaos.caos_Un.Offset        =    (-0x42);
  87.     MyCaos.a6            =    (ULONG) CyberGfxBase;
  88.     return((ULONG)PPCCallOS(&MyCaos));
  89. }
  90.  
  91. #ifndef NO_PPCINLINE_STDARG
  92. #define CModeRequestTags(a0, tags...) \
  93.     ({ULONG _tags[] = { tags }; CModeRequestTagList((a0), (struct TagItem *)_tags);})
  94. #endif /* !NO_PPCINLINE_STDARG */
  95.  
  96. #define CVideoCtrlTagList(viewPort, tagList) _CVideoCtrlTagList(CYBERGFX_BASE_NAME, viewPort, tagList)
  97.  
  98. static __inline void
  99. _CVideoCtrlTagList(void *CyberGfxBase, struct ViewPort *viewPort, struct TagItem *tagList)
  100. {
  101. struct Caos    MyCaos;
  102.     MyCaos.M68kCacheMode        =    IF_CACHEFLUSHALL;
  103. //    MyCaos.M68kStart        =    NULL;
  104. //    MyCaos.M68kSize            =    0;
  105.     MyCaos.PPCCacheMode        =    IF_CACHEFLUSHALL;
  106. //    MyCaos.PPCStart            =    NULL;
  107. //    MyCaos.PPCSize            =    0;
  108.     MyCaos.a0            =    (ULONG) viewPort;
  109.     MyCaos.a1            =    (ULONG) tagList;
  110.     MyCaos.caos_Un.Offset        =    (-0xa2);
  111.     MyCaos.a6            =    (ULONG) CyberGfxBase;
  112.     PPCCallOS(&MyCaos);
  113. }
  114.  
  115. #ifndef NO_PPCINLINE_STDARG
  116. #define CVideoCtrlTags(a0, tags...) \
  117.     ({ULONG _tags[] = { tags }; CVideoCtrlTagList((a0), (struct TagItem *)_tags);})
  118. #endif /* !NO_PPCINLINE_STDARG */
  119.  
  120. #define DoCDrawMethodTagList(hook, rastPort, tagList) _DoCDrawMethodTagList(CYBERGFX_BASE_NAME, hook, rastPort, tagList)
  121.  
  122. static __inline void
  123. _DoCDrawMethodTagList(void *CyberGfxBase, struct Hook *hook, struct RastPort *rastPort, struct TagItem *tagList)
  124. {
  125. struct Caos    MyCaos;
  126.     MyCaos.M68kCacheMode        =    IF_CACHEFLUSHALL;
  127. //    MyCaos.M68kStart        =    NULL;
  128. //    MyCaos.M68kSize            =    0;
  129.     MyCaos.PPCCacheMode        =    IF_CACHEFLUSHALL;
  130. //    MyCaos.PPCStart            =    NULL;
  131. //    MyCaos.PPCSize            =    0;
  132.     MyCaos.a0            =    (ULONG) hook;
  133.     MyCaos.a1            =    (ULONG) rastPort;
  134.     MyCaos.a2            =    (ULONG) tagList;
  135.     MyCaos.caos_Un.Offset        =    (-0x9c);
  136.     MyCaos.a6            =    (ULONG) CyberGfxBase;
  137.     PPCCallOS(&MyCaos);
  138. }
  139.  
  140. #ifndef NO_PPCINLINE_STDARG
  141. #define DoCDrawMethodTags(a0, a1, tags...) \
  142.     ({ULONG _tags[] = { tags }; DoCDrawMethodTagList((a0), (a1), (struct TagItem *)_tags);})
  143. #endif /* !NO_PPCINLINE_STDARG */
  144.  
  145. #define FillPixelArray(rastPort, destX, destY, sizeX, sizeY, ARGB) _FillPixelArray(CYBERGFX_BASE_NAME, rastPort, destX, destY, sizeX, sizeY, ARGB)
  146.  
  147. static __inline ULONG
  148. _FillPixelArray(void *CyberGfxBase, struct RastPort *rastPort, UWORD destX, UWORD destY, UWORD sizeX, UWORD sizeY, ULONG ARGB)
  149. {
  150. struct Caos    MyCaos;
  151.     MyCaos.M68kCacheMode        =    IF_CACHEFLUSHALL;
  152. //    MyCaos.M68kStart        =    NULL;
  153. //    MyCaos.M68kSize            =    0;
  154.     MyCaos.PPCCacheMode        =    IF_CACHEFLUSHALL;
  155. //    MyCaos.PPCStart            =    NULL;
  156. //    MyCaos.PPCSize            =    0;
  157.     MyCaos.d0            =    (ULONG) destX;
  158.     MyCaos.d1            =    (ULONG) destY;
  159.     MyCaos.d2            =    (ULONG) sizeX;
  160.     MyCaos.d3            =    (ULONG) sizeY;
  161.     MyCaos.d4            =    ARGB;
  162.     MyCaos.a1            =    (ULONG) rastPort;
  163.     MyCaos.caos_Un.Offset        =    (-0x96);
  164.     MyCaos.a6            =    (ULONG) CyberGfxBase;
  165.     return((ULONG)PPCCallOS(&MyCaos));
  166. }
  167.  
  168. #define FreeCModeList(modeList) _FreeCModeList(CYBERGFX_BASE_NAME, modeList)
  169.  
  170. static __inline void
  171. _FreeCModeList(void *CyberGfxBase, struct List *modeList)
  172. {
  173. struct Caos    MyCaos;
  174.     MyCaos.M68kCacheMode        =    IF_CACHEFLUSHALL;
  175. //    MyCaos.M68kStart        =    NULL;
  176. //    MyCaos.M68kSize            =    0;
  177.     MyCaos.PPCCacheMode        =    IF_CACHEFLUSHALL;
  178. //    MyCaos.PPCStart            =    NULL;
  179. //    MyCaos.PPCSize            =    0;
  180.     MyCaos.a0            =    (ULONG) modeList;
  181.     MyCaos.caos_Un.Offset        =    (-0x4e);
  182.     MyCaos.a6            =    (ULONG) CyberGfxBase;
  183.     PPCCallOS(&MyCaos);
  184. }
  185.  
  186. #define GetCyberIDAttr(attribute, displayModeID) _GetCyberIDAttr(CYBERGFX_BASE_NAME, attribute, displayModeID)
  187.  
  188. static __inline ULONG
  189. _GetCyberIDAttr(void *CyberGfxBase, ULONG attribute, ULONG displayModeID)
  190. {
  191. struct Caos    MyCaos;
  192.     MyCaos.M68kCacheMode        =    IF_CACHEFLUSHALL;
  193. //    MyCaos.M68kStart        =    NULL;
  194. //    MyCaos.M68kSize            =    0;
  195.     MyCaos.PPCCacheMode        =    IF_CACHEFLUSHALL;
  196. //    MyCaos.PPCStart            =    NULL;
  197. //    MyCaos.PPCSize            =    0;
  198.     MyCaos.d0            =    attribute;
  199.     MyCaos.d1            =    displayModeID;
  200.     MyCaos.caos_Un.Offset        =    (-0x66);
  201.     MyCaos.a6            =    (ULONG) CyberGfxBase;
  202.     return((ULONG)PPCCallOS(&MyCaos));
  203. }
  204.  
  205. #define GetCyberMapAttr(bitMap, attribute) _GetCyberMapAttr(CYBERGFX_BASE_NAME, bitMap, attribute)
  206.  
  207. static __inline ULONG
  208. _GetCyberMapAttr(void *CyberGfxBase, struct BitMap *bitMap, ULONG attribute)
  209. {
  210. struct Caos    MyCaos;
  211.     MyCaos.M68kCacheMode        =    IF_CACHEFLUSHALL;
  212. //    MyCaos.M68kStart        =    NULL;
  213. //    MyCaos.M68kSize            =    0;
  214.     MyCaos.PPCCacheMode        =    IF_CACHEFLUSHALL;
  215. //    MyCaos.PPCStart            =    NULL;
  216. //    MyCaos.PPCSize            =    0;
  217.     MyCaos.d1            =    attribute;
  218.     MyCaos.a0            =    (ULONG) bitMap;
  219.     MyCaos.caos_Un.Offset        =    (-0x60);
  220.     MyCaos.a6            =    (ULONG) CyberGfxBase;
  221.     return((ULONG)PPCCallOS(&MyCaos));
  222. }
  223.  
  224. #define InvertPixelArray(rastPort, destX, destY, sizeX, sizeY) _InvertPixelArray(CYBERGFX_BASE_NAME, rastPort, destX, destY, sizeX, sizeY)
  225.  
  226. static __inline ULONG
  227. _InvertPixelArray(void *CyberGfxBase, struct RastPort *rastPort, UWORD destX, UWORD destY, UWORD sizeX, UWORD sizeY)
  228. {
  229. struct Caos    MyCaos;
  230.     MyCaos.M68kCacheMode        =    IF_CACHEFLUSHALL;
  231. //    MyCaos.M68kStart        =    NULL;
  232. //    MyCaos.M68kSize            =    0;
  233.     MyCaos.PPCCacheMode        =    IF_CACHEFLUSHALL;
  234. //    MyCaos.PPCStart            =    NULL;
  235. //    MyCaos.PPCSize            =    0;
  236.     MyCaos.d0            =    (ULONG) destX;
  237.     MyCaos.d1            =    (ULONG) destY;
  238.     MyCaos.d2            =    (ULONG) sizeX;
  239.     MyCaos.d3            =    (ULONG) sizeY;
  240.     MyCaos.a1            =    (ULONG) rastPort;
  241.     MyCaos.caos_Un.Offset        =    (-0x90);
  242.     MyCaos.a6            =    (ULONG) CyberGfxBase;
  243.     return((ULONG)PPCCallOS(&MyCaos));
  244. }
  245.  
  246. #define IsCyberModeID(displayModeID) _IsCyberModeID(CYBERGFX_BASE_NAME, displayModeID)
  247.  
  248. static __inline BOOL
  249. _IsCyberModeID(void *CyberGfxBase, ULONG displayModeID)
  250. {
  251. struct Caos    MyCaos;
  252.     MyCaos.M68kCacheMode        =    IF_CACHEFLUSHALL;
  253. //    MyCaos.M68kStart        =    NULL;
  254. //    MyCaos.M68kSize            =    0;
  255.     MyCaos.PPCCacheMode        =    IF_CACHEFLUSHALL;
  256. //    MyCaos.PPCStart            =    NULL;
  257. //    MyCaos.PPCSize            =    0;
  258.     MyCaos.d0            =    displayModeID;
  259.     MyCaos.caos_Un.Offset        =    (-0x36);
  260.     MyCaos.a6            =    (ULONG) CyberGfxBase;
  261.     return((BOOL)PPCCallOS(&MyCaos));
  262. }
  263.  
  264. #define LockBitMapTagList(bitMap, tagList) _LockBitMapTagList(CYBERGFX_BASE_NAME, bitMap, tagList)
  265.  
  266. static __inline APTR
  267. _LockBitMapTagList(void *CyberGfxBase, struct BitMap *bitMap, struct TagItem *tagList)
  268. {
  269. struct Caos    MyCaos;
  270.     MyCaos.M68kCacheMode        =    IF_CACHEFLUSHALL;
  271. //    MyCaos.M68kStart        =    NULL;
  272. //    MyCaos.M68kSize            =    0;
  273.     MyCaos.PPCCacheMode        =    IF_CACHEFLUSHALL;
  274. //    MyCaos.PPCStart            =    NULL;
  275. //    MyCaos.PPCSize            =    0;
  276.     MyCaos.a0            =    (ULONG) bitMap;
  277.     MyCaos.a1            =    (ULONG) tagList;
  278.     MyCaos.caos_Un.Offset        =    (-0xa8);
  279.     MyCaos.a6            =    (ULONG) CyberGfxBase;
  280.     return((APTR)PPCCallOS(&MyCaos));
  281. }
  282.  
  283. #ifndef NO_PPCINLINE_STDARG
  284. #define LockBitMapTags(a0, tags...) \
  285.     ({ULONG _tags[] = { tags }; LockBitMapTagList((a0), (struct TagItem *)_tags);})
  286. #endif /* !NO_PPCINLINE_STDARG */
  287.  
  288. #define MovePixelArray(srcX, srcY, rastPort, destX, destY, sizeX, sizeY) _MovePixelArray(CYBERGFX_BASE_NAME, srcX, srcY, rastPort, destX, destY, sizeX, sizeY)
  289.  
  290. static __inline ULONG
  291. _MovePixelArray(void *CyberGfxBase, UWORD srcX, UWORD srcY, struct RastPort *rastPort, UWORD destX, UWORD destY, UWORD sizeX, UWORD sizeY)
  292. {
  293. struct Caos    MyCaos;
  294.     MyCaos.M68kCacheMode        =    IF_CACHEFLUSHALL;
  295. //    MyCaos.M68kStart        =    NULL;
  296. //    MyCaos.M68kSize            =    0;
  297.     MyCaos.PPCCacheMode        =    IF_CACHEFLUSHALL;
  298. //    MyCaos.PPCStart            =    NULL;
  299. //    MyCaos.PPCSize            =    0;
  300.     MyCaos.d0            =    (ULONG) srcX;
  301.     MyCaos.d1            =    (ULONG) srcY;
  302.     MyCaos.d2            =    (ULONG) destX;
  303.     MyCaos.d3            =    (ULONG) destY;
  304.     MyCaos.d4            =    (ULONG) sizeX;
  305.     MyCaos.d5            =    (ULONG) sizeY;
  306.     MyCaos.a1            =    (ULONG) rastPort;
  307.     MyCaos.caos_Un.Offset        =    (-0x84);
  308.     MyCaos.a6            =    (ULONG) CyberGfxBase;
  309.     return((ULONG)PPCCallOS(&MyCaos));
  310. }
  311.  
  312. #define ReadPixelArray(destRect, destX, destY, destMod, rastPort, srcX, srcY, sizeX, sizeY, destFormat) _ReadPixelArray(CYBERGFX_BASE_NAME, destRect, destX, destY, destMod, rastPort, srcX, srcY, sizeX, sizeY, destFormat)
  313.  
  314. static __inline ULONG
  315. _ReadPixelArray(void *CyberGfxBase, APTR destRect, UWORD destX, UWORD destY, UWORD destMod, struct RastPort *rastPort, UWORD srcX, UWORD srcY, UWORD sizeX, UWORD sizeY, UBYTE destFormat)
  316. {
  317. struct Caos    MyCaos;
  318.     MyCaos.M68kCacheMode        =    IF_CACHEFLUSHALL;
  319. //    MyCaos.M68kStart        =    NULL;
  320. //    MyCaos.M68kSize            =    0;
  321.     MyCaos.PPCCacheMode        =    IF_CACHEFLUSHALL;
  322. //    MyCaos.PPCStart            =    NULL;
  323. //    MyCaos.PPCSize            =    0;
  324.     MyCaos.d0            =    (ULONG) destX;
  325.     MyCaos.d1            =    (ULONG) destY;
  326.     MyCaos.d2            =    (ULONG) destMod;
  327.     MyCaos.d3            =    (ULONG) srcX;
  328.     MyCaos.d4            =    (ULONG) srcY;
  329.     MyCaos.d5            =    (ULONG) sizeX;
  330.     MyCaos.d6            =    (ULONG) sizeY;
  331.     MyCaos.d7            =    (ULONG) destFormat;
  332.     MyCaos.a0            =    (ULONG) destRect;
  333.     MyCaos.a1            =    (ULONG) rastPort;
  334.     MyCaos.caos_Un.Offset        =    (-0x78);
  335.     MyCaos.a6            =    (ULONG) CyberGfxBase;
  336.     return((ULONG)PPCCallOS(&MyCaos));
  337. }
  338.  
  339. #define ReadRGBPixel(rastPort, x, y) _ReadRGBPixel(CYBERGFX_BASE_NAME, rastPort, x, y)
  340.  
  341. static __inline ULONG
  342. _ReadRGBPixel(void *CyberGfxBase, struct RastPort *rastPort, UWORD x, UWORD y)
  343. {
  344. struct Caos    MyCaos;
  345.     MyCaos.M68kCacheMode        =    IF_CACHEFLUSHALL;
  346. //    MyCaos.M68kStart        =    NULL;
  347. //    MyCaos.M68kSize            =    0;
  348.     MyCaos.PPCCacheMode        =    IF_CACHEFLUSHALL;
  349. //    MyCaos.PPCStart            =    NULL;
  350. //    MyCaos.PPCSize            =    0;
  351.     MyCaos.d0            =    (ULONG) x;
  352.     MyCaos.d1            =    (ULONG) y;
  353.     MyCaos.a1            =    (ULONG) rastPort;
  354.     MyCaos.caos_Un.Offset        =    (-0x6c);
  355.     MyCaos.a6            =    (ULONG) CyberGfxBase;
  356.     return((ULONG)PPCCallOS(&MyCaos));
  357. }
  358.  
  359. #define ScalePixelArray(srcRect, srcW, srcH, srcMod, rastPort, destX, destY, destW, destH, srcFormat) _ScalePixelArray(CYBERGFX_BASE_NAME, srcRect, srcW, srcH, srcMod, rastPort, destX, destY, destW, destH, srcFormat)
  360.  
  361. static __inline LONG
  362. _ScalePixelArray(void *CyberGfxBase, APTR srcRect, UWORD srcW, UWORD srcH, UWORD srcMod, struct RastPort *rastPort, UWORD destX, UWORD destY, UWORD destW, UWORD destH, UBYTE srcFormat)
  363. {
  364. struct Caos    MyCaos;
  365.     MyCaos.M68kCacheMode        =    IF_CACHEFLUSHALL;
  366. //    MyCaos.M68kStart        =    NULL;
  367. //    MyCaos.M68kSize            =    0;
  368.     MyCaos.PPCCacheMode        =    IF_CACHEFLUSHALL;
  369. //    MyCaos.PPCStart            =    NULL;
  370. //    MyCaos.PPCSize            =    0;
  371.     MyCaos.d0            =    (ULONG) srcW;
  372.     MyCaos.d1            =    (ULONG) srcH;
  373.     MyCaos.d2            =    (ULONG) srcMod;
  374.     MyCaos.d3            =    (ULONG) destX;
  375.     MyCaos.d4            =    (ULONG) destY;
  376.     MyCaos.d5            =    (ULONG) destW;
  377.     MyCaos.d6            =    (ULONG) destH;
  378.     MyCaos.d7            =    (ULONG) srcFormat;
  379.     MyCaos.a0            =    (ULONG) srcRect;
  380.     MyCaos.a1            =    (ULONG) rastPort;
  381.     MyCaos.caos_Un.Offset        =    (-0x5a);
  382.     MyCaos.a6            =    (ULONG) CyberGfxBase;
  383.     return((LONG)PPCCallOS(&MyCaos));
  384. }
  385.  
  386. #define UnLockBitMap(handle) _UnLockBitMap(CYBERGFX_BASE_NAME, handle)
  387.  
  388. static __inline void
  389. _UnLockBitMap(void *CyberGfxBase, APTR handle)
  390. {
  391. struct Caos    MyCaos;
  392.     MyCaos.M68kCacheMode        =    IF_CACHEFLUSHALL;
  393. //    MyCaos.M68kStart        =    NULL;
  394. //    MyCaos.M68kSize            =    0;
  395.     MyCaos.PPCCacheMode        =    IF_CACHEFLUSHALL;
  396. //    MyCaos.PPCStart            =    NULL;
  397. //    MyCaos.PPCSize            =    0;
  398.     MyCaos.a0            =    (ULONG) handle;
  399.     MyCaos.caos_Un.Offset        =    (-0xae);
  400.     MyCaos.a6            =    (ULONG) CyberGfxBase;
  401.     PPCCallOS(&MyCaos);
  402. }
  403.  
  404. #define WritePixelArray(srcRect, srcX, srcY, srcMod, rastPort, destX, destY, sizeX, sizeY, srcFormat) _WritePixelArray(CYBERGFX_BASE_NAME, srcRect, srcX, srcY, srcMod, rastPort, destX, destY, sizeX, sizeY, srcFormat)
  405.  
  406. static __inline ULONG
  407. _WritePixelArray(void *CyberGfxBase, APTR srcRect, UWORD srcX, UWORD srcY, UWORD srcMod, struct RastPort *rastPort, UWORD destX, UWORD destY, UWORD sizeX, UWORD sizeY, UBYTE srcFormat)
  408. {
  409. struct Caos    MyCaos;
  410.     MyCaos.M68kCacheMode        =    IF_CACHEFLUSHALL;
  411. //    MyCaos.M68kStart        =    NULL;
  412. //    MyCaos.M68kSize            =    0;
  413.     MyCaos.PPCCacheMode        =    IF_CACHEFLUSHALL;
  414. //    MyCaos.PPCStart            =    NULL;
  415. //    MyCaos.PPCSize            =    0;
  416.     MyCaos.d0            =    (ULONG) srcX;
  417.     MyCaos.d1            =    (ULONG) srcY;
  418.     MyCaos.d2            =    (ULONG) srcMod;
  419.     MyCaos.d3            =    (ULONG) destX;
  420.     MyCaos.d4            =    (ULONG) destY;
  421.     MyCaos.d5            =    (ULONG) sizeX;
  422.     MyCaos.d6            =    (ULONG) sizeY;
  423.     MyCaos.d7            =    (ULONG) srcFormat;
  424.     MyCaos.a0            =    (ULONG) srcRect;
  425.     MyCaos.a1            =    (ULONG) rastPort;
  426.     MyCaos.caos_Un.Offset        =    (-0x7e);
  427.     MyCaos.a6            =    (ULONG) CyberGfxBase;
  428.     return((ULONG)PPCCallOS(&MyCaos));
  429. }
  430.  
  431. #define WriteRGBPixel(rastPort, x, y, color) _WriteRGBPixel(CYBERGFX_BASE_NAME, rastPort, x, y, color)
  432.  
  433. static __inline LONG
  434. _WriteRGBPixel(void *CyberGfxBase, struct RastPort *rastPort, UWORD x, UWORD y, ULONG color)
  435. {
  436. struct Caos    MyCaos;
  437.     MyCaos.M68kCacheMode        =    IF_CACHEFLUSHALL;
  438. //    MyCaos.M68kStart        =    NULL;
  439. //    MyCaos.M68kSize            =    0;
  440.     MyCaos.PPCCacheMode        =    IF_CACHEFLUSHALL;
  441. //    MyCaos.PPCStart            =    NULL;
  442. //    MyCaos.PPCSize            =    0;
  443.     MyCaos.d0            =    (ULONG) x;
  444.     MyCaos.d1            =    (ULONG) y;
  445.     MyCaos.d2            =    color;
  446.     MyCaos.a1            =    (ULONG) rastPort;
  447.     MyCaos.caos_Un.Offset        =    (-0x72);
  448.     MyCaos.a6            =    (ULONG) CyberGfxBase;
  449.     return((LONG)PPCCallOS(&MyCaos));
  450. }
  451.  
  452. #endif /* SASC Pragmas */
  453. #endif /* !_PPCPRAGMA_CYBERGRAPHICS_H */
  454.