mdw@git.distorted.org.uk Git - ssr/blob - StraySrc/Libraries/Steel/c/sprite

   1 /************************************************************************/
   2 /* © Acorn Computers Ltd, 1992.                                         */
   3 /*                                                                      */
   4 /* This file forms part of an unsupported source release of RISC_OSLib. */
   5 /*                                                                      */
   6 /* It may be freely used to create executable images for saleable       */
   7 /* products but cannot be sold in source form or as an object library   */
   8 /* without the prior written consent of Acorn Computers Ltd.            */
   9 /*                                                                      */
  10 /* If this file is re-distributed (even if modified) it should retain   */
  11 /* this copyright notice.                                               */
  12 /*                                                                      */
  13 /************************************************************************/
  14
  15 /*
  16  * Title  : c.sprite
  17  * Purpose: provide access to RISC OS sprite facilities
  18  * History: IDJ: 07-Feb-92: prepared for source release
  19  *
  20  */
  21
  22
  23 #include <stddef.h>
  24 #include "h.os"
  25
  26 #include "h.sprite"
  27
  28
  29 /* Basic primitive used by sprite_xxx calls */
  30
  31 #define OS_SpriteOp 0x2E
  32
  33 #define ScreenSave            2
  34 #define ScreenLoad            3
  35
  36 #define ReadAreaCB            8  /* *SInfo */
  37 #define ClearSprites          9  /* *SNew */
  38 #define LoadSpriteFile        10 /* *SLoad <filename> */
  39 #define MergeSpriteFile       11 /* *SMerge <filename> */
  40 #define SaveSpriteFile        12 /* *SSave <filename> */
  41 #define ReturnName            13
  42 #define GetSprite             14 /* *SGet <n> */
  43 #define CreateSprite          15
  44 #define GetSpriteUserCoords   16
  45
  46 #define SelectSprite          24 /* *SChoose <n> [<m>] */
  47 #define DeleteSprite          25 /* *SDelete <n> */
  48 #define RenameSprite          26 /* *SRename */
  49 #define CopySprite            27
  50 #define PutSprite             28
  51 #define CreateMask            29
  52 #define RemoveMask            30
  53 #define InsertRow             31
  54 #define DeleteRow             32
  55 #define FlipAboutXAxis        33
  56 #define PutSpriteUserCoords   34
  57 #define AppendSprite          35
  58 #define SetPointerShape       36
  59
  60 #define ReadSpriteSize        40
  61 #define ReadPixelColour       41
  62 #define WritePixelColour      42
  63 #define ReadPixelMask         43
  64 #define WritePixelMask        44
  65 #define InsertCol             45
  66 #define DeleteCol             46
  67 #define FlipAboutYAxis        47
  68 #define PlotMask              48
  69 #define PlotMaskUserCoords    49
  70
  71 #define PlotMaskScaled        50
  72 #define PaintCharScaled       51
  73 #define PutSpriteScaled       52
  74 #define PutSpriteGreyScaled   53
  75 #define RemoveLeftHandWastage 54
  76 #define PlotMaskTransformed   55
  77 #define PutSpriteTransformed  56
  78 #define InsertDeleteRows      57
  79 #define InsertDeleteColumns   58
  80
  81 #define SwitchOutputToSprite  60
  82 #define SwitchOutputToMask    61
  83 #define ReadSaveAreaSize      62
  84
  85 #define BadReasonCode         63
  86
  87 #pragma no_check_stack
  88
  89 static os_error * sprite__op(os_regset *r)
  90 {
  91   return os_swix(OS_SpriteOp, r);
  92 }
  93
  94
  95 /******** Simple operations, use no sprite area, no name/sprite pointer ***/
  96
  97
  98 os_error * sprite_screensave(const char *filename, sprite_palflag palflag)
  99 {
 100    os_regset r;
 101    os_error *result;
 102    r.r[0] = 2;
 103  /*r.r[1] unused */
 104    r.r[2] = (int) filename;
 105    r.r[3] = palflag;
 106    result = sprite__op(&r);
 107    return result;
 108 }
 109
 110
 111 os_error * sprite_screenload(const char *filename)
 112 {
 113    os_regset r;
 114    os_error *result;
 115    r.r[0] = 3;
 116  /*r.r[1] unused */
 117    r.r[2] = (int) filename;
 118    result = sprite__op(&r);
 119    return result;
 120 }
 121
 122
 123 /****** Operations on either system/user area, no name/sprite pointer *****/
 124
 125 static void setfromarea(int op, sprite_area *area, os_regset *r)
 126 {
 127    if (area == sprite_mainarea)
 128    {
 129       r->r[0] = op;
 130  /*   r->r[1] unused */
 131    }
 132    else
 133    {
 134       r->r[0] = op + 256;
 135       r->r[1] = (int) area;
 136    }
 137 }
 138
 139
 140 void sprite_area_initialise(sprite_area *area, int length)
 141 {
 142    area->size    = length; /* No SpriteOp to do this ! */
 143    area->number  = 0;
 144    area->sproff  = 16;
 145    area->freeoff = 16;
 146 }
 147
 148
 149 os_error * sprite_area_readinfo(sprite_area *area, sprite_area *resultarea)
 150 {
 151    os_regset r;
 152    os_error *result;
 153    setfromarea(8, area, &r);
 154    result = sprite__op(&r);
 155    if (result == NULL) /* Only return result if no error */
 156    {
 157       resultarea->size    = r.r[2];
 158       resultarea->number  = r.r[3];
 159       resultarea->sproff  = r.r[4];
 160       resultarea->freeoff = r.r[5];
 161    }
 162    return result;
 163 }
 164
 165
 166 os_error * sprite_area_reinit(sprite_area *area)
 167 {
 168    os_regset r;
 169    os_error *result;
 170    setfromarea(9, area, &r);
 171    result = sprite__op(&r);
 172    return result;
 173 }
 174
 175
 176 os_error * sprite_area_save(sprite_area *area, const char *filename)
 177 {
 178    os_regset r;
 179    os_error *result;
 180    setfromarea(12, area, &r);
 181    r.r[2] = (int) filename;
 182    result = sprite__op(&r);
 183    return result;
 184 }
 185
 186
 187 os_error * sprite_area_load(sprite_area *area, const char *filename)
 188 {
 189    os_regset r;
 190    os_error *result;
 191    setfromarea(10, area, &r);
 192    r.r[2] = (int) filename;
 193    result = sprite__op(&r);
 194    return result;
 195 }
 196
 197
 198 os_error * sprite_area_merge(sprite_area *area, const char *filename)
 199 {
 200    os_regset r;
 201    os_error *result;
 202    setfromarea(11, area, &r);
 203    r.r[2] = (int) filename;
 204    result = sprite__op(&r);
 205    return result;
 206 }
 207
 208
 209 os_error * sprite_getname(sprite_area *area, void *buffer,
 210                           int *length, int index)
 211 {
 212    os_regset r;
 213    os_error *result;
 214    setfromarea(13, area, &r);
 215    r.r[2] = (int) buffer;
 216    r.r[3] = *length;
 217    r.r[4] = index;
 218    result = sprite__op(&r);
 219    if (result == NULL) /* Only return result if no error */
 220    {
 221       *length = r.r[3];
 222    }
 223    return result;
 224 }
 225
 226
 227 os_error * sprite_get(sprite_area *area, char *name, sprite_palflag palflag)
 228 {
 229    os_regset r;
 230    os_error *result;
 231    setfromarea(14, area, &r);
 232    r.r[2] = (int) name;
 233    r.r[3] = palflag;
 234    result = sprite__op(&r);
 235    return result;
 236 }
 237
 238
 239 os_error * sprite_get_rp(sprite_area *area, char *name, sprite_palflag palflag,
 240                          sprite_ptr *resultaddress)
 241 {
 242    os_regset r;
 243    os_error *result;
 244    setfromarea(14, area, &r);
 245    r.r[2] = (int) name;
 246    r.r[3] = palflag;
 247    result = sprite__op(&r);
 248    if (result == NULL) /* Only return result if no error */
 249    {
 250       *resultaddress = (void *) r.r[2];
 251    }
 252    return result;
 253 }
 254
 255
 256 os_error * sprite_get_given(sprite_area *area, char *name,
 257                             sprite_palflag palflag,
 258                             int x0, int y0, int x1, int y1)
 259 {
 260    os_regset r;
 261    os_error *result;
 262    setfromarea(16, area, &r);
 263    r.r[2] = (int) name;
 264    r.r[3] = palflag;
 265    r.r[4] = x0;
 266    r.r[5] = y0;
 267    r.r[6] = x1;
 268    r.r[7] = y1;
 269    result = sprite__op(&r);
 270    return result;
 271 }
 272
 273
 274 os_error * sprite_get_given_rp(sprite_area *area, char *name,
 275                                sprite_palflag palflag, int x0, int y0,
 276                                int x1, int y1, sprite_ptr *resultaddress)
 277 {
 278    os_regset r;
 279    os_error *result;
 280    setfromarea(16, area, &r);
 281    r.r[2] = (int) name;
 282    r.r[3] = palflag;
 283    r.r[4] = x0;
 284    r.r[5] = y0;
 285    r.r[6] = x1;
 286    r.r[7] = y1;
 287    result = sprite__op(&r);
 288    if (result == NULL) /* Only return result if no error */
 289    {
 290       *resultaddress = (void *) r.r[2];
 291    }
 292    return result;
 293 }
 294
 295
 296 os_error * sprite_create(sprite_area *area, char *name, sprite_palflag palflag,
 297                          int width, int height, int mode)
 298 {
 299    os_regset r;
 300    os_error *result;
 301    setfromarea(15, area, &r); /* NB. Not all done in numeric order !! */
 302    r.r[2] = (int) name;
 303    r.r[3] = palflag;
 304    r.r[4] = width;
 305    r.r[5] = height;
 306    r.r[6] = mode;
 307    result = sprite__op(&r);
 308    return result;
 309 }
 310
 311
 312 os_error * sprite_create_rp(sprite_area *area, char *name,
 313                             sprite_palflag palflag,
 314                             int width, int height, int mode,
 315                             sprite_ptr *resultaddress)
 316 {
 317    os_regset r;
 318    os_error *result;
 319    setfromarea(15, area, &r); /* NB. Not all done in numeric order !! */
 320    r.r[2] = (int) name;
 321    r.r[3] = palflag;
 322    r.r[4] = width;
 323    r.r[5] = height;
 324    r.r[6] = mode;
 325    result = sprite__op(&r);
 326    if (result == NULL) /* Only return result if no error */
 327    {
 328       /* spriteop 15 doesn't return pointer to sprite in r2, so....*/
 329       /* select the sprite just created (gets its address in r2) */
 330       setfromarea(24, area, &r);
 331       r.r[2] = (int)name;
 332       result = sprite__op(&r);
 333       if (result == NULL)
 334          *resultaddress = (void *) r.r[2];
 335    }
 336    return result;
 337 }
 338
 339
 340 /*********** Operations on system/user area, name/sprite pointer **********/
 341
 342 /* Modify op if using sprite address is address, not name */
 343 /* But only if using own sprite area */
 344
 345 static void setfromtag(int op, sprite_area *area, sprite_id *spr, os_regset *r)
 346 {
 347    if (area == sprite_mainarea)
 348    {
 349       r->r[0] = op;
 350    /* r->r[1] unused */
 351    }
 352    else
 353    {
 354       r->r[1] = (int) area;
 355       if ((spr->tag) == sprite_id_addr)
 356       {
 357          r->r[0] = 512 + op;
 358          r->r[2] = (int) (spr->s.addr);
 359       }
 360       else
 361       {
 362          r->r[0] = 256 + op;
 363          r->r[2] = (int) (spr->s.name);
 364       }
 365    }
 366 }
 367
 368
 369 os_error * sprite_readinfo(sprite_area *area, sprite_id *spr,
 370                            sprite_info *resultinfo)
 371 {
 372    os_regset r;
 373    os_error *result;
 374    setfromtag(40, area, spr, &r);
 375    result = sprite__op(&r);
 376    if (result == NULL) /* Only return result if no error */
 377    {
 378       resultinfo->width  = r.r[3];
 379       resultinfo->height = r.r[4];
 380       resultinfo->mask   = r.r[5];
 381       resultinfo->mode   = r.r[6];
 382    }
 383    return result;
 384 }
 385
 386
 387 os_error * sprite_select(sprite_area *area, sprite_id *spr)
 388 {
 389    os_regset r;
 390    os_error *result;
 391    setfromtag(24, area, spr, &r);
 392    result = sprite__op(&r);
 393    return result;
 394 }
 395
 396
 397 os_error * sprite_select_rp(sprite_area *area, sprite_id *spr,
 398                             sprite_ptr *resultaddress)
 399 {
 400    os_regset r;
 401    os_error *result;
 402    setfromtag(24, area, spr, &r);
 403    result = sprite__op(&r);
 404    if (result == NULL) /* Only return result if no error */
 405    {
 406       *resultaddress = (void *) r.r[2];
 407    }
 408    return result;
 409 }
 410
 411
 412 os_error * sprite_delete(sprite_area *area, sprite_id *spr)
 413 {
 414    os_regset r;
 415    os_error *result;
 416    setfromtag(25, area, spr, &r);
 417    result = sprite__op(&r);
 418    return result;
 419 }
 420
 421
 422 os_error * sprite_rename(sprite_area *area, sprite_id *spr, char *newname)
 423 {
 424    os_regset r;
 425    os_error *result;
 426    setfromtag(26, area, spr, &r);
 427    r.r[3] = (int) newname;
 428    result = sprite__op(&r);
 429    return result;
 430 }
 431
 432
 433 os_error * sprite_copy(sprite_area *area, sprite_id *spr, char *copyname)
 434 {
 435    os_regset r;
 436    os_error *result;
 437    setfromtag(27, area, spr, &r);
 438    r.r[3] = (int) copyname;
 439    result = sprite__op(&r);
 440    return result;
 441 }
 442
 443
 444 os_error * sprite_put(sprite_area *area, sprite_id *spr, int gcol_action)
 445 {
 446    os_regset r;
 447    os_error *result;
 448    setfromtag(28, area, spr, &r);
 449    r.r[5] = gcol_action;
 450    result = sprite__op(&r);
 451    return result;
 452 }
 453
 454
 455 os_error * sprite_put_given(sprite_area *area, sprite_id *spr, int gcol_action,
 456                             int x, int y)
 457 {
 458    os_regset r;
 459    os_error *result;
 460    setfromtag(34, area, spr, &r);
 461    r.r[3] = x;
 462    r.r[4] = y;
 463    r.r[5] = gcol_action;
 464    result = sprite__op(&r);
 465    return result;
 466 }
 467
 468
 469 os_error * sprite_put_scaled(sprite_area *area, sprite_id *spr,
 470                              int gcol_action,
 471                              int x, int y,
 472                              sprite_factors *factors,
 473                              sprite_pixtrans *pixtrans)
 474 {
 475    os_regset r;
 476    os_error *result;
 477    setfromtag(52, area, spr, &r);
 478    r.r[3] = x;
 479    r.r[4] = y;
 480    r.r[5] = gcol_action;
 481    r.r[6] = (int) factors;
 482    r.r[7] = (int) pixtrans;
 483    result = sprite__op(&r);
 484    return result;
 485 }
 486
 487
 488 os_error * sprite_put_greyscaled(sprite_area *area, sprite_id *spr,
 489                                  int x, int y,
 490                                  sprite_factors *factors,
 491                                  sprite_pixtrans *pixtrans)
 492 {
 493    os_regset r;
 494    os_error *result;
 495    setfromtag(53, area, spr, &r);
 496    r.r[3] = x;
 497    r.r[4] = y;
 498    r.r[5] = 0;                   /* doesn't support mask or gcol action */
 499    r.r[6] = (int) factors;
 500    r.r[7] = (int) pixtrans;
 501    result = sprite__op(&r);
 502    return result;
 503 }
 504
 505
 506 os_error * sprite_put_mask(sprite_area *area, sprite_id *spr)
 507 {
 508    os_regset r;
 509    os_error *result;
 510    setfromtag(48, area, spr, &r);
 511    result = sprite__op(&r);
 512    return result;
 513 }
 514
 515
 516 os_error * sprite_put_mask_given(sprite_area *area, sprite_id *spr,
 517                                  int x, int y)
 518 {
 519    os_regset r;
 520    os_error *result;
 521    setfromtag(49, area, spr, &r);
 522    r.r[3] = x;
 523    r.r[4] = y;
 524    result = sprite__op(&r);
 525    return result;
 526 }
 527
 528
 529 os_error * sprite_put_mask_scaled(sprite_area *area, sprite_id *spr,
 530                                   int x, int y,
 531                                   sprite_factors *factors)
 532 {
 533    os_regset r;
 534    os_error *result;
 535    setfromtag(50, area, spr, &r);
 536    r.r[3] = x;
 537    r.r[4] = y;
 538    r.r[6] = (int) factors;
 539    result = sprite__op(&r);
 540    return result;
 541 }
 542
 543
 544 os_error * sprite_put_char_scaled(char ch,
 545                                   int x, int y,
 546                                   sprite_factors *factors)
 547 {
 548    os_regset r;
 549    os_error *result;
 550    r.r[0] = 51;
 551    r.r[1] = ch;
 552    r.r[3] = x;
 553    r.r[4] = y;
 554    r.r[6] = (int) factors;
 555    result = sprite__op(&r);
 556    return result;
 557 }
 558
 559
 560 os_error * sprite_create_mask(sprite_area *area, sprite_id *spr)
 561 {
 562    os_regset r;
 563    os_error *result;
 564    setfromtag(29, area, spr, &r);
 565    result = sprite__op(&r);
 566    return result;
 567 }
 568
 569
 570 os_error * sprite_remove_mask(sprite_area *area, sprite_id *spr)
 571 {
 572    os_regset r;
 573    os_error *result;
 574    setfromtag(30, area, spr, &r);
 575    result = sprite__op(&r);
 576    return result;
 577 }
 578
 579
 580 os_error * sprite_insert_row(sprite_area *area, sprite_id *spr, int row)
 581 {
 582    os_regset r;
 583    os_error *result;
 584    setfromtag(31, area, spr, &r);
 585    r.r[3] = row;
 586    result = sprite__op(&r);
 587    return result;
 588 }
 589
 590
 591 os_error * sprite_delete_row(sprite_area *area, sprite_id *spr, int row)
 592 {
 593    os_regset r;
 594    os_error *result;
 595    setfromtag(32, area, spr, &r);
 596    r.r[3] = row;
 597    result = sprite__op(&r);
 598    return result;
 599 }
 600
 601
 602 os_error * sprite_insert_column(sprite_area *area, sprite_id *spr, int column)
 603 {
 604    os_regset r;
 605    os_error *result;
 606    setfromtag(45, area, spr, &r);
 607    r.r[3] = column;
 608    result = sprite__op(&r);
 609    return result;
 610 }
 611
 612
 613 os_error * sprite_delete_column(sprite_area *area, sprite_id *spr, int column)
 614 {
 615    os_regset r;
 616    os_error *result;
 617    setfromtag(46, area, spr, &r);
 618    r.r[3] = column;
 619    result = sprite__op(&r);
 620    return result;
 621 }
 622
 623
 624 os_error * sprite_flip_x(sprite_area *area, sprite_id *spr)
 625 {
 626    os_regset r;
 627    os_error *result;
 628    setfromtag(33, area, spr, &r);
 629    result = sprite__op(&r);
 630    return result;
 631 }
 632
 633
 634 os_error * sprite_flip_y(sprite_area *area, sprite_id *spr)
 635 {
 636    os_regset r;
 637    os_error *result;
 638    setfromtag(47, area, spr, &r);
 639    result = sprite__op(&r);
 640    return result;
 641 }
 642
 643 os_error * sprite_readsize(sprite_area *area, sprite_id *spr,
 644                            sprite_info *resultinfo)
 645 {
 646    os_regset r;
 647    os_error *result;
 648    setfromtag(40, area, spr, &r);
 649    result = sprite__op(&r);
 650  /* now copy returned data */
 651    resultinfo->width = r.r[3] ;
 652    resultinfo->height = r.r[4] ;
 653    resultinfo->mask = r.r[5] ;
 654    resultinfo->mode = r.r[6] ;
 655    return result;
 656 }
 657
 658 os_error * sprite_readpixel(sprite_area *area, sprite_id *spr, int x, int y,
 659                             sprite_colour *resultcolour)
 660 {
 661    os_regset r;
 662    os_error *result;
 663    setfromtag(41, area, spr, &r);
 664    r.r[3] = x;
 665    r.r[4] = y;
 666    result = sprite__op(&r);
 667    if (result == NULL) /* Only return result if no error */
 668    {
 669       resultcolour->colour = r.r[5];
 670       resultcolour->tint   = r.r[6];
 671    }
 672    return result;
 673 }
 674
 675
 676 os_error * sprite_writepixel(sprite_area *area, sprite_id *spr, int x, int y,
 677                             sprite_colour *colour)
 678 {
 679    os_regset r;
 680    os_error *result;
 681    setfromtag(42, area, spr, &r);
 682    r.r[3] = x;
 683    r.r[4] = y;
 684    r.r[5] = colour->colour;
 685    r.r[6] = colour->tint;
 686    result = sprite__op(&r);
 687    return result;
 688 }
 689
 690
 691 os_error * sprite_readmask(sprite_area *area, sprite_id *spr, int x, int y,
 692                            sprite_maskstate *resultmaskstate)
 693 {
 694    os_regset r;
 695    os_error *result;
 696    setfromtag(43, area, spr, &r);
 697    r.r[3] = x;
 698    r.r[4] = y;
 699    result = sprite__op(&r);
 700    if (result == NULL) /* Only return result if no error */
 701    {
 702       *resultmaskstate = r.r[5];
 703    }
 704    return result;
 705 }
 706
 707
 708 os_error * sprite_writemask(sprite_area *area, sprite_id *spr, int x, int y,
 709                             sprite_maskstate *maskstate)
 710 {
 711    os_regset r;
 712    os_error *result;
 713    setfromtag(44, area, spr, &r);
 714    r.r[3] = x;
 715    r.r[4] = y;
 716    r.r[5] = (int) (*maskstate); /* Use pointer here for consistent interface */
 717    result = sprite__op(&r);
 718    return result;
 719 }
 720
 721 os_error *sprite_restorestate(sprite_state state)
 722 {
 723    os_regset r;
 724    os_error *result;
 725
 726    r.r[0] = state.r[0];
 727    r.r[1] = state.r[1];
 728    r.r[2] = state.r[2];
 729    r.r[3] = state.r[3];
 730
 731    result = sprite__op(&r);
 732    return result;
 733 }
 734
 735 os_error *sprite_outputtosprite(sprite_area *area, sprite_id *id,
 736                                 int *save_area, sprite_state *state)
 737 {
 738    os_regset r;
 739    os_error *result;
 740
 741    setfromtag(0x3c, area, id, &r);
 742    r.r[3] = (int) save_area;
 743
 744    result = sprite__op(&r);
 745    if (result == NULL)
 746    {
 747       state->r[0] = r.r[0];
 748       state->r[1] = r.r[1];
 749       state->r[2] = r.r[2];
 750       state->r[3] = r.r[3];
 751    }
 752    return result;
 753 }
 754
 755 os_error *sprite_outputtomask(sprite_area *area, sprite_id *id,
 756                               int *save_area, sprite_state *state)
 757 {
 758    os_regset r;
 759    os_error *result;
 760
 761    setfromtag(0x3d, area, id, &r);
 762    r.r[3] = (int) save_area;
 763
 764    result = sprite__op(&r);
 765    if (result == NULL)
 766    {
 767      state->r[0] = r.r[0];
 768      state->r[1] = r.r[1];
 769      state->r[2] = r.r[2];
 770      state->r[3] = r.r[3];
 771    }
 772    return result;
 773 }
 774
 775 os_error *sprite_outputtoscreen(int *save_area, sprite_state *state)
 776 {
 777    os_regset r;
 778    os_error *result;
 779
 780    r.r[0] = 0x3c;
 781    r.r[2] = 0;
 782    r.r[3] = (int)save_area;
 783
 784    result = sprite__op(&r);
 785    if (result == NULL)
 786    {
 787      state->r[0] = r.r[0];
 788      state->r[1] = r.r[1];
 789      state->r[2] = r.r[2];
 790      state->r[3] = r.r[3];
 791    }
 792    return result;
 793
 794 }
 795
 796 os_error *sprite_sizeof_spritecontext(sprite_area *area, sprite_id *id,
 797                                       int *size)
 798 {
 799    os_regset r;
 800    os_error *result;
 801
 802    setfromtag(0x3e, area, id, &r);
 803
 804    result = sprite__op(&r);
 805
 806    if (result == NULL)
 807      *size = r.r[3];
 808
 809    return result;
 810 }
 811
 812
 813 os_error *sprite_sizeof_screencontext(int *size)
 814 {
 815    os_regset r;
 816    os_error *result;
 817
 818    r.r[0] = 0x3e;
 819    r.r[2] = 0;
 820
 821    result = sprite__op(&r);
 822
 823    if (result == NULL)
 824      *size = r.r[3];
 825
 826    return result;
 827 }
 828
 829 os_error *sprite_removewastage(sprite_area *area, sprite_id *id)
 830 {
 831    os_regset r;
 832    os_error *result;
 833
 834    setfromtag(0x36, area, id, &r);
 835
 836    result = sprite__op(&r);
 837
 838    return result;
 839 }
 840
 841 os_error *sprite_change_size (sprite_area *area,
 842                               sprite_id *id,
 843                               BOOL rows,
 844                               int at,
 845                               int number)
 846 {
 847    os_regset reg_set;
 848    setfromtag (rows? InsertDeleteRows: InsertDeleteColumns, area, id, &reg_set);
 849    reg_set.r [3] = at;
 850    reg_set.r [4] = number;
 851    return sprite__op (&reg_set);
 852 }
 853
 854 os_error *sprite_put_mask_trans (sprite_area *area,
 855                                  sprite_id *id,
 856                                  sprite_box *box,
 857                                  sprite_transmat *trans_mat)
 858 {
 859    os_regset reg_set;
 860    setfromtag (PlotMaskTransformed, area, id, &reg_set);
 861    reg_set.r [3] = box == NULL? 0: 1 << 1;
 862    reg_set.r [4] = (int) box;
 863    reg_set.r [6] = (int) trans_mat;
 864    return sprite__op (&reg_set);
 865 }
 866
 867 os_error *sprite_put_mask_pgm (sprite_area *area,
 868                                sprite_id *id,
 869                                sprite_box *box,
 870                                sprite_pgm *pgm)
 871 {
 872    os_regset reg_set;
 873    setfromtag (PlotMaskTransformed, area, id, &reg_set);
 874    reg_set.r [3] = (box == NULL? 0: 1 << 1) | (1 << 0);
 875    reg_set.r [4] = (int) box;
 876    reg_set.r [6] = (int) pgm;
 877    return sprite__op (&reg_set);
 878 }
 879
 880 os_error *sprite_put_trans (sprite_area *area,
 881                             sprite_id *id,
 882                             int gcol_action,
 883                             sprite_box *box,
 884                             sprite_transmat *trans_mat,
 885                             sprite_pixtrans *pix_trans)
 886 {
 887    os_regset reg_set;
 888    setfromtag (PutSpriteTransformed, area, id, &reg_set);
 889    reg_set.r [3] = box == NULL? 0: 1 << 1;
 890    reg_set.r [4] = (int) box;
 891    reg_set.r [5] = gcol_action;
 892    reg_set.r [6] = (int) trans_mat;
 893    reg_set.r [7] = (int) pix_trans;
 894    return sprite__op (&reg_set);
 895 }
 896
 897 os_error *sprite_put_pgm (sprite_area *area,
 898                           sprite_id *id,
 899                           int gcol_action,
 900                           sprite_box *box,
 901                           sprite_pgm *pgm,
 902                           sprite_pixtrans *pix_trans)
 903 {
 904    os_regset reg_set;
 905    setfromtag (PutSpriteTransformed, area, id, &reg_set);
 906    reg_set.r [3] = (box == NULL? 0: 1 << 1) | (1 << 0);
 907    reg_set.r [4] = (int) box;
 908    reg_set.r [5] = gcol_action;
 909    reg_set.r [6] = (int) pgm;
 910    reg_set.r [7] = (int) pix_trans;
 911    return sprite__op (&reg_set);
 912 }
 913
 914 #pragma check_stack
 915
 916 /* end of c.sprite */