Games/Doom/cybergraphics_pragmas.h

   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 */