![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to pointer.asm CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [WindowsNT SDKs] / ntddk / src / video / displays / vga / i386|
Return to pointer.asm CVS log | Up to [WindowsNT SDKs] / ntddk / src / video / displays / vga / i386 |
1.1 ! root 1: page ,132 ! 2: ;-----------------------------Module-Header-----------------------------; ! 3: ; Module Name: POINTER.ASM ! 4: ; ! 5: ; This file contains the pointer shape routines required to draw the ! 6: ; pointer shape on the EGA. ! 7: ; ! 8: ; Copyright (c) 1992 Microsoft Corporation ! 9: ; ! 10: ; Exported Functions: none ! 11: ; ! 12: ; Public Functions: xyCreateMasks ! 13: ; vDrawPointer ! 14: ; vYankPointer ! 15: ; ! 16: ; General Description: ! 17: ; ! 18: ; All display drivers must support a "pointer" for the pointing ! 19: ; device. The pointer is a small graphics image which is allowed ! 20: ; to move around the screen independantly of all other operations ! 21: ; to the screen, and is normally bound to the location of the ! 22: ; pointing device. The pointer is non-destructive in nature, i.e. ! 23: ; the bits underneath the pointer image are not destroyed by the ! 24: ; presence of the pointer image. ! 25: ; ! 26: ; A pointer consists of an AND mask and an XOR mask, which give ! 27: ; combinations of 0's, 1's, display, or inverse display. ! 28: ; ! 29: ; AND XOR | DISPLAY ! 30: ; ---------------------- ! 31: ; 0 0 | 0 ! 32: ; 0 1 | 1 ! 33: ; 1 0 | Display ! 34: ; 1 1 | Not Display ! 35: ; ! 36: ; The pointer also has a "hot spot", which is the pixel of the ! 37: ; pointer image which is to be aligned with the actual pointing ! 38: ; device location. ! 39: ; ! 40: ; ! 41: ; | For a pointer like this, the hot spot ! 42: ; | would normally be the *, which would ! 43: ; ---*--- be aligned with the pointing device ! 44: ; | position ! 45: ; | ! 46: ; ! 47: ; The pointer may be moved to any location on the screen, be ! 48: ; restricted to only a section of the screen, or made invisible. ! 49: ; Part of the pointer may actually be off the edge of the screen, ! 50: ; and in such a case only the visible portion of the pointer ! 51: ; image is displayed. ! 52: ; ! 53: ; ! 54: ; ! 55: ; Logically, the pointer image isn't part of the physical display ! 56: ; surface. When a drawing operation coincides with the pointer ! 57: ; image, the result is the same as if the pointer image wasn't ! 58: ; there. In reality, if the pointer image is part of the display ! 59: ; surface it must be removed from memory before the drawing ! 60: ; operation may occur, and redrawn at a later time. ! 61: ; ! 62: ; This exclusion of the pointer image is the responsibility of ! 63: ; the display driver. If the pointer image is part of physical ! 64: ; display memory, then all output operations must perform a hit ! 65: ; test to determine if the pointer must be removed from display ! 66: ; memory, and set a protection rectangle wherein the pointer must ! 67: ; not be displayed. The actual pointer image drawing routine ! 68: ; must honor this protection rectangle by never drawing the ! 69: ; pointer image within its boundary. ! 70: ; ! 71: ; This code doesn't distinguish between pointers and icons, ! 72: ; they both are the same size, 32 x 32, which comes out square. ! 73: ; ! 74: ; Restrictions: ! 75: ; ! 76: ; All routines herein assume protection either via cli/sti ! 77: ; or a semephore at higher level code. ! 78: ; ! 79: ;-----------------------------------------------------------------------; ! 80: ! 81: .386 ! 82: ! 83: ifndef DOS_PLATFORM ! 84: .model small,c ! 85: else ! 86: ifdef STD_CALL ! 87: .model small,c ! 88: else ! 89: .model small,pascal ! 90: endif; STD_CALL ! 91: endif; DOS_PLATFORM ! 92: ! 93: ASSUME CS: FLAT, DS: FLAT, SS: FLAT, ES: FLAT ! 94: assume FS: NOTHING, GS: NOTHING ! 95: ! 96: .xlist ! 97: include stdcall.inc ! 98: include i386\egavga.inc ! 99: include i386\strucs.inc ! 100: .list ! 101: ! 102: PUBLIC PTR_ROUND_RIGHT ;Pointer exclusion needs these ! 103: PUBLIC PTR_ROUND_LEFT ! 104: PUBLIC PTR_WIDTH_BITS ! 105: PUBLIC PTR_HEIGHT ! 106: ! 107: ! 108: ;-----------------------------------------------------------------------; ! 109: ; The following values allow us to set rounding for cursor exclusion. ! 110: ; These values are applied as an AND mask (for rounding left) and as ! 111: ; an OR mask (for rounding right). ! 112: ;-----------------------------------------------------------------------; ! 113: ! 114: ROUNDING_SIZE EQU 8 ;Round to byte boundaries ! 115: .ERRNZ ROUNDING_SIZE AND 111b ;Must be at least byte boundary ! 116: PTR_ROUND_RIGHT EQU ROUNDING_SIZE-1 ! 117: PTR_ROUND_LEFT EQU -ROUNDING_SIZE ! 118: ! 119: ;-----------------------------------------------------------------------; ! 120: ; The RECT_DATA structure is used for describing the rectangles ! 121: ; which will be manipulated by this code. The fields are: ! 122: ; ! 123: ; rd_ptbSave This is the (X,Y) origin of the given rectangle in ! 124: ; the save area. ! 125: ; ! 126: ; rd_ptlScreen This is the (X,Y) origin of the given rectangle on ! 127: ; the screen. ! 128: ; ! 129: ; rd_sizb This is the extents of the rectangle. ! 130: ; ! 131: ; rd_ptbWork This is the (X,Y) origin of the given rectangle in ! 132: ; the work area. ! 133: ;-----------------------------------------------------------------------; ! 134: ! 135: ifdef DUPS_ARE_LEGAL ! 136: ! 137: RECT_DATA STRUC ! 138: rd_ptbSave DW ((SIZE POINTB)/2) DUP (0) ! 139: rd_ptlScreen DW ((SIZE POINTL)/2) DUP (0) ! 140: rd_sizb DW ((SIZE SIZEB)/2) DUP (0) ! 141: rd_ptbWork DW ((SIZE POINTB)/2) DUP (0) ! 142: RECT_DATA ENDS ! 143: .ERRNZ SIZE POINTB AND 1 ! 144: .ERRNZ SIZE POINTL AND 1 ! 145: .ERRNZ SIZE SIZEB AND 1 ! 146: ! 147: else ! 148: ! 149: RECT_DATA STRUC ! 150: rd_ptbSave dw 0 ; POINTB ! 151: rd_ptlScreen dd 0,0 ; POINTL ! 152: rd_sizb dw 0 ; SIZEB ! 153: rd_ptbWork dw 0 ; POINTB ! 154: RECT_DATA ENDS ! 155: .ERRNZ (SIZE POINTB) - 2 ! 156: .ERRNZ (SIZE POINTL) - 8 ! 157: .ERRNZ (SIZE SIZEB) - 2 ! 158: ! 159: endif ! 160: ! 161: ! 162: ! 163: ;-----------------------------------------------------------------------; ! 164: ; The POINTER_DATA structure is used for describing the actual pointer's ! 165: ; rectangle. It also contains clipping information and control flags. ! 166: ; The fields are: ! 167: ; ! 168: ; pd_rd RECT_DATA structure as defined above ! 169: ; ! 170: ; pd_fb Flags as follows: ! 171: ; ! 172: ; PD_VALID 1 The rectangle contains valid data. ! 173: ; 0 The rectangle data is invalid. ! 174: ; ! 175: ; PD_CLIP_BOTTOM 1 Clip the bottom ! 176: ; 0 No bottom clipping needed ! 177: ; ! 178: ; PD_CLIP_TOP 1 Clip the top ! 179: ; 0 No top clipping needed ! 180: ; ! 181: ; PD_CLIP_LEFT 1 Clip the lhs ! 182: ; 0 No lhs clipping needed ! 183: ; ! 184: ; PD_CLIP_RIGHT 1 Clip the rhs ! 185: ; 0 No rhs clipping needed ! 186: ;-----------------------------------------------------------------------; ! 187: ! 188: ifdef DUPS_ARE_LEGAL ! 189: ! 190: POINTER_DATA STRUC ! 191: pd_rd DW ((SIZE RECT_DATA)/2) DUP (0) ! 192: pd_fb DB 0 ! 193: DB 0 ! 194: POINTER_DATA ENDS ! 195: .ERRNZ SIZE RECT_DATA AND 1 ! 196: ! 197: else ! 198: ! 199: POINTER_DATA struc ! 200: pd_rd dw 0,0,0,0,0,0,0 ; RECT_DATA ! 201: pd_fb db 0 ! 202: db 0 ! 203: POINTER_DATA ends ! 204: .ERRNZ (size POINTER_DATA) - (SIZE RECT_DATA) - 2 ! 205: ! 206: endif ! 207: ! 208: ! 209: PD_CLIP_BOTTOM EQU 10000000b ! 210: PD_CLIP_TOP EQU 01000000b ! 211: PD_CLIP_RIGHT EQU 00100000b ! 212: PD_CLIP_LEFT EQU 00010000b ! 213: PD_VALID EQU 00001000b ! 214: ; EQU 00000100b ! 215: ; EQU 00000010b ! 216: ; EQU 00000001b ! 217: ! 218: PD_CLIPPED EQU PD_CLIP_BOTTOM OR PD_CLIP_TOP OR PD_CLIP_RIGHT OR PD_CLIP_LEFT ! 219: ! 220: ! 221: .DATA ! 222: ! 223: PUBLIC pdPtr1 ! 224: PUBLIC pdPtr2 ! 225: PUBLIC rdFlushX ! 226: PUBLIC rdFlushY ! 227: PUBLIC rdOverlap ! 228: PUBLIC rdReadX ! 229: PUBLIC rdReadY ! 230: PUBLIC rdWork ! 231: ! 232: ! 233: ; Offsets of locations in the EGA/VGA's address ! 234: ; space used both to determine and save the state of the EGA/VGA. ! 235: ; ! 236: ; The actual address within the EGA/VGA's Regen RAM is determined ! 237: ; at init time, and is based on the number of vertical scans. ! 238: ! 239: EXTRN pPtrSave : DWORD ;offset from bitmap start of pointer ! 240: EXTRN pPtrWork : DWORD ; work areas ! 241: ! 242: ; !!! This temp flag is a stupid hack to know if the pointer is color or ! 243: ; !!! mono. Fix it up ! 244: ! 245: ! 246: flPointer dd 0 ! 247: ! 248: ! 249: ! 250: pdPtr1 POINTER_DATA <> ;Old/New pointer's data ! 251: pdPtr2 POINTER_DATA <> ;Old/New pointer's data ! 252: rdFlushX RECT_DATA <> ;Flush from save area to screen ! 253: rdFlushY RECT_DATA <> ;Flush from save area to screen ! 254: rdOverlap RECT_DATA <> ;And from save area to work area ! 255: rdReadX RECT_DATA <> ;Read from screen to save, xor to work ! 256: rdReadY RECT_DATA <> ;Read from screen to save, xor to work ! 257: rdWork RECT_DATA <> ;Xor from work to screen ! 258: ! 259: ! 260: ;-----------------------------------------------------------------------; ! 261: ; siz?Mask contains the width and height of the working portion of ! 262: ; the current AND and XOR mask. Use of this allows us to manipulate ! 263: ; less memory when parts of the pointer won't alter the screen image. ! 264: ;-----------------------------------------------------------------------; ! 265: ! 266: sizbMask SIZEB <WORK_WIDTH,PTR_HEIGHT> ! 267: sizlMask SIZEL <WORK_WIDTH,PTR_HEIGHT> ! 268: ! 269: ! 270: ;-----------------------------------------------------------------------; ! 271: ; sizsMaxDelta is the maximum distance the old and new pointers may ! 272: ; be before they are considered disjoint. ! 273: ;-----------------------------------------------------------------------; ! 274: ! 275: sizlMaxDelta SIZEL <WORK_WIDTH,WORK_HEIGHT> ! 276: ! 277: ! 278: ;-----------------------------------------------------------------------; ! 279: ; ptlBotRightClip is the coordinate where rhs or bottom clipping ! 280: ; will first occur. It is basically the screen width - pointer width. ! 281: ;-----------------------------------------------------------------------; ! 282: ! 283: ptlBotRightClip POINTL <0,0> ! 284: ! 285: ! 286: ;-----------------------------------------------------------------------; ! 287: ; This is the initial origin in the save buffer. ! 288: ;-----------------------------------------------------------------------; ! 289: ! 290: ptbInitOrigin POINTB <0,0> ! 291: ! 292: ! 293: ;-----------------------------------------------------------------------; ! 294: ; ppdOld is the pointer to the old pointer's POINTER_DATA structure ! 295: ;-----------------------------------------------------------------------; ! 296: ! 297: ppdOld DD offset FLAT:pdPtr1 ! 298: ! 299: ! 300: ;-----------------------------------------------------------------------; ! 301: ; ppdNew is the pointer to the new pointer's POINTER_DATA structure ! 302: ;-----------------------------------------------------------------------; ! 303: ! 304: ppdNew DD offset FLAT:pdPtr2 ! 305: ! 306: ! 307: ;-----------------------------------------------------------------------; ! 308: ; pAndXor is the pointer to which AND/XOR mask is to be used. It is ! 309: ; based on the 3 least significant bits of the pointer's X coordinate. ! 310: ; pColor is the pointer to which COLOR mask is to be used. ! 311: ;-----------------------------------------------------------------------; ! 312: ! 313: pAndXor DD -1 ! 314: pColor DD -1 ! 315: ! 316: ! 317: ;-----------------------------------------------------------------------; ! 318: ; The following are the masks which make up the pointer image. There ! 319: ; will be one AND/XOR/COLOR mask pair for each possible alignment. On ! 320: ; move_pointers call, all the alignments will be generated to save time. ! 321: ;-----------------------------------------------------------------------; ! 322: ! 323: public base_and_masks ! 324: public base_xor_masks ! 325: public base_clr_masks ! 326: ! 327: base_and_masks EQU THIS BYTE ! 328: REPT (MASK_LENGTH * 8) ! 329: DB ? ! 330: ENDM ! 331: ! 332: base_xor_masks EQU THIS BYTE ! 333: REPT (MASK_LENGTH * 8) ! 334: DB ? ! 335: ENDM ! 336: ! 337: base_clr_masks EQU THIS BYTE ! 338: REPT (CLR_MASK_LENGTH * 8) ! 339: DB ? ! 340: ENDM ! 341: ! 342: ;-----------------------------------------------------------------------; ! 343: ; pabAndMasks is an array which points to the start of the mask for ! 344: ; each X rotation. It is indexed into using the low 3 bits of the ! 345: ; pointer's X coordinate. ! 346: ;-----------------------------------------------------------------------; ! 347: ! 348: pabAndMasks EQU THIS DWORD ! 349: DD offset FLAT:base_and_masks+(0*MASK_LENGTH) ! 350: DD offset FLAT:base_and_masks+(1*MASK_LENGTH) ! 351: DD offset FLAT:base_and_masks+(2*MASK_LENGTH) ! 352: DD offset FLAT:base_and_masks+(3*MASK_LENGTH) ! 353: DD offset FLAT:base_and_masks+(4*MASK_LENGTH) ! 354: DD offset FLAT:base_and_masks+(5*MASK_LENGTH) ! 355: DD offset FLAT:base_and_masks+(6*MASK_LENGTH) ! 356: DD offset FLAT:base_and_masks+(7*MASK_LENGTH) ! 357: ! 358: ;-----------------------------------------------------------------------; ! 359: ; pabClrMasks is an array which points to the start of the mask for ! 360: ; each X rotation. It is indexed into using the low 3 bits of the ! 361: ; pointer's X coordinate. ! 362: ;-----------------------------------------------------------------------; ! 363: ! 364: pabClrMasks EQU THIS DWORD ! 365: DD offset FLAT:base_clr_masks+(0*CLR_MASK_LENGTH) ! 366: DD offset FLAT:base_clr_masks+(1*CLR_MASK_LENGTH) ! 367: DD offset FLAT:base_clr_masks+(2*CLR_MASK_LENGTH) ! 368: DD offset FLAT:base_clr_masks+(3*CLR_MASK_LENGTH) ! 369: DD offset FLAT:base_clr_masks+(4*CLR_MASK_LENGTH) ! 370: DD offset FLAT:base_clr_masks+(5*CLR_MASK_LENGTH) ! 371: DD offset FLAT:base_clr_masks+(6*CLR_MASK_LENGTH) ! 372: DD offset FLAT:base_clr_masks+(7*CLR_MASK_LENGTH) ! 373: ! 374: ;-----------------------------------------------------------------------; ! 375: ; The following flags and flag bytes are used to control which ! 376: ; rectangles are used for what. ! 377: ; ! 378: ; fbFlush controls which rectangles are to be copied from the save ! 379: ; area to the screen. Valid flags are: ! 380: ; ! 381: ; FB_OLD_PTR, FB_FLUSH_X, FB_FLUSH_Y ! 382: ; ! 383: ; FB_OLD_PTR is mutually exclusive of all other flags ! 384: ; ! 385: ; ! 386: ; fbAndRead controls which rectangles are to be ANDed into the work ! 387: ; area from the screen or save area, and which rectangles are to be ! 388: ; copied from the screen to the save area. Valid flags are: ! 389: ; ! 390: ; FB_NEW_PTR, FB_OVERLAP, FB_READ_X, FB_READ_Y, FB_WORK_RECT, ! 391: ; ! 392: ; FB_NEW_PTR and FB_WORK_RECT are mutually exclusive of all other ! 393: ; flags. Note that FB_OVERLAP doesn't apply when coping into the ! 394: ; save area. ! 395: ; ! 396: ; ! 397: ; fbXor describes which rectangle is to be XORed from the work area ! 398: ; into the screen. Valid flags are: ! 399: ; ! 400: ; FB_NEW_PTR, FB_WORK_RECT ! 401: ; ! 402: ; FB_NEW_PTR and FB_WORK_RECT are mutually exclusive ! 403: ;-----------------------------------------------------------------------; ! 404: ! 405: fbFlush DB 0 ! 406: fbAndRead DB 0 ! 407: fbXor DB 0 ! 408: FB_OLD_PTR EQU 10000000b ! 409: FB_NEW_PTR EQU 01000000b ! 410: FB_FLUSH_X EQU 00100000b ! 411: FB_FLUSH_Y EQU 00010000b ! 412: FB_OVERLAP EQU 00001000b ! 413: FB_READ_X EQU 00000100b ! 414: FB_READ_Y EQU 00000010b ! 415: FB_WORK_RECT EQU 00000001b ! 416: ! 417: ; Temporary work buffer. We copy the masks and color data here before ! 418: ; we decide how to flip them. !!! Costly use of static space. Use frame ! 419: ! 420: public alWorkBuff ! 421: ! 422: ! 423: alWorkBuff EQU THIS DWORD ! 424: REPT (2 * PTR_HEIGHT) ! 425: DD ? ! 426: ENDM ! 427: ! 428: ! 429: ; Table of entry points into and_from_screen inner loop ! 430: ! 431: align 4 ! 432: and_from_screen_entry_table label dword ! 433: dd and_from_screen_width_0 ! 434: dd and_from_screen_width_1 ! 435: dd and_from_screen_width_2 ! 436: dd and_from_screen_width_3 ! 437: dd and_from_screen_width_4 ! 438: dd and_from_screen_width_5 ! 439: ! 440: ! 441: ; Table of entry points into and_from_save inner loop ! 442: ! 443: align 4 ! 444: and_from_save_entry_table label dword ! 445: dd and_from_save_width_0 ! 446: dd and_from_save_width_1 ! 447: dd and_from_save_width_2 ! 448: dd and_from_save_width_3 ! 449: dd and_from_save_width_4 ! 450: dd and_from_save_width_5 ! 451: ! 452: ! 453: ; Table of entry points into cps_do_a_pass inner loop ! 454: ! 455: align 4 ! 456: color_to_screen_entry_table label dword ! 457: dd color_to_screen_width_0 ! 458: dd color_to_screen_width_1 ! 459: dd color_to_screen_width_2 ! 460: dd color_to_screen_width_3 ! 461: dd color_to_screen_width_4 ! 462: dd color_to_screen_width_5 ! 463: ! 464: ;------------------------------------------------------------------------; ! 465: ! 466: .CODE ! 467: ! 468: _TEXT$01 SEGMENT DWORD USE32 PUBLIC 'CODE' ! 469: ASSUME CS:FLAT, DS:FLAT, ES:FLAT, SS:NOTHING, FS:NOTHING, GS:NOTHING ! 470: ! 471: ;--------------------------Public-Routine-------------------------------; ! 472: ; xyCreateMasks ! 473: ; ! 474: ; The AND, XOR and COLOR pointer masks are stored in the pointer work ! 475: ; areas. The original mask will be pre-rotated for all eight ! 476: ; possible alignments within a byte. ! 477: ; ! 478: ; As the pointer is copied, it will be processed to see if it ! 479: ; can be made narrower. After it has been copied, it will be ! 480: ; processed to see if it can be made shorter. ! 481: ; ! 482: ; The following table indicates how the XOR/AND bitmap interacts with ! 483: ; the COLOR bitmap for a color system: ! 484: ; ! 485: ; XOR AND COLOR Result ! 486: ; 1 1 x invert screen ! 487: ; 0 0 x use x ! 488: ; 0 1 x transparent ! 489: ; 1 0 x use x ! 490: ; ! 491: ; From the table, we observe that when the AND bits are on, the ! 492: ; corresponding COLOR bits are irrelevant. We preprocess the ! 493: ; COLOR bitmap to mask off these bits. ! 494: ; ! 495: ; When drawing the color pointer, we do the following steps: ! 496: ; 1. XOR the destination with XOR mask. ! 497: ; 2. AND the destination with AND mask. Note the zero bits ! 498: ; would mask off the destination to prepare for the COLOR mask. ! 499: ; 3. OR the destination with the COLOR mask. Note it does not ! 500: ; affect the inverted or transparent bits since we have masked ! 501: ; off the corresponding COLOR bits during preprocessing. ! 502: ; ! 503: ; Entry: ! 504: ; ! 505: ; Returns: ! 506: ; AX = width in pels for exclusion hit test ! 507: ; DX = height in scans for exclusion hit test ! 508: ; Error Returns: ! 509: ; None ! 510: ; Registers Preserved: ! 511: ; BP ! 512: ; Registers Destroyed: ! 513: ; AX,BX,CX,DX,SI,DI,FLAGS ! 514: ; Calls: ! 515: ; create_masks_1_thru_7 ! 516: ; ! 517: ;-----------------------------------------------------------------------; ! 518: ! 519: cProc xyCreateMasks,24,< \ ! 520: USES esi edi ebx, \ ! 521: ppdev:PTR, \ ! 522: pBitsAndXor:PTR, \ ! 523: pBitsColor:PTR, \ ! 524: cyHeight:DWORD, \ ! 525: pulXlate:DWORD, \ ! 526: wFlags:WORD > ! 527: ! 528: local cyScreen:dword ;height of bitmap in scans ! 529: local lNextScan:dword ;width of bitmap in bytes ! 530: local ajColorBits[PTR_WIDTH*PTR_HEIGHT*4]:byte ! 531: local aulXlate[16]:dword ! 532: ! 533: cld ! 534: ! 535: mov ecx,ppdev ! 536: mov eax,[ecx].PDEV_sizlSurf.sizl_cy ! 537: mov cyScreen,eax ! 538: mov ecx,[ecx].PDEV_pdsurf ! 539: mov eax,[ecx].dsurf_lNextScan ! 540: mov lNextScan,eax ! 541: ! 542: cmp pBitsColor,0 ! 543: jne short xycm_have_color ! 544: ; Copy the AND/XOR mask into the work buffer ! 545: ! 546: mov esi,pBitsAndXor ! 547: mov ecx,cyHeight ! 548: mov bx,wFlags ! 549: shl ecx,1 ! 550: mov edi,offset FLAT:alWorkBuff ! 551: rep movsd ;copy AND mask ! 552: jmp short xycm_continue ! 553: ! 554: xycm_have_color: ! 555: ! 556: ; If a color translation vector was given, generate the new bit ! 557: ; conversion array ! 558: ! 559: mov eax,offset FLAT:aulDefBitMapping ! 560: cld ! 561: mov esi,pulXlate ! 562: or esi,esi ! 563: jz have_mapping_array ! 564: lea edi,aulXlate ! 565: mov ecx,16 ! 566: create_next_bit_mapping: ! 567: lodsd ! 568: mov eax,aulDefBitMapping[eax*4] ! 569: stosd ! 570: dec ecx ! 571: jnz create_next_bit_mapping ! 572: lea eax,[edi][-16*4] ! 573: have_mapping_array: ! 574: mov pulXlate,eax ! 575: ! 576: ; Copy the AND mask into the work buffer ! 577: ! 578: mov edi,offset FLAT:alWorkBuff ! 579: test wFlags,PTRI_INVERT ;are masks backwards? ! 580: jz @F ; NO ! 581: mov edi,offset FLAT:alWorkBuff + (4*PTR_HEIGHT) ! 582: @@: ! 583: mov esi,pBitsAndXor ! 584: mov ecx,cyHeight ! 585: rep movsd ;copy AND mask ! 586: ! 587: ; later on we will flip the AND and XOR masks, so we have to mix them ! 588: ; up now else there will be problems later. ! 589: ! 590: mov esi,pBitsColor ;Source color bits ! 591: lea edi,ajColorBits ;Where to store color ! 592: mov ecx,cyHeight ! 593: mov dx,wFlags ! 594: push ebp ! 595: mov ebp,pulXlate ! 596: call vConvertDIBPointer ! 597: pop ebp ! 598: ! 599: xycm_continue: ! 600: mov ebx,cyHeight ! 601: mov dx,wFlags ! 602: cCall vCopyMasks ;Pad and maybe flip masks ! 603: ! 604: ;-----------------------------------------------------------------------; ! 605: ; The image we are copying is PTR_WIDTH bytes wide. We must add an ! 606: ; extra byte to make it WORK_WIDTH wide. The byte we add will depends ! 607: ; on whether this is the AND or the XOR mask. For an AND mask, we add ! 608: ; an FF byte on the end of each scan. For an XOR mask, we add a 00 ! 609: ; byte on the end of each scan. For the COLOR mask, we add a 00 byte on ! 610: ; the end of each scan of all planes. These bytes won't alter anything ! 611: ; on the screen. ! 612: ;-----------------------------------------------------------------------; ! 613: ! 614: mov esi,offset FLAT:alWorkBuff ;ESI --> AND/XOR mask ! 615: ! 616: ;-----------------------------------------------------------------------; ! 617: ; Copy the AND mask over. As we copy it, accumulate the value of ! 618: ; each column of the mask. If the entire column is FF, we may be ! 619: ; able to discard it. ! 620: ;-----------------------------------------------------------------------; ! 621: ! 622: mov edi, offset FLAT:base_and_masks ! 623: mov ecx, PTR_HEIGHT ;Set height for move ! 624: mov ebx, 0FFFFFFFFh ;Accumulate mask columns ! 625: ! 626: move_next_and_mask_scan: ! 627: lodsd ;Move explicit part ! 628: stosd ! 629: and ebx, eax ! 630: mov al, 0FFh ! 631: stosb ! 632: .ERRNZ PTR_WIDTH-4 ! 633: .ERRNZ WORK_WIDTH-5 ! 634: loop move_next_and_mask_scan ! 635: push ebx ;Save AND column mask ! 636: mov edx, offset FLAT:base_and_masks ! 637: mov ecx, (MASK_LENGTH*7)/(WORK_WIDTH*2) ! 638: .ERRNZ (MASK_LENGTH*7) mod (WORK_WIDTH*2) ! 639: cCall create_masks_1_thru_7 ! 640: ! 641: ;-----------------------------------------------------------------------; ! 642: ; Copy the XOR mask over. As we copy it, accumulate the value of ! 643: ; each column of the mask. If the entire column is 00, we may be ! 644: ; able to discard it. ! 645: ;-----------------------------------------------------------------------; ! 646: ! 647: mov edi, offset FLAT:base_xor_masks ! 648: mov ecx, PTR_HEIGHT ;Set height for move ! 649: xor ebx, ebx ;Accumulate columns of the mask ! 650: ! 651: move_next_xor_mask_scan: ! 652: lodsd ;Move explicit part ! 653: stosd ! 654: or ebx, eax ! 655: xor al, al ! 656: stosb ! 657: .ERRNZ PTR_WIDTH-4 ! 658: .ERRNZ WORK_WIDTH-5 ! 659: loop move_next_xor_mask_scan ! 660: push ebx ! 661: mov edx, offset FLAT:base_xor_masks ! 662: mov ecx, (MASK_LENGTH*7)/(WORK_WIDTH*2) ! 663: .ERRNZ (MASK_LENGTH*7) mod (WORK_WIDTH*2) ! 664: cCall create_masks_1_thru_7 ! 665: ! 666: ;-----------------------------------------------------------------------; ! 667: ; The masks have been copied. Compute the number of columns which can ! 668: ; be discarded. To discard a column, all bits of the AND mask for that ! 669: ; column must be 1, and all bits of the XOR mask for the column must be ! 670: ; 0. Since we work with bytes in this code, this must be true for an ! 671: ; entire byte. ! 672: ; ! 673: ; Also note that the columns must be processed right to left. We cannot ! 674: ; throw out a middle column if its neighbors contain data. ! 675: ;-----------------------------------------------------------------------; ! 676: ! 677: ;AND mask, EAX[0] = byte 1, EAX[1] = byte 2 ! 678: ;AND mask, EAX[2] = byte 3, EAX[3] = byte 4 ! 679: ;XOR mask, EBX[0] = byte 1, EBX[1] = byte 2 ! 680: ;XOR mask, EBX[2] = byte 3, EBX[3] = byte 4 ! 681: ! 682: pop ebx ;EBX XOR mask ! 683: pop eax ;EAX AND mask ! 684: ! 685: not eax ! 686: or eax, ebx ;Discard only if both are zero! ! 687: ! 688: mov ebx, WORK_WIDTH ! 689: mov edx, PTR_HEIGHT ;assume full mask ! 690: xor ecx, ecx ! 691: ;check wFlags ! 692: test wFlags, PTRI_ANIMATE ! 693: jnz mp_have_sizes ! 694: ! 695: ; !!! Until conversion of pointer images is handled via bitblt, always ! 696: ; !!! treat color cursors as full size ! 697: cmp pBitsColor,0 ;!!! ! 698: jne mp_have_sizes ;!!! ! 699: ! 700: mov edx,eax ;DX = bytes 1 and 2 ! 701: shr eax,16 ;AX = bytes 3 and 4 ! 702: or ah,ah ;Discard 4th byte of mask? ! 703: jnz @F ; No ! 704: dec ebx ! 705: or al,al ! 706: jnz @F ! 707: dec ebx ! 708: or dh,dh ! 709: jnz @F ! 710: dec ebx ! 711: or dl,dl ! 712: jz move_pointers_done ;AX = DX = 0 for return codes ! 713: @@: ! 714: ! 715: ;-----------------------------------------------------------------------; ! 716: ; Compute the number of rows which can be discarded off the bottom. ! 717: ; To discard a row, all bits of the AND mask for that row must be a ! 718: ; 1, and all bits of the XOR mask for that row must be 0. ! 719: ;-----------------------------------------------------------------------; ! 720: ! 721: .ERRNZ PTR_WIDTH AND 1 ;Must be a word multiple ! 722: ! 723: dec esi ;Post decremnent, not pre decrement ! 724: dec esi ! 725: lea edi, [esi][-PTR_WIDTH*PTR_HEIGHT] ;Last word of AND mask ! 726: mov ecx, (PTR_WIDTH/2)*PTR_HEIGHT ! 727: mov ax, 0FFFFh ;Processing AND mask ! 728: std ! 729: repe scasw ! 730: mov edx, ecx ;Save count ! 731: mov edi, esi ;--> XOR mask ! 732: mov ecx, (PTR_WIDTH/2)*PTR_HEIGHT ! 733: xor eax, eax ;Processing XOR mask ! 734: repe scasw ! 735: cld ;Take care of this while we remember ! 736: cmp ecx, edx ;Want |cx| to be the largest ! 737: ja @F ! 738: xchg ecx, edx ! 739: @@: ! 740: ;-----------------------------------------------------------------------; ! 741: ; CX >> 1 +1 ! 742: ; ! 743: ; 63 31 32 1st word did not match, don't chop any scans ! 744: ; 62 31 32 2nd word did not match, don't chop any scans ! 745: ; 61 30 31 3rd word did not match, chop 1 scan ! 746: ; 60 30 31 4th word did not match, chop 1 scan ! 747: ;-----------------------------------------------------------------------; ! 748: ! 749: .ERRNZ PTR_WIDTH-4 ! 750: ! 751: shr ecx, 1 ! 752: inc ecx ;ECX = working height ! 753: mov edx, PTR_HEIGHT ! 754: sub edx, ecx ;EDX = # scans chopped off bottom ! 755: xchg ecx, edx ;Height in DX for returning ! 756: ! 757: ; EBX = working width of the pointer image in bytes. ECX = amount to ! 758: ; chop of the bottom of the pointer image. EDX = working height of ! 759: ; the pointer image. ! 760: ! 761: mp_have_sizes: ! 762: mov eax, ebx ! 763: mov sizlMask.sizl_cx, eax ! 764: mov sizlMaxDelta.sizl_cx, eax ! 765: mov ah, dl ! 766: mov sizbMask, ax ! 767: ! 768: .ERRNZ sizb_cy-sizb_cx-1 ! 769: ! 770: mov eax, edx ! 771: mov sizlMask.sizl_cy, eax ! 772: mov sizlMaxDelta.sizl_cy, eax ! 773: neg eax ! 774: add eax, cyScreen ! 775: mov ptlBotRightClip.ptl_y, eax ! 776: mov eax, lNextScan ! 777: sub eax, ebx ! 778: mov ptlBotRightClip.ptl_x, eax ! 779: shr ecx, 1 ! 780: mov eax, WORK_WIDTH ! 781: sub eax, ebx ! 782: shr eax, 1 ! 783: mov ah, cl ! 784: mov ptbInitOrigin, ax ! 785: ! 786: .ERRNZ ptb_y-ptb_x-1 ! 787: ! 788: mov eax, ebx ! 789: dec eax ! 790: shl eax, 3 ;Bit count is needed ! 791: ! 792: shl edx, 16 ;Return value in upper word of EAX ! 793: or eax, edx ; is cyPointer, lower word of EAX ! 794: push eax ; is cxPointer. ! 795: ! 796: ;-----------------------------------------------------------------------; ! 797: ; Finally, copy the COLOR mask over. As we copy it, mask off the ! 798: ; corresponding AND bits in the COLOR mask since we do not use that ! 799: ; color bit if the AND bit is on. ! 800: ; ! 801: ; XOR AND COLOR ! 802: ; 1 1 invert screen ! 803: ; 0 0 use color ! 804: ; 0 1 transparent ! 805: ; 1 0 use color ! 806: ; ! 807: ;-----------------------------------------------------------------------; ! 808: ! 809: mov ecx, pBitsColor ! 810: jecxz move_color_pointer_done ;pBitsColor was set to null ! 811: lea esi, ajColorBits ! 812: mov edi, offset FLAT:base_clr_masks ! 813: push ebp ;Need extra loop counter ! 814: mov ebp, BITS_PEL ! 815: ! 816: move_next_color_mask_plane: ! 817: mov ecx, PTR_HEIGHT ;Set height for move ! 818: mov ebx, offset FLAT:base_and_masks ! 819: sub ebx, edi ;make it relative ! 820: ! 821: move_next_color_mask_scan: ! 822: ifdef WITH_AND_MASK ! 823: lodsw ;Copy a scan from the current plane ! 824: mov dx, [ebx][edi] ;Mask off the corresponding AND bits ! 825: not dx ! 826: and ax, dx ! 827: stosw ! 828: lodsw ! 829: mov dx, [ebx][edi] ! 830: not dx ! 831: and ax, dx ! 832: stosw ! 833: else ! 834: movsd ! 835: endif ! 836: xor al, al ! 837: stosb ! 838: ! 839: .ERRNZ PTR_WIDTH-4 ! 840: .ERRNZ WORK_WIDTH-5 ! 841: ! 842: add esi, (BITS_PEL-1)*PTR_WIDTH ! 843: loop move_next_color_mask_scan ! 844: sub esi, (BITS_PEL*PTR_WIDTH*PTR_HEIGHT)-PTR_WIDTH ! 845: dec ebp ! 846: jnz move_next_color_mask_plane ! 847: pop ebp ;Restore register ! 848: ! 849: mov edx, offset FLAT:base_clr_masks ! 850: mov ecx, (CLR_MASK_LENGTH*7)/(WORK_WIDTH*2) ! 851: ! 852: .ERRNZ (CLR_MASK_LENGTH*7) MOD (WORK_WIDTH*2) ! 853: ! 854: cCall create_masks_1_thru_7 ! 855: ! 856: move_color_pointer_done: ! 857: ! 858: pop eax ;return results in EAX ! 859: ! 860: move_pointers_done: ! 861: mp_exit: ! 862: cRet xyCreateMasks ! 863: ! 864: endProc xyCreateMasks ! 865: ! 866: ;-------------------------Private-Routine-------------------------------; ! 867: ; Copy the masks to the work buffer and adjust for use. Two things may ! 868: ; need to be done: ! 869: ; ! 870: ; 1) The masks could be inverted. ! 871: ; 2) The masks may need to be padded out ! 872: ; ! 873: ; Entry: ! 874: ; EBX = number of scan lines in each mask ! 875: ; DX = flags (PTRI_INVERT) ! 876: ; ! 877: ; Returns: ! 878: ; None ! 879: ; ! 880: ; Error Returns: ! 881: ; None ! 882: ; ! 883: ;-----------------------------------------------------------------------; ! 884: ! 885: cProc vCopyMasks ! 886: mov ecx,ebx ;Needed for padding calculations ! 887: test dx,PTRI_INVERT ;are masks backwards? ! 888: jz copy_no_flip ! 889: ! 890: ; This is really annoying. Not only are the masks inverted, but they ! 891: ; are stored in the wrong order. First get the AND and XOR masks into ! 892: ; the correct order. ! 893: ! 894: mov ecx,PTR_HEIGHT ! 895: mov esi,offset FLAT:alWorkBuff ! 896: mov edi,offset FLAT:alWorkBuff + PTR_HEIGHT * 4 ! 897: ! 898: @@: ! 899: mov eax,[esi] ! 900: xchg [edi],eax ! 901: mov [esi],eax ! 902: add esi,4 ! 903: add edi,4 ! 904: loop @B ! 905: ! 906: ; Next, flip them so they are right-side up. ! 907: ! 908: mov ecx,ebx ! 909: mov esi,offset FLAT:alWorkBuff ! 910: cCall vFlipMask ;flip AND mask ! 911: ! 912: mov ecx,ebx ! 913: mov esi,offset FLAT:alWorkBuff + PTR_HEIGHT * 4 ! 914: cCall vFlipMask ;flip XOR mask ! 915: ! 916: ; Now pad out the masks so no junk appears on the screen ! 917: ! 918: copy_no_flip: ! 919: ! 920: mov eax,0FFFFFFFFh ;pad AND mask ! 921: mov ecx,PTR_HEIGHT ! 922: sub ecx,ebx ! 923: mov edi,offset FLAT:alWorkBuff ! 924: lea edi,[edi+4*ebx] ! 925: rep stosd ! 926: ! 927: xor eax,eax ;pad XOR mask ! 928: mov ecx,PTR_HEIGHT ! 929: sub ecx,ebx ! 930: mov edi,offset FLAT:alWorkBuff + PTR_HEIGHT * 4 ! 931: lea edi,[edi+4*ebx] ! 932: rep stosd ! 933: ! 934: cRet vCopyMasks ! 935: ! 936: endProc vCopyMasks ! 937: ! 938: ;-------------------------Private-Routine-------------------------------; ! 939: ; Flip the scans in the buffer ! 940: ; ! 941: ; Entry: ! 942: ; ESI --> start of first scan line ! 943: ; ECX = number of scan lines ! 944: ; ! 945: ; Returns: ! 946: ; None ! 947: ; ! 948: ; Error Returns: ! 949: ; None ! 950: ; ! 951: ;-----------------------------------------------------------------------; ! 952: ! 953: cProc vFlipMask ! 954: lea edi,[esi+4*ecx] ! 955: shr ecx,1 ! 956: ! 957: flip_next_scan: ! 958: sub edi,4 ;decrement target pointer ! 959: ! 960: mov eax,[esi] ;Load ! 961: xchg [edi],eax ;Swap ! 962: mov [esi],eax ;Save ! 963: ! 964: add esi,4 ;increment source pointer ! 965: ! 966: loop flip_next_scan ! 967: ! 968: cRet vFlipMask ! 969: ! 970: endProc vFlipMask ! 971: ! 972: page ! 973: ! 974: ;--------------------------Public-Routine-------------------------------; ! 975: ; create_masks_1_thru_7 ! 976: ; ! 977: ; The pointer shape has been copied into our memory. Now pre-rotate ! 978: ; the pointer for all the different alignments. Simply put: ! 979: ; ! 980: ; pointer image fill byte ! 981: ; ! 982: ; |ABCDEFGH|IJKLMNOP|QRSTUVWX|YZabcdef|00000000| ! 983: ; ! 984: ; becomes this for (x mod 8) = 1 ! 985: ; ! 986: ; |0ABCDEFG|HIJKLMNO|PQRSTUVW|XYZabcde|f0000000| ! 987: ; ! 988: ; and this for (x mod 8) = 2 ! 989: ; ! 990: ; |00ABCDEF|GHIJKLMN|OPQRSTUV|WXYZabcd|ef000000| ! 991: ; ! 992: ; Entry: ! 993: ; EDI --> first byte of mask for phase alignment 1 ! 994: ; EDX --> first byte of mask for phase alignment 0 ! 995: ; ECX = (mask length * 7) / (WORK_WIDTH * 2) ! 996: ; AL = fill value (00 or FF) ! 997: ; Returns: ! 998: ; None ! 999: ; Error Returns: ! 1000: ; None ! 1001: ; Registers Preserved: ! 1002: ; BX,SI,BP ! 1003: ; Registers Destroyed: ! 1004: ; AX,CX,DX,DI ! 1005: ; Calls: ! 1006: ; none ! 1007: ; ! 1008: ;-----------------------------------------------------------------------; ! 1009: ! 1010: cProc create_masks_1_thru_7 ! 1011: ! 1012: ; Since the masks are contiguous, we can do it as one very long loop, ! 1013: ; where the results of rotating the previous mask by one becomes the ! 1014: ; source for the next rotate by one. ! 1015: ! 1016: xchg esi, edx ! 1017: add al, al ;Set initial 'C' value ! 1018: ! 1019: rotate_next_two_scans: ! 1020: lodsw ! 1021: rcr al, 1 ! 1022: rcr ah, 1 ! 1023: stosw ! 1024: ! 1025: lodsw ! 1026: rcr al, 1 ! 1027: rcr ah, 1 ! 1028: stosw ! 1029: ! 1030: lodsw ! 1031: rcr al, 1 ! 1032: rcr ah, 1 ! 1033: stosw ! 1034: ! 1035: lodsw ! 1036: rcr al, 1 ! 1037: rcr ah, 1 ! 1038: stosw ! 1039: ! 1040: lodsw ! 1041: rcr al, 1 ! 1042: rcr ah, 1 ! 1043: stosw ! 1044: ! 1045: loop rotate_next_two_scans ! 1046: ! 1047: .ERRNZ (WORK_WIDTH*2)-10 ! 1048: ! 1049: xchg esi, edx ! 1050: ! 1051: cRet create_masks_1_thru_7 ! 1052: ! 1053: endProc create_masks_1_thru_7 ! 1054: page ! 1055: ! 1056: ;--------------------------Public-Routine-------------------------------; ! 1057: ; vYankPointer ! 1058: ; ! 1059: ; Move the pointer off the right edge of the screen ! 1060: ; ! 1061: ; Returns: ! 1062: ; per vDrawPointer ! 1063: ; Error Returns: ! 1064: ; per vDrawPointer ! 1065: ; Registers Preserved: ! 1066: ; per vDrawPointer ! 1067: ; Registers Destroyed: ! 1068: ; per vDrawPointer ! 1069: ; Calls: ! 1070: ; per vDrawPointer ! 1071: ; Restrictions: ! 1072: ; per vDrawPointer ! 1073: ; ! 1074: ;-----------------------------------------------------------------------; ! 1075: ! 1076: cProc vYankPointer,8,< \ ! 1077: ppdev:ptr PDEV, \ ! 1078: flPtr:DWORD > ! 1079: ! 1080: mov eax,ppdev ! 1081: cCall vDrawPointer,<eax,[eax].PDEV_sizlsurf.sizl_cx, \ ! 1082: [eax].PDEV_sizlsurf.sizl_cy,flPtr> ! 1083: yp_exit: ! 1084: cRet vYankPointer ! 1085: ! 1086: endProc vYankPointer ! 1087: ! 1088: page ! 1089: ! 1090: ;--------------------------Public-Routine-------------------------------; ! 1091: ; vDrawPointer ! 1092: ; ! 1093: ; The pointer shape is drawn on the screen at the given coordinates. ! 1094: ; If it currently is displayed on the screen, it will be removed ! 1095: ; from the old location first. ! 1096: ; ! 1097: ; Entry: ! 1098: ; Returns: ! 1099: ; None ! 1100: ; Error Returns: ! 1101: ; None ! 1102: ; Registers Preserved: ! 1103: ; BP ! 1104: ; Registers Destroyed: ! 1105: ; AX,BX,CX,DX,SI,DI,FLAGS ! 1106: ; Calls: ! 1107: ; compute_rects ! 1108: ; clip_rects ! 1109: ; and_into_work ! 1110: ; copy_things_around ! 1111: ; xor_to_screen ! 1112: ; color_pointer_to_screen ! 1113: ; Restrictions: ! 1114: ; None ! 1115: ; ! 1116: ;-----------------------------------------------------------------------; ! 1117: ! 1118: cProc vDrawPointer,16,< \ ! 1119: USES esi edi ebx, \ ! 1120: ppdev:ptr PDEV, \ ! 1121: ptlX:DWORD, \ ! 1122: ptlY:DWORD, \ ! 1123: flPtr:DWORD > ! 1124: ! 1125: local lNextScan :dword ;width of bitmap in bytes ! 1126: local ulNextSrcScan :dword ;offset to next source scan line ! 1127: local jPostWrapWidth :dword ;post-wrap width ! 1128: local pSaveAddr :dword ;virtual address of save area ! 1129: local jSaveSourceXY :dword ;X and Y coordinates of source point in ! 1130: ; save area ! 1131: local jWorkSourceXY :dword ;X and Y coordinates of source point in ! 1132: ; work area ! 1133: local jNextSaveSourceY :dword ;Y coordinate of start source point in ! 1134: ; save area for next bank ! 1135: local jNextWorkSourceY :dword ;Y coordinate of start source point in ! 1136: ; work area for next bank ! 1137: local pWorkingSave :dword ;save area virtual address ! 1138: local ulScanMinusWorkWidth :dword ;distance to next scan, minus the ! 1139: ; width of the work area ! 1140: local ulCurrentTopScan :dword ;top scan line to which to draw in ! 1141: ; current bank ! 1142: local jScansInBank :dword ;# of scan to do in current bank ! 1143: local cjTotalScans :dword ;# of scans left in operation ! 1144: local ulPtrBankScan :dword ;last scan line in pointer work bank ! 1145: local pdsurf :ptr DEVSURF ;pointer to surface structure to which ! 1146: ; we're drawing ! 1147: ;variables used by cps_do_a_pass ! 1148: local ulDeltaScreen :dword ;offset from one scan to next ! 1149: local ulOffsetSave :dword ;offset in save area ! 1150: local ulOffsetMask :dword ;offset within mask ! 1151: local iPlaneMask :dword ! 1152: ;variables used by ! 1153: ; color_pointer_to_screen ! 1154: local pDest :dword ;pointer to destination address ! 1155: local prclSource :dword ;pointer to source rectangle ! 1156: local cyScreen :dword ;height of screen in scan lines ! 1157: ! 1158: ;-----------------------------------------------------------------------; ! 1159: ! 1160: cld ! 1161: ! 1162: mov ecx,ppdev ! 1163: mov eax,[ecx].PDEV_sizlSurf.sizl_cy ! 1164: mov cyScreen,eax ! 1165: ! 1166: mov ecx,[ecx].PDEV_pdsurf ! 1167: mov pdsurf,ecx ;pointer to target surface ! 1168: ! 1169: mov eax,[ecx].dsurf_ulPtrBankScan ! 1170: mov ulPtrBankScan,eax ;last scan line in pointer work bank ! 1171: ! 1172: mov eax,[ecx].dsurf_lNextScan ! 1173: mov lNextScan,eax ;width of bitmap ! 1174: ! 1175: mov eax, flPtr ! 1176: mov flPointer,eax ;save flags ! 1177: mov edi, ppdNew ;--> new pointer's data goes here ! 1178: mov esi, ppdOld ;--> old pointer's data ! 1179: mov eax, ptlX ;EAX = ptlX ! 1180: mov ebx, eax ! 1181: and ebx, 7 ! 1182: mov edx, pabAndMasks[ebx * 4] ! 1183: mov pAndXor, edx ! 1184: mov edx, pabClrMasks[ebx * 4] ! 1185: mov pColor, edx ! 1186: mov ebx, PD_VALID ;Assume visible ! 1187: sar eax, 3 ;Compute starting byte address (set 'S') ! 1188: mov [edi].pd_rd.rd_ptlScreen.ptl_x, eax ! 1189: ! 1190: ;-----------------------------------------------------------------------; ! 1191: ; Compute any X clipping parameters for the new pointer image. ! 1192: ;-----------------------------------------------------------------------; ! 1193: ! 1194: js clip_lhs_of_pointer ;If X is negative, lhs clipping needed ! 1195: sub eax, ptlBotRightClip.ptl_x ! 1196: jle done_x_clipping ! 1197: mov bh,PD_CLIP_RIGHT ;EAX = amount to clip off rhs ! 1198: jmp finish_x_clip ! 1199: ! 1200: clip_lhs_of_pointer: ! 1201: neg eax ;Want |eax| ! 1202: mov bh, PD_CLIP_LEFT ! 1203: ! 1204: finish_x_clip: ! 1205: cmp eax, sizlMask.sizl_cx ;Width of pointer in bytes ! 1206: jge not_visible ;Clipped away too much ! 1207: or bl, bh ! 1208: done_x_clipping: ! 1209: ! 1210: ;-----------------------------------------------------------------------; ! 1211: ; Compute any Y clipping parameters for the new pointer image. ! 1212: ;-----------------------------------------------------------------------; ! 1213: ! 1214: mov eax, ptlY ! 1215: mov [edi].pd_rd.rd_ptlScreen.ptl_y, eax ! 1216: or eax, eax ! 1217: js clip_top_of_pointer ;If Y is negative, top clipping needed ! 1218: sub eax, ptlBotRightClip.ptl_y ! 1219: jle done_y_clipping ! 1220: mov bh, PD_CLIP_BOTTOM ;AX = amount to clip off bottom ! 1221: jmp finish_y_clip ! 1222: ! 1223: ! 1224: ;-----------------------------------------------------------------------; ! 1225: ; not_visible - the pointer will be totally off the screen. All we ! 1226: ; have to do is to determine if any part of the old pointer is visible ! 1227: ; and remove it if so. ! 1228: ;-----------------------------------------------------------------------; ! 1229: ! 1230: not_visible: ! 1231: test [esi].pd_fb, PD_VALID ! 1232: jz draw_pointer_exit ;No new, no old ! 1233: xor eax, eax ! 1234: mov [edi].pd_fb, al ;Clear PD_VALID flag, clipping flags ! 1235: mov WORD PTR fbAndRead, ax ;Nothing to read/and/xor ! 1236: ! 1237: .ERRNZ fbXor-fbAndRead-1 ! 1238: ! 1239: mov fbFlush, FB_OLD_PTR ;Write old to screen ! 1240: jmp rectangles_been_computed ! 1241: ! 1242: ! 1243: ;-----------------------------------------------------------------------; ! 1244: ; Continue with Y clipping ! 1245: ;-----------------------------------------------------------------------; ! 1246: ! 1247: clip_top_of_pointer: ! 1248: neg eax ;Want |eax| ! 1249: mov bh,PD_CLIP_TOP ! 1250: ! 1251: finish_y_clip: ! 1252: cmp eax, sizlMask.sizl_cy ;Height of pointer in scans ! 1253: jge not_visible ;Clipped away too much ! 1254: or bl, bh ! 1255: ! 1256: done_y_clipping: ! 1257: mov [edi].pd_fb, bl ;Set clipping flags and show valid ! 1258: ! 1259: ;-----------------------------------------------------------------------; ! 1260: ; It looks like some portion of the pointer image will be visible. ! 1261: ; Initialize some of the new pointer's POINTER_DATA structure. ! 1262: ;-----------------------------------------------------------------------; ! 1263: ! 1264: mov ax, sizbMask ;ptbSave will be set by compute_rects ! 1265: mov [edi].pd_rd.rd_sizb, ax ! 1266: ! 1267: .ERRNZ (SIZE SIZEB) - 2 ! 1268: ! 1269: xor ax, ax ! 1270: mov [edi].pd_rd.rd_ptbWork, ax ! 1271: ! 1272: .ERRNZ (SIZE POINTB) - 2 ! 1273: ! 1274: ;-----------------------------------------------------------------------; ! 1275: ; Compute the rectangles describing how things overlap and then clip ! 1276: ; them. ! 1277: ;-----------------------------------------------------------------------; ! 1278: ! 1279: call compute_rects ! 1280: rectangles_been_computed: ! 1281: ! 1282: ;-----------------------------------------------------------------------; ! 1283: ; Set WRITE mode of EGA/VGA ! 1284: ;-----------------------------------------------------------------------; ! 1285: ! 1286: mov dx, EGA_BASE + GRAF_ADDR ! 1287: mov ax, DR_SET SHL 8 + GRAF_DATA_ROT ! 1288: out dx, ax ! 1289: ! 1290: mov ax, M_PROC_WRITE SHL 8 + GRAF_MODE ! 1291: out dx, ax ! 1292: ! 1293: mov ax, 0FF00h + GRAF_BIT_MASK ! 1294: out dx, ax ! 1295: ! 1296: mov ax, GRAF_ENAB_SR ! 1297: out dx, ax ! 1298: ! 1299: mov dl, SEQ_ADDR ! 1300: mov ax, MM_ALL SHL 8 + SEQ_MAP_MASK ! 1301: out dx, ax ! 1302: ! 1303: call clip_rects ! 1304: ! 1305: mov eax,flPointer ;lousy hack ! 1306: or eax,eax ! 1307: jnz draw_color_pointer ;Color pointer? ! 1308: ! 1309: ;-----------------------------------------------------------------------; ! 1310: ; Draw B/W Pointer ! 1311: ;-----------------------------------------------------------------------; ! 1312: ! 1313: ;-----------------------------------------------------------------------; ! 1314: ; AND from the save area and the screen into the work area ! 1315: ;-----------------------------------------------------------------------; ! 1316: ! 1317: mov al, fbAndRead ! 1318: or al, al ! 1319: jz done_and_portion ! 1320: call and_into_work ! 1321: done_and_portion: ! 1322: ! 1323: ;-----------------------------------------------------------------------; ! 1324: ; Copy from save area to the screen and from the screen to the save ! 1325: ; area. ! 1326: ;-----------------------------------------------------------------------; ! 1327: ! 1328: mov ax, WORD PTR fbFlush ;Assume nothing to copy to/from save ! 1329: ! 1330: .ERRNZ fbAndRead-fbFlush-1 ! 1331: ! 1332: or ah, al ! 1333: jz copied_things_around ! 1334: call copy_things_around ! 1335: copied_things_around: ! 1336: ! 1337: ! 1338: ;-----------------------------------------------------------------------; ! 1339: ; XOR from the work area to the screen ! 1340: ;-----------------------------------------------------------------------; ! 1341: ! 1342: mov al, fbXor ! 1343: or al, al ! 1344: jz pointer_drawn ! 1345: call xor_to_screen ! 1346: jmp pointer_drawn ! 1347: ! 1348: ;-----------------------------------------------------------------------; ! 1349: ; Draw Color Pointer ! 1350: ;-----------------------------------------------------------------------; ! 1351: ! 1352: draw_color_pointer: ! 1353: ! 1354: ;-----------------------------------------------------------------------; ! 1355: ; Copy from save area to the screen and from the screen to the save area. ! 1356: ;-----------------------------------------------------------------------; ! 1357: ! 1358: mov ax, WORD PTR fbFlush ;Assume nothing to copy to/from save ! 1359: ! 1360: .ERRNZ fbAndRead-fbFlush-1 ! 1361: ! 1362: or ah, al ! 1363: jz things_copied_around ! 1364: call copy_things_around ! 1365: things_copied_around: ! 1366: ! 1367: ;-----------------------------------------------------------------------; ! 1368: ; Draw color pointer to screen ! 1369: ;-----------------------------------------------------------------------; ! 1370: ! 1371: test fbXor, 0FFh ! 1372: jz pointer_drawn ! 1373: call color_pointer_to_screen ;Planes must all be enabled ! 1374: ! 1375: pointer_drawn: ! 1376: mov eax, ppdNew ! 1377: xchg eax, ppdOld ! 1378: mov ppdNew, eax ! 1379: draw_pointer_exit: ! 1380: ! 1381: ;-----------------------------------------------------------------------; ! 1382: ; Reset WRITE mode of EGA/VGA to WRITE MODE 0, READ MODE 1 ! 1383: ;-----------------------------------------------------------------------; ! 1384: ! 1385: mov al, MM_ALL ;Set Map Mask for all write ! 1386: mov dx, EGA_BASE + SEQ_DATA ! 1387: out dx, al ! 1388: ! 1389: mov dx, EGA_BASE + GRAF_ADDR ! 1390: mov ax, DR_SET SHL 8 + GRAF_DATA_ROT ! 1391: out dx, ax ! 1392: ! 1393: mov ax, M_PROC_WRITE SHL 8 + GRAF_MODE ! 1394: out dx, ax ! 1395: ! 1396: mov ax, 0FF00h + GRAF_BIT_MASK ! 1397: out dx, ax ! 1398: ! 1399: mov ax, GRAF_ENAB_SR ! 1400: out dx, ax ! 1401: ! 1402: cRet vDrawPointer ! 1403: ! 1404: ;-----------------------------------------------------------------------; ! 1405: ; The following routines would be procs, outside the scope of ! 1406: ; vDrawPointer, but then they couldn't access vDrawPointer's stack ! 1407: ; frame, which they need to. ! 1408: ;-----------------------------------------------------------------------; ! 1409: ! 1410: page ! 1411: ! 1412: ;--------------------------Private-Routine------------------------------; ! 1413: ; compute_rects ! 1414: ; ! 1415: ; This routine computes the rectangles which describe what needs to be ! 1416: ; read/ANDed/XORed/written. The rectangles are unclipped. Clipping ! 1417: ; must be performed by a different routine. ! 1418: ; ! 1419: ; Entry: ! 1420: ; AX = 0 ! 1421: ; SI --> currently displayed pointer's rectangle data ! 1422: ; DI --> new pointer's rectangle data ! 1423: ; Returns: ! 1424: ; None ! 1425: ; Error Returns: ! 1426: ; None ! 1427: ; Registers Preserved: ! 1428: ; BP ! 1429: ; Registers Destroyed: ! 1430: ; AX,BX,CX,DX,SI,DI,FLAGS ! 1431: ; Calls: ! 1432: ; None ! 1433: ; ! 1434: ;-----------------------------------------------------------------------; ! 1435: ! 1436: align 4 ! 1437: compute_rects: ! 1438: ! 1439: push ebp ! 1440: ! 1441: mov WORD PTR fbFlush, ax ;Assume nothing to restore to screen ! 1442: ! 1443: .ERRNZ fbAndRead-fbFlush-1 ;Assume nothing to read/And to work ! 1444: ! 1445: mov fbXor, FB_NEW_PTR ;Assume new pointer is XORed to screen ! 1446: test [esi].pd_fb, PD_VALID ! 1447: jz old_pointer_is_invalid ! 1448: ! 1449: ;-----------------------------------------------------------------------; ! 1450: ; There is a pointer currently displayed on the screen. If the new ! 1451: ; pointer is far enough away from the old pointer, then we won't have ! 1452: ; to deal with overlap. ! 1453: ;-----------------------------------------------------------------------; ! 1454: ! 1455: old_pointer_is_valid: ! 1456: mov eax, [edi].pd_rd.rd_ptlScreen.ptl_x ! 1457: sub eax, [esi].pd_rd.rd_ptlScreen.ptl_x ! 1458: mov bl, al ;BL = delta x ! 1459: or eax, eax ;EAX = |EAX| ! 1460: jns @F ! 1461: neg eax ! 1462: @@: ! 1463: cmp eax, sizlMaxDelta.sizl_cx ! 1464: jae rects_are_disjoint ! 1465: mov eax, [edi].pd_rd.rd_ptlScreen.ptl_y ! 1466: sub eax, [esi].pd_rd.rd_ptlScreen.ptl_y ! 1467: mov bh, al ;BH = delta y ! 1468: or eax, eax ;EAX = |EAX| ! 1469: jns @F ! 1470: neg eax ! 1471: @@: ! 1472: cmp eax, sizlMaxDelta.sizl_cy ! 1473: jb rects_overlap ;(or are identical) ! 1474: ! 1475: ;-----------------------------------------------------------------------; ! 1476: ; The rectangles will be disjoint. Set up to restore under the old ! 1477: ; pointer, copy the new rectangle to the save area, and AND it into ! 1478: ; the work area. ! 1479: ;-----------------------------------------------------------------------; ! 1480: ! 1481: rects_are_disjoint: ! 1482: mov fbFlush, FB_OLD_PTR ! 1483: ! 1484: ;-----------------------------------------------------------------------; ! 1485: ; The save area image is invalid, so we won't have to copy it to the ! 1486: ; screen or AND some part of it into the work area. We'll simply want ! 1487: ; to copy the new area to the save area and AND it into the work area. ! 1488: ; This can be treated the same as if the rectangles are identical, ! 1489: ; except we want to reset the origin within the save buffer. ! 1490: ;-----------------------------------------------------------------------; ! 1491: ! 1492: old_pointer_is_invalid: ! 1493: mov ax, ptbInitOrigin ;Reset origin within the save area ! 1494: mov [edi].pd_rd.rd_ptbSave,ax ! 1495: ! 1496: .ERRNZ (SIZE POINTB) - 2 ! 1497: ! 1498: mov fbAndRead, FB_NEW_PTR ;Copy new ptr to save and XOR to work ! 1499: jmp compute_rects_exit ! 1500: ! 1501: ! 1502: ;-----------------------------------------------------------------------; ! 1503: ; The rectangles overlap in some manner. Compute how the rectangles, ! 1504: ; will overlap, setting up the various needed rectangle structures as ! 1505: ; we go. ! 1506: ; ! 1507: ; The only hope we have of computing the overlap rectangle is to ! 1508: ; initialize it to some known state and adjusting it as we process ! 1509: ; dx and dy. We will initialize it to be the upper left hand corner ! 1510: ; of the old pointer rectangle. ! 1511: ; ! 1512: ; Currently: ! 1513: ; AX = old pointer's pd_rd.rd_ptbSave ! 1514: ; BH = dy ! 1515: ; BL = dx (negative) ! 1516: ; SI --> old pointer's rd_ptlScreen ! 1517: ; DI --> new pointer rectangle ! 1518: ;-----------------------------------------------------------------------; ! 1519: ! 1520: rects_overlap: ! 1521: ! 1522: ; Set old pointer's save buffer (X,Y) into the overlap rectangle. ! 1523: ; Also set this as the save buffer origin for the new pointer rectangle. ! 1524: ! 1525: lodsw ! 1526: ! 1527: .ERRNZ pd_rd.rd_ptbSave ! 1528: ! 1529: mov rdOverlap.rd_ptbSave, ax ! 1530: mov [edi].pd_rd.rd_ptbSave, ax ! 1531: mov dx, ax ! 1532: ! 1533: ; Set old pointer's screen (X,Y) into the overlap rectangle as the ! 1534: ; screen origin. ! 1535: ! 1536: lodsd ! 1537: ! 1538: .ERRNZ rd_ptlScreen-rd_ptbSave-2 ! 1539: .ERRNZ ptl_x ! 1540: ! 1541: mov rdOverlap.rd_ptlScreen.ptl_x, eax ! 1542: mov ebp, eax ! 1543: lodsd ! 1544: ! 1545: .ERRNZ ptl_y-ptl_x-4 ! 1546: ! 1547: mov rdOverlap.rd_ptlScreen.ptl_y, eax ! 1548: mov esi, eax ! 1549: ! 1550: ; Set the mask width and height into the overlap rectangle ! 1551: ! 1552: mov ax, sizbMask ! 1553: mov rdOverlap.rd_sizb, ax ! 1554: ! 1555: .ERRNZ sizb_cy-sizb_cx-1 ! 1556: .ERRNZ (SIZE SIZEB) - 2 ! 1557: ! 1558: mov ecx, eax ! 1559: ! 1560: .ERRNZ sizb_cy-sizb_cx-1 ! 1561: ! 1562: ; Set the work buffer origin to be zero ! 1563: ! 1564: xor eax, eax ! 1565: mov rdOverlap.rd_ptbWork, ax ! 1566: ! 1567: ; Show that the overlap rectangle exists and should be ANDed into the ! 1568: ; work area, then dispatch based on dx,dy. ! 1569: ! 1570: mov fbAndRead, FB_OVERLAP ! 1571: or bl, bl ; Dispatch based on dx ! 1572: jg moved_right ! 1573: jl moved_left ! 1574: jmp processed_x_overlap ! 1575: ! 1576: ! 1577: ;-----------------------------------------------------------------------; ! 1578: ; The starting X of the new rectangle is to be set as the new lhs. ! 1579: ; ! 1580: ; * nnnnn $ onononono oooooooo * = start of new rectangle ! 1581: ; o o $ = start of old rectangle ! 1582: ; n | o | n | o ! 1583: ; n | n o | o ! 1584: ; n | o O n o ! 1585: ; n n v o F o ! 1586: ; n R o e n l o ! 1587: ; n e n r o u o ! 1588: ; n a o l n s o ! 1589: ; n d n a o h o ! 1590: ; n o p n o ! 1591: ; n | n o | o ! 1592: ; n | o | n | o ! 1593: ; n | n | o | o ! 1594: ; n o n o ! 1595: ; nnnnnnnn nonononono oooooooo ! 1596: ; ! 1597: ; |-- dx -| |-- dx -| ! 1598: ; |-sizbMask.sizb_cx-| ! 1599: ; ! 1600: ; ! 1601: ; Currently: ! 1602: ; AX = 0 ! 1603: ; BH = dy ! 1604: ; BL = dx (negative) ! 1605: ; CH = buffer height ! 1606: ; CL = buffer width ! 1607: ; DH = old pointer's Y coordinate in save area ! 1608: ; DL = old pointer's X coordinate in save area ! 1609: ; SI = old pointer's Y screen coordinate ! 1610: ; BP = old pointer's X screen coordinate ! 1611: ; DI = --> new pointer's RECT_DATA ! 1612: ;-----------------------------------------------------------------------; ! 1613: ! 1614: moved_left: ! 1615: ! 1616: ; The Read buffer will map into the work area at (0,0). ! 1617: ! 1618: mov rdReadX.rd_ptbWork, ax ! 1619: ! 1620: ; The width of the overlap area is sizbMask.sizb_cx - |dx|. ! 1621: ! 1622: mov al, bl ;BL = dx (which is negative) ! 1623: add al, cl ;CL = sizbMask.sizb_cx ! 1624: mov rdOverlap.rd_sizb.sizb_cx, al ! 1625: ! 1626: ; The flush rectangle's X is ptlScreen.ptl_x + sizbMask.sizb_cx - |dx|. ! 1627: ! 1628: add eax, ebp ;AX = sizbMask.sizb_cx - |dx| ! 1629: mov rdFlushX.rd_ptlScreen.ptl_x, eax ! 1630: ! 1631: ; Compute where in the save buffer the new lhs will map to. We must ! 1632: ; update the new pointer's rectangle to reflect where this origin is. ! 1633: ! 1634: mov eax, edx ;DX = old ptbSave ! 1635: add al, bl ;BL = dx (negative) ! 1636: add ah, bh ;BH = dy ! 1637: and eax, ((SAVE_BUFFER_HEIGHT-1) SHL 8) + SAVE_BUFFER_WIDTH-1 ! 1638: mov [edi].pd_rd.rd_ptbSave.ptb_x, al ! 1639: mov rdReadX.rd_ptbSave, ax ! 1640: ! 1641: .ERRNZ ptb_y-ptb_x-1 ! 1642: ! 1643: ; The origin of the flush rectangle is sizbMask.sizb_cx bytes away ! 1644: ; from the origin of the read rectangle. ! 1645: ! 1646: add al, cl ! 1647: and al, SAVE_BUFFER_WIDTH-1 ;Handle any wrap ! 1648: mov ah, dh ! 1649: mov rdFlushX.rd_ptbSave, ax ! 1650: ! 1651: ; Compute |dx|. This is the width of the read and flush rectangles. ! 1652: ; The height will be set to the working height. |dx| is also the ! 1653: ; overlap rectangle's work area X coordinate. ! 1654: ! 1655: mov al, bl ;BL = dx (negative) ! 1656: neg al ;AL = |dx| ! 1657: mov ah, ch ;CH = sizbMask.sizb_cy ! 1658: mov rdFlushX.rd_sizb, ax ! 1659: mov rdReadX.rd_sizb, ax ! 1660: ! 1661: .ERRNZ sizb_cy-sizb_cx-1 ! 1662: ! 1663: mov rdOverlap.rd_ptbWork.ptb_x, al ! 1664: ! 1665: ; The Read buffer's screen address is the ptlScreen stored in the new ! 1666: ; pointer's RECT_DATA. ! 1667: ! 1668: mov eax, [edi].pd_rd.rd_ptlScreen.ptl_x ! 1669: jmp finish_x_overlap ! 1670: ! 1671: ! 1672: ! 1673: ;-----------------------------------------------------------------------; ! 1674: ; The starting X of the new rectangle is somewhere in the middle ! 1675: ; of the old rectangle. ! 1676: ; ! 1677: ; $ ooooo * onononono nnnnnnn * = start of new rectangle ! 1678: ; o n o n $ = start of old rectangle ! 1679: ; o | o | n | n ! 1680: ; o | n o | n ! 1681: ; o o O n | n ! 1682: ; o F n v o n ! 1683: ; o l o e n R n ! 1684: ; o u n r o e n ! 1685: ; o s o l n a n ! 1686: ; o h n a o d n ! 1687: ; o o p n n ! 1688: ; o | n o | n ! 1689: ; o | o | n | n ! 1690: ; o | n | o | n ! 1691: ; o o n n ! 1692: ; oooooooo nonononono nnnnnnn ! 1693: ; ! 1694: ; |-- dx -| |-- dx -| ! 1695: ; |-sizbMask.sizb_cx-| ! 1696: ; ! 1697: ; ! 1698: ; Currently: ! 1699: ; AX = 0 ! 1700: ; BH = dy ! 1701: ; BL = dx (positive) ! 1702: ; CH = buffer height ! 1703: ; CL = buffer width ! 1704: ; DH = old pointer's Y coordinate in save area ! 1705: ; DL = old pointer's X coordinate in save area ! 1706: ; SI = old pointer's Y screen coordinate ! 1707: ; BP = old pointer's X screen coordinate ! 1708: ; DI = --> new pointer's RECT_DATA ! 1709: ;-----------------------------------------------------------------------; ! 1710: ! 1711: moved_right: ! 1712: ! 1713: ; The screen X origin of the overlap rectangle is the new rectangle's ! 1714: ; X coordinate, or the old rectangle's X coordinate + |dx|. ! 1715: ! 1716: mov al, bl ! 1717: add rdOverlap.rd_ptlScreen.ptl_x, eax ! 1718: ! 1719: ; The width of the read and flush buffers is |dx|. The height is ! 1720: ; just the working height. ! 1721: ! 1722: mov ah, ch ;CH = sizbMask.sizb_cy ! 1723: mov rdFlushX.rd_sizb, ax ! 1724: mov rdReadX.rd_sizb, ax ! 1725: ! 1726: .ERRNZ sizb_cy-sizb_cx-1 ! 1727: ! 1728: ; Compute where the new lhs is in the save area. This will be the lhs ! 1729: ; of both the new rectangle and the overlap area. ! 1730: ! 1731: add al, dl ;DL = ptbSave.ptb_x ! 1732: and al, SAVE_BUFFER_WIDTH-1 ;Handle any wrap ! 1733: mov [edi].pd_rd.rd_ptbSave.ptb_x, al ! 1734: mov rdOverlap.rd_ptbSave.ptb_x, al ! 1735: ! 1736: ; The data to be flushed will come from the lhs of the old rectangle ! 1737: ! 1738: mov eax, edx ! 1739: mov rdFlushX.rd_ptbSave, ax ! 1740: ! 1741: ; The data to be read will go at the old lhs + sizbMask.sizb_cx. The ! 1742: ; Y component will be the new Y. ! 1743: ! 1744: add al, cl ! 1745: add ah, bh ! 1746: and eax, ((SAVE_BUFFER_HEIGHT-1) SHL 8) + SAVE_BUFFER_WIDTH-1 ! 1747: mov rdReadX.rd_ptbSave, ax ! 1748: ! 1749: .ERRNZ ptb_y-ptb_x-1 ! 1750: ! 1751: ; The X screen origin of the flush buffer is the old ptlScreen.ptl_x ! 1752: ! 1753: mov rdFlushX.rd_ptlScreen.ptl_x, ebp ! 1754: ! 1755: ; The width of the overlap rectangle is sizbMask.sizb_cx - |dx|. This ! 1756: ; is also the X offset into the work area of the read rectangle. ! 1757: ; The Y offset is zero. ! 1758: ! 1759: mov al, cl ! 1760: sub al, bl ! 1761: mov rdOverlap.rd_sizb.sizb_cx, al ! 1762: movsx eax, al ! 1763: mov rdReadX.rd_ptbWork, ax ! 1764: ! 1765: .ERRNZ ptb_y-ptb_x-1 ! 1766: ! 1767: ; The screen Y origin of the read rectangle is the new rectangle's Y ! 1768: ; coordinate. The X coordinate can be computed as the old rectangles ! 1769: ; X coordinate + the save width ! 1770: ! 1771: mov al, cl ! 1772: add eax, ebp ! 1773: ! 1774: finish_x_overlap: ! 1775: mov rdReadX.rd_ptlScreen.ptl_x, eax ! 1776: mov eax, [edi].pd_rd.rd_ptlScreen.ptl_y ! 1777: mov rdReadX.rd_ptlScreen.ptl_y, eax ! 1778: ! 1779: ; The Y address of the flush rectangle on the screen is ptlScreen.ptl_y. ! 1780: ! 1781: mov rdFlushX.rd_ptlScreen.ptl_y, esi ! 1782: ! 1783: ; Set the flags to show that there is some form of X overlap. We want ! 1784: ; to show that there is some X rectangle to be read/flushed, and that ! 1785: ; there is some overlap rectangle to be processed. ! 1786: ! 1787: or WORD PTR fbFlush, (FB_READ_X SHL 8) + FB_FLUSH_X ! 1788: ! 1789: .ERRNZ fbAndRead-fbFlush-1 ! 1790: ! 1791: xor eax, eax ! 1792: ! 1793: processed_x_overlap: ! 1794: or bh, bh ! 1795: jg moved_down ! 1796: jz processed_y_overlap_relay ! 1797: ! 1798: ! 1799: ;-----------------------------------------------------------------------; ! 1800: ; The starting Y of the new rectangle is to be set as the new top. ! 1801: ; ! 1802: ; * = start of new rectangle ! 1803: ; $ = start of old rectangle ! 1804: ; ! 1805: ; $ oooooooooooooooooooooooooo --- --- ! 1806: ; o o | | ! 1807: ; o -------- Read ---------- o dy | ! 1808: ; o | | ! 1809: ; * onononononononononononono --- ! 1810: ; n sizbMask.sizb_cy - dy ! 1811: ; n o ! 1812: ; o ------- Overlap -------- n | ! 1813: ; n o | ! 1814: ; o n | ! 1815: ; ononononononononononononon --- --- ! 1816: ; n n | ! 1817: ; n -------- Write --------- n dy ! 1818: ; n n | ! 1819: ; nnnnnnnnnnnnnnnnnnnnnnnnnnnn --- ! 1820: ; ! 1821: ; ! 1822: ; ! 1823: ; Currently: ! 1824: ; AX = 0 ! 1825: ; BH = dy (negative) ! 1826: ; BL = dx ! 1827: ; CH = buffer height ! 1828: ; CL = buffer width ! 1829: ; DH = old pointer's Y coordinate in save area ! 1830: ; DL = old pointer's X coordinate in save area ! 1831: ; SI = old pointer's Y screen coordinate ! 1832: ; BP = old pointer's X screen coordinate ! 1833: ; DI = --> new pointer's RECT_DATA ! 1834: ;-----------------------------------------------------------------------; ! 1835: ! 1836: moved_up: ! 1837: ! 1838: ; The Read buffer will map into the work area at (0,0). ! 1839: ! 1840: mov rdReadY.rd_ptbWork, ax ! 1841: ! 1842: ; The height of the overlap area is sizbMask.sizb_cy - |dy|. ! 1843: ! 1844: mov al, bh ;BH = dy (which is negative) ! 1845: add al, ch ;CH = sizbMask.sizb_cy ! 1846: mov rdOverlap.rd_sizb.sizb_cy, al ! 1847: ! 1848: ; The flush rectangle's Y is ptlScreen.ptl_y + sizbMask.sizb_cy - |dy|. ! 1849: ! 1850: add eax, esi ;EAX = sizbMask.sizb_cy - |dy| ! 1851: mov rdFlushY.rd_ptlScreen.ptl_y, eax ! 1852: ! 1853: ; Compute where in the save buffer the new top will map to. We must ! 1854: ; update the new pointer's rectangle to reflect where this origin is. ! 1855: ! 1856: mov eax, edx ;DX = old ptbSave ! 1857: add ah, bh ;BH = dy (negative) ! 1858: add al, bl ! 1859: and eax, ((SAVE_BUFFER_HEIGHT-1) SHL 8) + SAVE_BUFFER_WIDTH-1 ! 1860: mov [edi].pd_rd.rd_ptbSave.ptb_y, ah ! 1861: mov rdReadY.rd_ptbSave, ax ! 1862: ! 1863: .ERRNZ ptb_y-ptb_x-1 ! 1864: ! 1865: ; The origin of the flush rectangle is sizbMask.sizb_cy scans away ! 1866: ; from the origin of the read rectangle. ! 1867: ! 1868: add ah, ch ! 1869: and ah, SAVE_BUFFER_HEIGHT-1 ;Handle any wrap ! 1870: mov al, dl ! 1871: mov rdFlushY.rd_ptbSave, ax ! 1872: ! 1873: ; Compute |dy|. This is the height of the read and flush rectangles. ! 1874: ; The width will be set to the working width. |dy| is also the ! 1875: ; overlap rectangle's work area Y coordinate. ! 1876: ! 1877: mov ah, bh ;BH = dy ! 1878: neg ah ;Make it |dy| ! 1879: mov al, cl ;CL = sizbMask.sizb_cx ! 1880: mov rdFlushY.rd_sizb, ax ! 1881: mov rdReadY.rd_sizb, ax ! 1882: ! 1883: .ERRNZ sizb_cy-sizb_cx-1 ! 1884: ! 1885: mov rdOverlap.rd_ptbWork.ptb_y, ah ! 1886: ! 1887: ; The Read buffer's screen address is the ptlScreen stored in the new ! 1888: ; pointer's RECT_DATA. ! 1889: ! 1890: mov eax, [edi].pd_rd.rd_ptlScreen.ptl_y ! 1891: jmp finish_y_overlap ! 1892: ! 1893: processed_y_overlap_relay: ! 1894: jmp processed_y_overlap ! 1895: ! 1896: ! 1897: ! 1898: ;-----------------------------------------------------------------------; ! 1899: ; The starting Y of the new rectangle is somewhere in the middle ! 1900: ; of the old rectangle. ! 1901: ; ! 1902: ; * = start of new rectangle ! 1903: ; $ = start of old rectangle ! 1904: ; ! 1905: ; $ oooooooooooooooooooooooooo --- --- ! 1906: ; o o | | ! 1907: ; o -------- Write --------- o dy | ! 1908: ; o | | ! 1909: ; * onononononononononononono --- ! 1910: ; n sizbMask.sizb_cy - dy ! 1911: ; n o ! 1912: ; o ------- Overlap -------- n | ! 1913: ; n o | ! 1914: ; o n | ! 1915: ; ononononononononononononon --- --- ! 1916: ; n n | ! 1917: ; n -------- Read ---------- n dy ! 1918: ; n n | ! 1919: ; nnnnnnnnnnnnnnnnnnnnnnnnnnnn --- ! 1920: ; ! 1921: ; ! 1922: ; Currently: ! 1923: ; AX = 0 ! 1924: ; BH = dy (positive) ! 1925: ; BL = dx ! 1926: ; CH = buffer height ! 1927: ; CL = buffer width ! 1928: ; DH = old pointer's Y coordinate in save area ! 1929: ; DL = old pointer's X coordinate in save area ! 1930: ; SI = old pointer's Y screen coordinate ! 1931: ; BP = old pointer's X screen coordinate ! 1932: ; DI = --> new pointer's RECT_DATA ! 1933: ;-----------------------------------------------------------------------; ! 1934: ! 1935: moved_down: ! 1936: ! 1937: ; The screen Y origin of the overlap rectangle is the new rectangle's ! 1938: ; Y coordinate, or the old rectangle's Y coordinate + |dy|. ! 1939: ! 1940: mov al, bh ! 1941: add rdOverlap.rd_ptlScreen.ptl_y, eax ! 1942: ! 1943: ; Compute where the new top is. This will be both the top of the new ! 1944: ; rectangle and the overlap area. ! 1945: ! 1946: ; mov al, bh ;BH = |dy| ! 1947: add al, dh ;DH = ptbSave.ptb_y ! 1948: and al, SAVE_BUFFER_HEIGHT-1 ;CH = sizbMask.sizb_cy ! 1949: mov [edi].pd_rd.rd_ptbSave.ptb_y, al ! 1950: mov rdOverlap.rd_ptbSave.ptb_y, al ! 1951: ! 1952: ; The height of the read and flush buffers is |dy|. The width is ! 1953: ; just the working width. ! 1954: ! 1955: mov ah, bh ! 1956: mov al, cl ;CL = sizbMask.sizb_cx ! 1957: mov rdFlushY.rd_sizb, ax ! 1958: mov rdReadY.rd_sizb, ax ! 1959: ! 1960: .ERRNZ sizb_cy-sizb_cx-1 ! 1961: ! 1962: ; The data to be flushed will come from the top of the old rectangle ! 1963: ! 1964: mov eax, edx ! 1965: mov rdFlushY.rd_ptbSave, dx ! 1966: ! 1967: ; The data to be read will go at the old top + sizbMask.sizb_cy ! 1968: ! 1969: add ah, ch ! 1970: add al, bl ! 1971: and eax, ((SAVE_BUFFER_HEIGHT-1) SHL 8) + SAVE_BUFFER_WIDTH-1 ! 1972: mov rdReadY.rd_ptbSave, ax ! 1973: ! 1974: .ERRNZ ptb_y-ptb_x-1 ! 1975: ! 1976: ; The Y screen origin of the flush buffer is the old ptlScreen.ptl_y ! 1977: ! 1978: mov rdFlushY.rd_ptlScreen.ptl_y, esi ! 1979: ! 1980: ; The height of the overlap rectangle is sizbMask.sizb_cy - |dy|. ! 1981: ; This is also the Y offset into the work area of the read rectangle. ! 1982: ; The X offset is zero. ! 1983: ! 1984: mov ah, ch ! 1985: sub ah, bh ! 1986: mov rdOverlap.rd_sizb.sizb_cy, ah ! 1987: xor al, al ! 1988: mov rdReadY.rd_ptbWork, ax ! 1989: ! 1990: .ERRNZ ptb_y-ptb_x-1 ! 1991: ! 1992: ; The screen X origin of the read rectangle is the new rectangle's X ! 1993: ; coordinate. The Y coordinate can be computed as the old ! 1994: ; rectangle's Y coordinate + the save height ! 1995: ! 1996: mov al, ch ! 1997: xor ah, ah ! 1998: add eax, esi ! 1999: ! 2000: finish_y_overlap: ! 2001: mov rdReadY.rd_ptlScreen.ptl_y, eax ! 2002: mov eax, [edi].pd_rd.rd_ptlScreen.ptl_x ! 2003: mov rdReadY.rd_ptlScreen.ptl_x, eax ! 2004: ! 2005: ; The X address of the flush rectangle on the screen is ptlScreen.ptl_x. ! 2006: ! 2007: mov rdFlushY.rd_ptlScreen.ptl_x, ebp ! 2008: ! 2009: ; Set the flags to show that there is some form of Y overlap. We want ! 2010: ; to show that there is some Y rectangle to be read/flushed, and that ! 2011: ; there is some overlap rectangle to be processed. ! 2012: ! 2013: or WORD PTR fbFlush, ((FB_READ_Y OR FB_OVERLAP) SHL 8) + FB_FLUSH_Y ! 2014: ! 2015: .ERRNZ fbAndRead-fbFlush-1 ! 2016: ! 2017: ! 2018: ;-----------------------------------------------------------------------; ! 2019: ; We have computed the seperate X and Y componets of the overlap. If ! 2020: ; there was both dx and dy, then we have an L shaped area which we'll ! 2021: ; be reading/writing. In this case, we want to remove the overlapping ! 2022: ; portion of the L. ! 2023: ;-----------------------------------------------------------------------; ! 2024: ! 2025: or bl, bl ! 2026: jz processed_y_overlap ! 2027: ! 2028: ;-----------------------------------------------------------------------; ! 2029: ; We have something which looks like one of the following: ! 2030: ; ! 2031: ; ---------- ---------- ! 2032: ; | flush | | flush | dy > 0 ! 2033: ; | f | | f | ! 2034: ; | l ---------- ---------- l | ----- ! 2035: ; | u | | | | | | u | | ! 2036: ; | s | | | | | | s | limit the "x" rectangles to ! 2037: ; | h | 1 | r | | r | 2 | h | this height ! 2038: ; | | | e | | e | | | | ! 2039: ; ---|------ a | | a ------|--- ----- ! 2040: ; | d | | d | \ ! 2041: ; | read | | read |\ \ ! 2042: ; ---------- ---------- \ \ ! 2043: ; \ \_____ The "x" overlap rectangle ! 2044: ; \ ! 2045: ; \______ The "y" overlap rectangle ! 2046: ; ! 2047: ; ! 2048: ; ! 2049: ; ---------- ---------- dy < 0 ! 2050: ; | read | | read | ! 2051: ; | r | | r | ! 2052: ; | e ------|--- ---|------ e | ----- ! 2053: ; | a | | | | | | a | | ! 2054: ; | d | | f | | f | | d | limit the "x" rectangles to ! 2055: ; | | 3 | l | | l | 4 | | this height ! 2056: ; | | | u | | u | | | | ! 2057: ; ---------- s | | s ---------- ----- ! 2058: ; | h | | h | ! 2059: ; | flush | | flush | ! 2060: ; ---------- ---------- ! 2061: ; ! 2062: ; ! 2063: ; The corners of the L shape are contained in both the X and Y ! 2064: ; rectangles we just created. We'll remove the overlap from the ! 2065: ; X rectangles. To do this, we must subtract |dy| from the height ! 2066: ; stored in the rectangles (which is sizbMask.sizb_cy) and adjust ! 2067: ; X parameters of either the read or flush rectangles. ! 2068: ; ! 2069: ; For cases 1 and 2, we want to adjust X parameters of the flush ! 2070: ; rectangle. For cases 3 and 4, we want to adjust X parameters ! 2071: ; of the read rectangle. ! 2072: ; ! 2073: ; Currently: ! 2074: ; BH = dy ! 2075: ; BL = dx ! 2076: ; CH = buffer height ! 2077: ; CL = buffer width ! 2078: ; DH = old pointer's Y coordinate in save area ! 2079: ; DL = old pointer's X coordinate in save area ! 2080: ; SI = old pointer's Y screen coordinate ! 2081: ; BP = old pointer's X screen coordinate ! 2082: ; DI = --> new pointer's RECT_DATA ! 2083: ;-----------------------------------------------------------------------; ! 2084: ! 2085: mov al, bh ! 2086: mov ebx, offset FLAT:rdFlushX ;Assume cases 1 and 2 ! 2087: or al, al ! 2088: jns @F ! 2089: mov ebx, offset FLAT:rdReadX ;Its cases 3 and 4 ! 2090: neg al ;|dy| ! 2091: add [ebx].rd_ptbWork.ptb_y, al;Move down in the work area too! ! 2092: @@: ! 2093: mov cl, [ebx].rd_ptbSave.ptb_y ! 2094: add cl, al ! 2095: and cl, SAVE_BUFFER_HEIGHT-1 ! 2096: mov [ebx].rd_ptbSave.ptb_y, cl ! 2097: movsx eax, al ! 2098: ! 2099: .ERRNZ (SAVE_BUFFER_HEIGHT-1) AND 80h ! 2100: ! 2101: add [ebx].rd_ptlScreen.ptl_y, eax ! 2102: neg al ! 2103: add al, ch ;sizbMask.sizb_cy - |dy| ! 2104: mov rdFlushX.rd_sizb.sizb_cy, al ! 2105: mov rdReadX.rd_sizb.sizb_cy, al ! 2106: ! 2107: processed_y_overlap: ! 2108: compute_rects_exit: ! 2109: ! 2110: pop ebp ! 2111: ! 2112: PLAIN_RET ! 2113: ! 2114: page ! 2115: ! 2116: ;--------------------------Private-Routine------------------------------; ! 2117: ; clip_rects ! 2118: ; ! 2119: ; This routine clips the rectangles computed by compute_rects. ! 2120: ; ! 2121: ; Entry: ! 2122: ; None ! 2123: ; Returns: ! 2124: ; None ! 2125: ; Error Returns: ! 2126: ; None ! 2127: ; Registers Preserved: ! 2128: ; BP ! 2129: ; Registers Destroyed: ! 2130: ; AX,BX,CX,DX,SI,DI,FLAGS ! 2131: ; Calls: ! 2132: ; do_clipping ! 2133: ; ! 2134: ;-----------------------------------------------------------------------; ! 2135: ! 2136: align 4 ! 2137: clip_rects: ! 2138: ! 2139: mov esi, ppdOld ;--> old POINTER_DATA structure ! 2140: mov dl, [esi].pd_fb ! 2141: test dl, PD_CLIPPED ;Won't be set if PD_VALID isn't set ! 2142: jz old_been_clipped ! 2143: ! 2144: ;-----------------------------------------------------------------------; ! 2145: ; The old pointer needs some form of clipping. This can affect either ! 2146: ; the old pointer's rectangle or rdFlushX and rdFlushY. Since the old ! 2147: ; pointer's rectangle will be discarded after it is restored, we don't ! 2148: ; care if we write over it's contents. ! 2149: ;-----------------------------------------------------------------------; ! 2150: ! 2151: mov edi, esi ;EDI --> rectangle to clip ! 2152: mov bl, fbFlush ;fbFlush tells us which rects to use ! 2153: mov bh, FB_OLD_PTR ! 2154: test bl, bh ! 2155: jnz call_do_clip ;Only have to clip old pointer's rect ! 2156: mov edi, offset FLAT:rdFlushX ! 2157: mov bh, FB_FLUSH_X ! 2158: test bl, bh ! 2159: jz @F ! 2160: call do_clipping ! 2161: @@: ! 2162: mov edi, offset FLAT:rdFlushY ! 2163: mov bh, FB_FLUSH_Y ! 2164: test bl, bh ! 2165: jz @F ! 2166: call_do_clip: ! 2167: call do_clipping ! 2168: @@: ! 2169: mov fbFlush, bl ! 2170: ! 2171: mov edi, offset FLAT:rdOverlap ! 2172: mov bl, fbAndRead ! 2173: mov bh, FB_OVERLAP ! 2174: test bl, bh ! 2175: jz @F ! 2176: call do_clipping ! 2177: mov fbAndRead, bl ! 2178: @@: ! 2179: old_been_clipped: ! 2180: ! 2181: ! 2182: ;-----------------------------------------------------------------------; ! 2183: ; The old pointer rectangle has been clipped. Now see about clipping ! 2184: ; the new pointer rectangle. ! 2185: ;-----------------------------------------------------------------------; ! 2186: ! 2187: mov esi, ppdNew ;--> new POINTER_DATA structure ! 2188: mov dl, [esi].pd_fb ! 2189: test dl, PD_CLIPPED ;Won't be set if PD_VALID isn't set ! 2190: jz new_been_clipped ! 2191: ! 2192: ;-----------------------------------------------------------------------; ! 2193: ; The new rectangle structure needs to be clipped. This presents a ! 2194: ; minor problem in that we don't want to destroy the screen X,Y and ! 2195: ; buffer X,Y of the pointer's POINTER_DATA structure. What we'll do ! 2196: ; instead is to copy it to the rdWork structure and update it there. ! 2197: ; We'll also set up to XOR this to the screen instead of the ! 2198: ; POINTER_DATA structure. ! 2199: ;-----------------------------------------------------------------------; ! 2200: ! 2201: lodsw ! 2202: mov rdWork.rd_ptbSave, ax ! 2203: ! 2204: .ERRNZ rd_ptbSave ! 2205: .ERRNZ (SIZE POINTB) - 2 ! 2206: ! 2207: lodsd ! 2208: mov rdWork.rd_ptlScreen.ptl_x, eax ! 2209: ! 2210: .ERRNZ rd_ptlScreen-rd_ptbSave-2 ! 2211: .ERRNZ ptl_x ! 2212: ! 2213: lodsd ! 2214: mov rdWork.rd_ptlScreen.ptl_y, eax ! 2215: ! 2216: .ERRNZ ptl_y-ptl_x-4 ! 2217: ! 2218: lodsw ! 2219: mov rdWork.rd_sizb, ax ! 2220: ! 2221: .ERRNZ (SIZE SIZEB) - 2 ! 2222: ! 2223: lodsw ! 2224: mov rdWork.rd_ptbWork, ax ! 2225: ! 2226: .ERRNZ (SIZE POINTB) - 2 ! 2227: ! 2228: sub esi,SIZE RECT_DATA ;--> to start of POINTER_DATA ! 2229: ! 2230: .ERRNZ (rd_ptbWork+2)-(SIZE RECT_DATA) ! 2231: ! 2232: ; Perform the clipping for the work area. We know that some part of the ! 2233: ; work area exists, else we wouldn't be here with a valid rectangle. ! 2234: ; If FB_NEW_PTR is set in fbAndRead, then we want to replace it with ! 2235: ; FB_WORK_RECT, else we'll want to process any overlap rectangles. ! 2236: ! 2237: mov edi, offset FLAT:rdWork ! 2238: call do_clipping ! 2239: mov bl, FB_WORK_RECT ! 2240: mov fbXor, bl ! 2241: xchg fbAndRead, bl ;Assume only work rect to and/read ! 2242: test bl, FB_NEW_PTR ! 2243: jnz new_been_clipped ! 2244: ! 2245: mov edi, offset FLAT:rdReadX ! 2246: mov bh, FB_READ_X ! 2247: test bl, bh ! 2248: jz @F ! 2249: call do_clipping ! 2250: @@: ! 2251: mov edi, offset FLAT:rdReadY ! 2252: mov bh, FB_READ_Y ! 2253: test bl, bh ! 2254: jz @F ! 2255: call do_clipping ! 2256: @@: ! 2257: mov fbAndRead, bl ! 2258: ! 2259: new_been_clipped: ! 2260: ! 2261: PLAIN_RET ! 2262: ! 2263: page ! 2264: ! 2265: ;--------------------------Private-Routine------------------------------; ! 2266: ; do_clipping ! 2267: ; ! 2268: ; This routine performs the actual clipping of a rectangle using the ! 2269: ; passed POINTER_DATA and RECT_DATA structures. ! 2270: ; ! 2271: ; Entry: ! 2272: ; BL = flag byte ! 2273: ; BH = bit to clear in BL if rectangle is invisible ! 2274: ; DL = pd_fb for [si] ! 2275: ; SI --> POINTER_DATA structure ! 2276: ; DI --> RECT_DATA structure ! 2277: ; Returns: ! 2278: ; BL updated ! 2279: ; Error Returns: ! 2280: ; None ! 2281: ; Registers Preserved: ! 2282: ; DX,SI,DI,BP ! 2283: ; Registers Destroyed: ! 2284: ; AX,BH,CX ! 2285: ; Calls: ! 2286: ; None ! 2287: ; ! 2288: ;-----------------------------------------------------------------------; ! 2289: ! 2290: ! 2291: align 4 ! 2292: do_clipping: ! 2293: ! 2294: .ERRNZ pd_rd ;Must be at offset 0 ! 2295: ! 2296: xor eax, eax ! 2297: test dl, PD_CLIP_BOTTOM OR PD_CLIP_TOP ! 2298: jz y_clipping_done ! 2299: mov ecx, [edi].rd_ptlScreen.ptl_y ! 2300: js clip_on_bottom_eh? ! 2301: ! 2302: .ERRNZ PD_CLIP_BOTTOM-10000000b ! 2303: ! 2304: ;-----------------------------------------------------------------------; ! 2305: ; Top clipping may have to be performed for this rectangle. ! 2306: ;-----------------------------------------------------------------------; ! 2307: ! 2308: clip_on_top: ! 2309: neg ecx ;If it was negative, then must clip ! 2310: jle y_clipping_done ;Was positive, no clipping needed ! 2311: sub [edi].rd_sizb.sizb_cy, cl ;Compute new height ! 2312: jle clear_visible_bit ;Clipped away, nothing visible ! 2313: add [edi].rd_ptbWork.ptb_y, cl ;Move down in work area ! 2314: add cl, [edi].rd_ptbSave.ptb_y ;Move down in save area ! 2315: and cl, SAVE_BUFFER_HEIGHT-1 ! 2316: mov [edi].rd_ptbSave.ptb_y, cl ! 2317: mov [edi].rd_ptlScreen.ptl_y, eax ! 2318: jmp finish_y_clipping ! 2319: ! 2320: ! 2321: ;-----------------------------------------------------------------------; ! 2322: ; Bottom clipping may have to be performed for this rectangle. ! 2323: ;-----------------------------------------------------------------------; ! 2324: ! 2325: clip_on_bottom_eh?: ! 2326: mov al, [edi].rd_sizb.sizb_cy ! 2327: add ecx, eax ! 2328: sub ecx, cyScreen ! 2329: jle finish_y_clipping ;EAX = amount to clip if positive ! 2330: sub al, cl ;Compute new height ! 2331: jle clear_visible_bit ;Clipped away, nothing visible ! 2332: mov [edi].rd_sizb.sizb_cy, al ! 2333: finish_y_clipping: ! 2334: xor eax, eax ! 2335: y_clipping_done: ! 2336: ! 2337: ! 2338: test dl, PD_CLIP_LEFT OR PD_CLIP_RIGHT ! 2339: jz x_clipping_done ! 2340: mov ecx, [edi].rd_ptlScreen.ptl_x ! 2341: test dl, PD_CLIP_RIGHT ! 2342: jnz clip_on_rhs ! 2343: ! 2344: ;-----------------------------------------------------------------------; ! 2345: ; lhs clipping may have to be performed for this rectangle. ! 2346: ;-----------------------------------------------------------------------; ! 2347: ! 2348: clip_on_lhs: ! 2349: neg ecx ;If it was negative, then must clip ! 2350: jle x_clipping_done ;Was positive, no clipping needed ! 2351: sub [edi].rd_sizb.sizb_cx, cl ;Compute new width ! 2352: jle clear_visible_bit ;Clipped away, nothing visible ! 2353: add [edi].rd_ptbWork.ptb_x, cl;Move right in work area ! 2354: add cl, [edi].rd_ptbSave.ptb_x;Move right in save area ! 2355: and cl, SAVE_BUFFER_WIDTH-1 ! 2356: mov [edi].rd_ptbSave.ptb_x, cl ! 2357: mov [edi].rd_ptlScreen.ptl_x, eax ! 2358: jmp x_clipping_done ! 2359: ! 2360: ! 2361: ;-----------------------------------------------------------------------; ! 2362: ; rhs clipping may have to be performed for this rectangle. ! 2363: ;-----------------------------------------------------------------------; ! 2364: ! 2365: clip_on_rhs: ! 2366: mov al,[edi].rd_sizb.sizb_cx ! 2367: add ecx,eax ! 2368: sub ecx,lNextScan ! 2369: jle x_clipping_done ;EAX = amount to clip if positive ! 2370: sub al,cl ;Compute new height ! 2371: jle clear_visible_bit ;Clipped away, nothing visible ! 2372: mov [edi].rd_sizb.sizb_cx, al ! 2373: x_clipping_done: ! 2374: xor bh,bh ;0 to cancel following XOR ! 2375: ! 2376: clear_visible_bit: ! 2377: xor bl,bh ;Update visible bit ! 2378: PLAIN_RET ! 2379: ! 2380: page ! 2381: ! 2382: ;--------------------------Private-Routine------------------------------; ! 2383: ; xor_to_screen ! 2384: ; ! 2385: ; The work area is XORed with the XOR mask and placed on the screen ! 2386: ; ! 2387: ; Entry: ! 2388: ; AL = fbXor ! 2389: ; Returns: ! 2390: ; None ! 2391: ; Error Returns: ! 2392: ; No error return. ! 2393: ; Registers Preserved: ! 2394: ; BP ! 2395: ; Registers Destroyed: ! 2396: ; AX,BX,CX,DX,SI,DI,FLAGS ! 2397: ; Calls: ! 2398: ; None ! 2399: ; ! 2400: ;-----------------------------------------------------------------------; ! 2401: ! 2402: .ERRNZ pd_rd ;Must be at offset 0 ! 2403: ! 2404: align 4 ! 2405: xor_to_screen: ! 2406: xor ebx, ebx ;Zero will be useful soon ! 2407: shr al, 1 ;Set 'C' to FB_WORK_RECT bit ! 2408: ! 2409: .ERRNZ FB_WORK_RECT-00000001b ! 2410: ! 2411: ;-----------------------------------------------------------------------; ! 2412: ; Program the EGA for XOR mode. This will be done using M_PROC_WRITE, ! 2413: ; M_DATA_READ, DR_XOR, and setting GRAF_BIT_MASK to FF. The normal ! 2414: ; sequence of events will have left the bitmask register with 00h and ! 2415: ; the mode register in AND mode. ! 2416: ;-----------------------------------------------------------------------; ! 2417: ! 2418: mov dx, EGA_BASE + GRAF_ADDR ! 2419: mov ax, 0FF00h + GRAF_BIT_MASK ! 2420: out dx, ax ;Enable all bits ! 2421: mov ax, DR_XOR SHL 8 + GRAF_DATA_ROT ! 2422: out dx, ax ! 2423: ! 2424: ;-----------------------------------------------------------------------; ! 2425: ; Compute the offset from the start of the work area and the XOR mask ! 2426: ; (its the same value). If we're to use the new pointer's rectangle, ! 2427: ; then this offset is zero. ! 2428: ;-----------------------------------------------------------------------; ! 2429: ! 2430: mov esi,ppdNew ;assume new pointer is in use ! 2431: jnc have_xor_mask_offset ;EBX = 0 is offset ! 2432: ! 2433: .ERRNZ FB_WORK_RECT-00000001b ! 2434: .ERRE FB_NEW_PTR-00000001b ! 2435: ! 2436: mov esi,offset FLAT:rdWork ;The work area (we be clipping) ! 2437: movzx eax,WORD PTR [esi].rd_ptbWork ;Get origin in work area ! 2438: xchg ah, bl ;BX = ptbWork.ptb_y, AX = ptbWork.ptb_x ! 2439: add eax,ebx ;*1 + X component ! 2440: add ebx,ebx ;*2 ! 2441: add ebx,ebx ;*4 ! 2442: add ebx,eax ;*5 + X = start from work/mask ! 2443: ! 2444: .ERRNZ WORK_WIDTH-5 ! 2445: ! 2446: have_xor_mask_offset: ! 2447: ! 2448: ! 2449: ; Map the proper bank into the destination window for the top destination ! 2450: ; scan line. ! 2451: ! 2452: mov edi,pdsurf ! 2453: mov edx,[esi].rd_ptlScreen.ptl_y ! 2454: mov ulCurrentTopScan,edx ;remember where the top dest scan is ! 2455: cmp edx,[edi].dsurf_rcl2WindowClipD.yTop ;is xor top less than ! 2456: ; current dest bank? ! 2457: jl short xts_map_init_bank ;yes, map in proper bank ! 2458: cmp edx,[edi].dsurf_rcl2WindowClipD.yBottom ;xor top greater than ! 2459: ; current dest bank? ! 2460: jl short xts_init_bank_mapped ;no, proper bank already mapped ! 2461: xts_map_init_bank: ! 2462: ! 2463: ; Map bank containing the top destination (screen) scan line into dest window. ! 2464: ; Note: EBX, ESI, and EDI preserved, according to C calling conventions. ! 2465: ! 2466: ptrCall <dword ptr [edi].dsurf_pfnBankControl2Window>, \ ! 2467: <edi,edx,JustifyTop,MapDestBank> ! 2468: ! 2469: xts_init_bank_mapped: ! 2470: ! 2471: ! 2472: ; Map the cursor bank into the source window. ! 2473: ! 2474: mov edx,ulPtrBankScan ;scan line at end of cursor work bank ! 2475: cmp edx,[edi].dsurf_rcl2WindowClipS.yTop ;is cursor scan less than ! 2476: ; current source bank? ! 2477: jl short xts_map_ptr_bank ;yes, map in proper bank ! 2478: cmp edx,[edi].dsurf_rcl2WindowClipS.yBottom ;cursor scan greater ! 2479: ; than current source ! 2480: ; bank? ! 2481: jl short xts_ptr_bank_mapped ;no, proper bank already mapped ! 2482: xts_map_ptr_bank: ! 2483: ! 2484: ; Map cursor work bank into source window. ! 2485: ; Note: EBX, ESI, and EDI preserved, according to C calling conventions. ! 2486: ! 2487: ptrCall <dword ptr [edi].dsurf_pfnBankControl2Window>, \ ! 2488: <edi,edx,JustifyBottom,MapSourceBank> ! 2489: ! 2490: xts_ptr_bank_mapped: ! 2491: ! 2492: ! 2493: ; Compute the screen address of this rectangle and get its size ! 2494: ! 2495: mov ecx,[edi].dsurf_pvBitmapStart2WindowD ;start of screen bitmap ! 2496: mov edi,lNextScan ;width of screen bitmap ! 2497: imul edi,[esi].rd_ptlScreen.ptl_y ;offset of dest start in screen ! 2498: add edi,[esi].rd_ptlScreen.ptl_x ; buffer ! 2499: add edi,ecx ;virtual address of dest start ! 2500: ! 2501: mov cx,[esi].rd_sizb ;CH = scans to copy ! 2502: ; CL = bytes across to copy ! 2503: ! 2504: .ERRNZ sizb_cy-sizb_cx-1 ! 2505: ! 2506: ;-----------------------------------------------------------------------; ! 2507: ; To save incrementing the work area pointer (BX), subtract the XOR ! 2508: ; mask pointer off of it. Then use [BX][SI] for addressing into the ! 2509: ; XOR mask. As SI is incremented, BX will effectively be incremented. ! 2510: ; We could not do this if the XOR mask and the work area were different ! 2511: ; widths. ! 2512: ; ! 2513: ; Finish computing the pointer to the XOR mask and the delta from the ! 2514: ; XOR mask to the work area. ! 2515: ;-----------------------------------------------------------------------; ! 2516: ! 2517: mov esi,pAndXor ;set address of XOR mask ! 2518: lea esi,[esi][ebx][base_xor_masks-base_and_masks] ! 2519: add ebx,pPtrWork ;start src offset in bitmap ! 2520: mov eax,pdsurf ! 2521: add ebx,[eax].dsurf_pvBitmapStart2WindowS ;start src virtual addr ! 2522: sub ebx,esi ;fudge back so we get away with one ! 2523: ; increment ! 2524: ! 2525: ; Calculate the number of scans we'll do in this bank. ! 2526: ! 2527: mov edx,[eax].dsurf_rcl2WindowClipD.yBottom ! 2528: sub edx,ulCurrentTopScan ;max # of scans that can be handled in ! 2529: ; the initial bank ! 2530: sub eax,eax ! 2531: mov al,ch ;total # of scans to copy ! 2532: cmp eax,edx ;can we handle all remaining scans in ! 2533: ; this bank? ! 2534: jb short @F ;yes ! 2535: mov eax,edx ;no, so we'll do the whole bank's worth ! 2536: @@: ! 2537: add ulCurrentTopScan,eax ;set top scan for next bank ! 2538: sub ch,al ;count this bank's scans off total ! 2539: mov byte ptr cjTotalScans,ch ;remember # of scans after this bank ! 2540: mov ch,al ;# of scans to do in this bank ! 2541: ! 2542: ; Compute the delta to the start of the next scanline of the XOR mask ! 2543: ; and the work area, and the next scan of the screen ! 2544: ! 2545: sub eax,eax ! 2546: mov al,cl ;width to copy in bytes ! 2547: mov edx,WORK_WIDTH ! 2548: sub edx,eax ;offset from end of one source scan to ! 2549: mov ulNextSrcScan,edx ; start of next ! 2550: add edx,lNextScan ;offset from end of one dest scan to ! 2551: sub edx,WORK_WIDTH ; start of next ! 2552: ! 2553: lea eax,[eax*4] ! 2554: neg eax ! 2555: add eax,offset FLAT:xor_to_screen_width_0 ! 2556: ! 2557: push ebp ;remember stack frame pointer ! 2558: mov ebp,ulNextSrcScan ;offset to next XOR scan ! 2559: jmp eax ! 2560: ! 2561: .ERRNZ WORK_WIDTH-5 ! 2562: ;-----------------------------------------------------------------------; ! 2563: ; Register usage for the loop will be: ! 2564: ; ! 2565: ; AX = loop starting address ! 2566: ; BX = offset off [si] to the work area ! 2567: ; CH = height ! 2568: ; DX = delta to next scan of the destination ! 2569: ; SI --> XOR mask ! 2570: ; DI --> Destination ! 2571: ; BP = offset to next byte of XOR mask, next scan of work area ! 2572: ;-----------------------------------------------------------------------; ! 2573: ! 2574: align 4 ! 2575: xor_to_screen_width_5: ! 2576: cmp al, [ebx][esi] ;Load latches from work area ! 2577: movsb ;XOR to the screen ! 2578: xor_to_screen_width_4: ! 2579: cmp al, [ebx][esi] ! 2580: movsb ! 2581: xor_to_screen_width_3: ! 2582: cmp al, [ebx][esi] ! 2583: movsb ! 2584: xor_to_screen_width_2: ! 2585: cmp al, [ebx][esi] ! 2586: movsb ! 2587: xor_to_screen_width_1: ! 2588: cmp al, [ebx][esi] ! 2589: movsb ! 2590: xor_to_screen_width_0: ! 2591: ! 2592: .ERRNZ xor_to_screen_width_0-xor_to_screen_width_1-4 ! 2593: .ERRNZ xor_to_screen_width_1-xor_to_screen_width_2-4 ! 2594: .ERRNZ xor_to_screen_width_2-xor_to_screen_width_3-4 ! 2595: .ERRNZ xor_to_screen_width_3-xor_to_screen_width_4-4 ! 2596: .ERRNZ xor_to_screen_width_4-xor_to_screen_width_5-4 ! 2597: ! 2598: add esi, ebp ;--> next scan's XOR mask, work addr ! 2599: add edi, edx ;--> next scan's destination ! 2600: dec ch ;count down lines in this bank ! 2601: jz short @F ;no more lines in this bank ! 2602: jmp eax ;do the next line in this bank ! 2603: ! 2604: align 4 ! 2605: @@: ;done with bank ! 2606: pop ebp ;retrieve stack frame pointer ! 2607: cmp byte ptr cjTotalScans,0 ;more lines (in next dest bank)? ! 2608: jz short xts_done ;no, we're done ! 2609: ;advance to next dest bank and continue ! 2610: ; XORing ! 2611: push eax ;preserve entry vector ! 2612: push edx ;preserve dest next scan ! 2613: mov eax,pdsurf ! 2614: sub edi,[eax].dsurf_pvBitmapStart2WindowD ! 2615: ;calculate the destination offset ! 2616: ; within the bitmap, because the start ! 2617: ; address is about to move ! 2618: mov edx,ulCurrentTopScan ! 2619: ! 2620: ; Note: EBX, ESI, and EDI preserved, according to C calling conventions. ! 2621: ! 2622: ptrCall <dword ptr [eax].dsurf_pfnBankControl2Window>, \ ! 2623: <eax,edx,JustifyTop,MapDestBank> ;map in the next dest bank ! 2624: ! 2625: mov eax,pdsurf ! 2626: add edi,[eax].dsurf_pvBitmapStart2WindowD ! 2627: ;add back in the bitmap start address ! 2628: ; to yield the virtual dest address ! 2629: mov edx,[eax].dsurf_rcl2WindowClipD.yBottom ! 2630: sub edx,ulCurrentTopScan ;max # of scans that can be handled in ! 2631: ; the new bank ! 2632: sub eax,eax ! 2633: mov al,byte ptr cjTotalScans ;remaining scan count ! 2634: cmp eax,edx ;can we handle all remaining scans in ! 2635: ; this bank? ! 2636: jb short @F ;yes ! 2637: mov eax,edx ;no, so we'll do the whole bank's worth ! 2638: @@: ! 2639: add ulCurrentTopScan,eax ;set top scan for next bank ! 2640: sub byte ptr cjTotalScans,al ;count this bank's scans off total ! 2641: mov ch,al ;# of scans to do in this bank ! 2642: ! 2643: pop edx ;restore dest next scan ! 2644: pop eax ;restore entry vector ! 2645: ! 2646: push ebp ;remember stack frame pointer ! 2647: mov ebp,ulNextSrcScan ;offset to next XOR scan ! 2648: jmp eax ;do the next block of scans ! 2649: ! 2650: xts_done: ! 2651: PLAIN_RET ! 2652: ! 2653: page ! 2654: ;--------------------------Private-Routine------------------------------; ! 2655: ; color_pointer_to_screen ! 2656: ; ! 2657: ; The color pointer is output to the screen using AND/XOR/COLOR masks. ! 2658: ; ! 2659: ; Entry: ! 2660: ; None ! 2661: ; Returns: ! 2662: ; None ! 2663: ; Error Returns: ! 2664: ; No error return. ! 2665: ; Registers Preserved: ! 2666: ; BP ! 2667: ; Registers Destroyed: ! 2668: ; AX,BX,CX,DX,SI,DI,FLAGS ! 2669: ; Calls: ! 2670: ; None ! 2671: ; ! 2672: ;-----------------------------------------------------------------------; ! 2673: ! 2674: align 4 ! 2675: color_pointer_to_screen: ! 2676: ! 2677: .ERRNZ pd_rd ;Must be at offset 0 ! 2678: ! 2679: ; Set up variables that don't change from plane to plane in the outer loop ! 2680: ! 2681: mov esi,ppdNew ! 2682: test fbXor,FB_WORK_RECT ! 2683: jz short cps_have_pointer_rect ! 2684: mov esi,offset FLAT:rdWork ;the work area (we be clipping) ! 2685: cps_have_pointer_rect: ! 2686: mov prclSource,esi ! 2687: ! 2688: ; Map the proper bank into the destination window for the top destination ! 2689: ; scan line. ! 2690: ! 2691: mov ebx,pdsurf ! 2692: mov edx,[esi].rd_ptlScreen.ptl_y ! 2693: mov ulCurrentTopScan,edx ;remember where the top dest scan is ! 2694: cmp edx,[ebx].dsurf_rcl2WindowClipD.yTop ;is copy top less than ! 2695: ; current dest bank? ! 2696: jl short cpts_map_init_bank ;yes, map in proper bank ! 2697: cmp edx,[ebx].dsurf_rcl2WindowClipD.yBottom ;copy top greater than ! 2698: ; current dest bank? ! 2699: jl short cpts_init_bank_mapped ;no, proper bank already mapped ! 2700: cpts_map_init_bank: ! 2701: ! 2702: ; Map bank containing the top destination (screen) scan line into dest window. ! 2703: ; Note: EBX, ESI, and EDI preserved, according to C calling conventions. ! 2704: ! 2705: ptrCall <dword ptr [ebx].dsurf_pfnBankControl2Window>, \ ! 2706: <ebx,edx,JustifyTop,MapDestBank> ! 2707: ! 2708: cpts_init_bank_mapped: ! 2709: ! 2710: ! 2711: ; Map the cursor bank into the source window. ! 2712: ! 2713: mov edx,ulPtrBankScan ;scan line at end of cursor work bank ! 2714: cmp edx,[ebx].dsurf_rcl2WindowClipS.yTop ;is cursor scan less than ! 2715: ; current source bank? ! 2716: jl short cpts_map_ptr_bank ;yes, map in proper bank ! 2717: cmp edx,[ebx].dsurf_rcl2WindowClipS.yBottom ;cursor scan greater ! 2718: ; than current source ! 2719: ; bank? ! 2720: jl short cpts_ptr_bank_mapped ;no, proper bank already mapped ! 2721: cpts_map_ptr_bank: ! 2722: ! 2723: ; Map cursor work bank into source window. ! 2724: ; Note: EBX, ESI, and EDI preserved, according to C calling conventions. ! 2725: ! 2726: ptrCall <dword ptr [ebx].dsurf_pfnBankControl2Window>, \ ! 2727: <ebx,edx,JustifyBottom,MapSourceBank> ! 2728: ! 2729: cpts_ptr_bank_mapped: ! 2730: ! 2731: ! 2732: ; Offset to next screen scan, minus the width of the work area, will ! 2733: ; come in handy in the inner loop. ! 2734: ! 2735: mov eax,lNextScan ;width of screen bitmap ! 2736: mov edi,eax ;set aside for computing the screen address ! 2737: sub eax,WORK_WIDTH ! 2738: mov ulScanMinusWorkWidth,eax ! 2739: ! 2740: ; Compute the screen address of the rectangle in this bank ! 2741: ! 2742: imul edi,[esi].rd_ptlScreen.ptl_y ;offset of dest start in screen ! 2743: add edi,[esi].rd_ptlScreen.ptl_x ; buffer ! 2744: add edi,[ebx].dsurf_pvBitmapStart2WindowD ;virtual address of dest ! 2745: ; start ! 2746: mov pDest,edi ! 2747: ! 2748: ; Remember the save source point. ! 2749: ! 2750: sub eax,eax ! 2751: mov ax,word ptr [esi].rd_ptbSave ! 2752: mov jSaveSourceXY,eax ! 2753: mov byte ptr jNextSaveSourceY,ah ! 2754: ! 2755: ! 2756: ; Remember the work source point. ! 2757: ! 2758: mov ax,word ptr [esi].rd_ptbWork ! 2759: mov jWorkSourceXY,eax ! 2760: mov byte ptr jNextWorkSourceY,ah ! 2761: ! 2762: ! 2763: ; Calculate the number of scans we'll do in this bank. ! 2764: ! 2765: mov edx,[ebx].dsurf_rcl2WindowClipD.yBottom ! 2766: sub edx,ulCurrentTopScan ;max # of scans that can be handled in ! 2767: ; the initial bank ! 2768: mov ch,byte ptr [esi].rd_sizb+1 ;total # of scans to copy ! 2769: sub eax,eax ! 2770: mov al,ch ! 2771: cmp eax,edx ;can we handle all remaining scans in ! 2772: ; this bank? ! 2773: jb short @F ;yes ! 2774: mov eax,edx ;no, so we'll do the whole bank's worth ! 2775: @@: ! 2776: add ulCurrentTopScan,eax ;set top scan for next bank ! 2777: add byte ptr jNextSaveSourceY,al ;top save source scan for next bank ! 2778: add byte ptr jNextWorkSourceY,al ;top work source scan for next bank ! 2779: sub ch,al ;count this bank's scans off total ! 2780: mov byte ptr cjTotalScans,ch ;remember # of scans after this bank ! 2781: mov byte ptr jScansInBank,al ;# of scans to do in this bank ! 2782: ! 2783: ; Set the virtual address of the save area ! 2784: ! 2785: mov eax,[ebx].dsurf_pvBitmapStart2WindowS ;start of source bitmap ! 2786: add eax,pPtrSave ;virtual address of save area ! 2787: mov pWorkingSave,eax ! 2788: ! 2789: ; Loop through banks that this cursor spans ! 2790: ! 2791: cpts_bank_loop: ! 2792: ! 2793: ; Initial plane is plane 3 ! 2794: ! 2795: mov iPlaneMask,MM_C3 ! 2796: ! 2797: ;-----------------------------------------------------------------------; ! 2798: ; Program the VGA for SET mode. This will be done using M_PROC_WRITE, ! 2799: ; M_DATA_READ, DR_SET, and setting GRAF_BIT_MASK to FF. The normal ! 2800: ; sequence of events will have left the bitmask register with 00h and ! 2801: ; the mode register in AND mode. ! 2802: ;-----------------------------------------------------------------------; ! 2803: ! 2804: mov dx,EGA_BASE + GRAF_ADDR ! 2805: mov ax,0FF00h + GRAF_BIT_MASK ! 2806: out dx,ax ;enable all bits ! 2807: mov ax,DR_SET SHL 8 + GRAF_DATA_ROT ! 2808: out dx,ax ! 2809: mov al,GRAF_READ_MAP ! 2810: out dx,al ;leave the GC Index pointing to the Read Map reg ! 2811: ! 2812: cps_do_next_plane: ! 2813: ! 2814: ; Set write plane enable register to the ONE plane we will alter ! 2815: ! 2816: mov al,byte ptr iPlaneMask ;set Map Mask ! 2817: mov dx,EGA_BASE + SEQ_DATA ! 2818: out dx,al ! 2819: ! 2820: ; Set read plane to plane to read from ! 2821: ! 2822: shr al,1 ;map plane into ReadMask ! 2823: cmp al,100b ;set Carry if not C3 (plane 3) ! 2824: adc al,-1 ;sub 1 only if C3 ! 2825: mov dl,GRAF_DATA ! 2826: out dx,al ! 2827: ! 2828: mov esi,prclSource ;point to source rect ! 2829: mov edi,pDest ;point to initial dest byte ! 2830: ! 2831: mov eax,jSaveSourceXY ! 2832: mov edx,jWorkSourceXY ! 2833: ! 2834: .ERRNZ ptb_y-ptb_x-1 ! 2835: ! 2836: mov cl,byte ptr [esi].rd_sizb ! 2837: ! 2838: .ERRNZ sizb_cy-sizb_cx-1 ! 2839: ! 2840: mov bl,al ;see if save area is contiguous ! 2841: add bl,cl ! 2842: sub bl,SAVE_BUFFER_WIDTH ;BL = is overhang ! 2843: jle short call_cps_do_a_pass ;no overhang ! 2844: ! 2845: sub cl,bl ;set X extent for pass 1 ! 2846: mov bh,cl ;need it for pass 2 ! 2847: mov ch,byte ptr jScansInBank ;# of scans to do in this bank ! 2848: push ebx ! 2849: call cps_do_a_pass ;process first half ! 2850: pop ebx ! 2851: ! 2852: mov esi,prclSource ;point to source rect ! 2853: mov edi,pDest ;point to initial dest byte ! 2854: ! 2855: mov eax,jSaveSourceXY ! 2856: mov edx,jWorkSourceXY ! 2857: ! 2858: .ERRNZ ptb_y-ptb_x-1 ! 2859: ! 2860: mov cl,byte ptr [esi].rd_sizb ! 2861: ! 2862: .ERRNZ sizb_cy-sizb_cx-1 ! 2863: ! 2864: add dl,bh ;move right in work area ! 2865: mov cl,bl ;set new extent ! 2866: xor al,al ;X origin in save area is 0 ! 2867: movzx ebx,bh ;move right in destination area ! 2868: add edi,ebx ! 2869: ! 2870: call_cps_do_a_pass: ! 2871: mov ch,byte ptr jScansInBank ;# of scans to do in this bank ! 2872: call cps_do_a_pass ;process second half (or the whole ! 2873: ; color cursor, if no overhang) ! 2874: ! 2875: shr iPlaneMask,1 ! 2876: jnc cps_do_next_plane ! 2877: ! 2878: .ERRNZ MM_C0-00000001b ! 2879: .ERRNZ MM_C1-00000010b ! 2880: .ERRNZ MM_C2-00000100b ! 2881: .ERRNZ MM_C3-00001000b ! 2882: ! 2883: ;we've done all planes in this bank ! 2884: cmp byte ptr cjTotalScans,0 ;more lines (in next dest bank)? ! 2885: jz short cpts_done ;no, we're done ! 2886: ;advance to next dest bank and continue ! 2887: ; XORing ! 2888: ! 2889: ; Advance the source Y coordinates to match the bank advance we're about to do. ! 2890: ! 2891: mov al,byte ptr jNextSaveSourceY ! 2892: mov byte ptr jSaveSourceXY+1,al ! 2893: mov al,byte ptr jNextWorkSourceY ! 2894: mov byte ptr jWorkSourceXY+1,al ! 2895: ! 2896: ; Advance to the next dest bank. ! 2897: ! 2898: mov ebx,pdsurf ! 2899: mov edx,ulCurrentTopScan ! 2900: ! 2901: ; Note: EBX, ESI, and EDI preserved, according to C calling conventions. ! 2902: ! 2903: ptrCall <dword ptr [ebx].dsurf_pfnBankControl2Window>, \ ! 2904: <ebx,edx,JustifyTop,MapDestBank> ;map in the next dest bank ! 2905: ! 2906: ; Compute the screen start address of the rectangle in this bank ! 2907: ! 2908: mov esi,prclSource ;point to source rect ! 2909: mov edi,lNextScan ;width of screen bitmap ! 2910: imul edi,ulCurrentTopScan ;offset of dest start in screen ! 2911: add edi,[esi].rd_ptlScreen.ptl_x ; buffer ! 2912: add edi,[ebx].dsurf_pvBitmapStart2WindowD ;virtual address of dest ! 2913: ; start ! 2914: mov pDest,edi ! 2915: ! 2916: mov edx,[ebx].dsurf_rcl2WindowClipD.yBottom ! 2917: sub edx,ulCurrentTopScan ;max # of scans that can be handled in ! 2918: ; the new bank ! 2919: sub eax,eax ! 2920: mov al,byte ptr cjTotalScans ;remaining scan count ! 2921: cmp eax,edx ;can we handle all remaining scans in ! 2922: ; this bank? ! 2923: jb short @F ;yes ! 2924: mov eax,edx ;no, so we'll do the whole bank's worth ! 2925: @@: ! 2926: add ulCurrentTopScan,eax ;set top scan for next bank ! 2927: add byte ptr jNextSaveSourceY,al ;top save source scan for next bank ! 2928: add byte ptr jNextWorkSourceY,al ;top work source scan for next bank ! 2929: sub byte ptr cjTotalScans,al ;count this bank's scans off total ! 2930: mov byte ptr jScansInBank,al ;# of scans to do in this bank ! 2931: ! 2932: jmp cpts_bank_loop ;do the next block of scans ! 2933: ! 2934: cpts_done: ! 2935: PLAIN_RET ! 2936: ! 2937: page ! 2938: ;--------------------------Private-Routine------------------------------; ! 2939: ; cps_do_a_pass ! 2940: ; ! 2941: ; Output one plane of the color pointer to the screen using ! 2942: ; AND/XOR/COLOR masks. Does not handle bank spanning; that is taken care ! 2943: ; of in color_pointer_to_screen. ! 2944: ; ! 2945: ; Entry: ! 2946: ; AH = ptbSave.ptb_y, AL = ptbSave.ptb_x ! 2947: ; DH = ptbWork.ptb_y, DL = ptbWork.ptb_x ! 2948: ; CL = x bytes to process ! 2949: ; CH = y scans to process ! 2950: ; EDI --> Destination (screen area) ! 2951: ; EBP = stack frame ! 2952: ; VGA set up to enable writes to proper plane ! 2953: ; Returns: ! 2954: ; None ! 2955: ; Error Returns: ! 2956: ; No error return. ! 2957: ; Registers Preserved: ! 2958: ; EBP ! 2959: ; Registers Destroyed: ! 2960: ; EAX,EBX,ECX,EDX,ESI,EDI,EFLAGS ! 2961: ; Calls: ! 2962: ; None ! 2963: ; ! 2964: ;-----------------------------------------------------------------------; ! 2965: ! 2966: align 4 ! 2967: cps_do_a_pass: ! 2968: ! 2969: ;-----------------------------------------------------------------------; ! 2970: ; Compute the offset within the save area. Note that this is relative ! 2971: ; to screen_buf. ! 2972: ; AH = ptbSave.ptb_y, AL = ptbSave.ptb_x ! 2973: ;-----------------------------------------------------------------------; ! 2974: ! 2975: shl ah,3 ! 2976: add al,ah ;y * 8 + x ! 2977: xor ah,ah ! 2978: cwde ! 2979: mov ulOffsetSave,eax ! 2980: ! 2981: .ERRNZ SAVE_BUFFER_WIDTH-8 ! 2982: .ERRNZ SAVE_BUFFER_HEIGHT-32 ! 2983: ! 2984: mov esi,pWorkingSave ;point to the save area ! 2985: add esi,eax ;ESI --> start address in save area ! 2986: ! 2987: ! 2988: ;-----------------------------------------------------------------------; ! 2989: ; Compute the offset within the AND/XOR masks. ! 2990: ; DH = ptbWork.ptb_y, DL = ptbWork.ptb_x ! 2991: ;-----------------------------------------------------------------------; ! 2992: ! 2993: xor ebx,ebx ! 2994: xchg dh,bl ! 2995: add edx,ebx ;y * 1 + x ! 2996: add ebx,ebx ;y * 2 ! 2997: add ebx,ebx ;y * 4 ! 2998: add ebx,edx ;y * 5 + x ! 2999: mov ulOffsetMask,ebx ! 3000: add ebx,pAndXor ;EBX --> start address of AND mask ! 3001: sub ebx,edi ;make EBX relative to EDI ! 3002: ! 3003: ;-----------------------------------------------------------------------; ! 3004: ; Compute the delta to the start of the next scanline of destination ! 3005: ; screen area ! 3006: ;-----------------------------------------------------------------------; ! 3007: ! 3008: mov al, cl ! 3009: movsx eax, al ! 3010: mov edx,lNextScan ! 3011: sub edx,eax ! 3012: mov ulDeltaScreen,edx ;delta to next scan of screen area ! 3013: ! 3014: ;-----------------------------------------------------------------------; ! 3015: ; Calculate EDX = jump table address ! 3016: ;-----------------------------------------------------------------------; ! 3017: ! 3018: mov edx,color_to_screen_entry_table[eax*4] ! 3019: ! 3020: .ERRNZ WORK_WIDTH-5 ! 3021: ! 3022: ;-----------------------------------------------------------------------; ! 3023: ; Compute the offset within the COLOR mask. ! 3024: ;-----------------------------------------------------------------------; ! 3025: ! 3026: push ebp ;need an extra register ! 3027: mov al,byte ptr iPlaneMask ;AL --> iPlaneMask ! 3028: mov ebp,ulOffsetMask ;EBP --> usoffset_mask ! 3029: add ebp,pColor ;EBP --> start address of COLOR mask ! 3030: shr al,1 ! 3031: jz @F ! 3032: add ebp,MASK_LENGTH ! 3033: shr al,1 ! 3034: jz @F ! 3035: add ebp,MASK_LENGTH ! 3036: shr al,1 ! 3037: jz @F ! 3038: add ebp,MASK_LENGTH ! 3039: @@: ! 3040: sub ebp,edi ;make BP relative ! 3041: ! 3042: jmp edx ! 3043: ! 3044: ;-----------------------------------------------------------------------; ! 3045: ; Register usage for the loop will be: ! 3046: ; ! 3047: ; EBX = offset off EDI to the AND mask ! 3048: ; CH = height ! 3049: ; EDX = loop starting address ! 3050: ; ESI --> Source (save area) ! 3051: ; EDI --> Destination (screen area) ! 3052: ; EBP = offset off EDI to the COLOR mask ! 3053: ;-----------------------------------------------------------------------; ! 3054: ! 3055: align 4 ! 3056: color_to_screen_width_5: ! 3057: lodsb ! 3058: and al,[ebx][edi] ! 3059: xor al,[ebp][edi] ! 3060: stosb ! 3061: color_to_screen_width_4: ! 3062: lodsb ! 3063: and al,[ebx][edi] ! 3064: xor al,[ebp][edi] ! 3065: stosb ! 3066: color_to_screen_width_3: ! 3067: lodsb ! 3068: and al,[ebx][edi] ! 3069: xor al,[ebp][edi] ! 3070: stosb ! 3071: color_to_screen_width_2: ! 3072: lodsb ! 3073: and al,[ebx][edi] ! 3074: xor al,[ebp][edi] ! 3075: stosb ! 3076: color_to_screen_width_1: ! 3077: lodsb ! 3078: and al,[ebx][edi] ! 3079: xor al,[ebp][edi] ! 3080: stosb ! 3081: color_to_screen_width_0: ! 3082: ! 3083: mov eax,ebp ;EAX --> next scan's COLOR mask ! 3084: pop ebp ! 3085: sub eax,ulScanMinusWorkWidth ! 3086: ! 3087: ; WE HAVE NO SPARE REGISTERS HERE ! 3088: ! 3089: xchg eax,ulOffsetSave ! 3090: add al,SAVE_BUFFER_WIDTH ;Take into account wrap around ! 3091: mov esi,pWorkingSave ;point to the save area ! 3092: add esi,eax ;ESI --> next scan's save area ! 3093: xchg ulOffsetSave,eax ! 3094: ! 3095: add edi,ulDeltaScreen ;EDI --> next scan's screen area ! 3096: sub ebx,ulScanMinusWorkWidth ! 3097: ;EBX --> next scan's AND mask ! 3098: dec ch ! 3099: jz cps_exit ! 3100: ! 3101: push ebp ! 3102: mov ebp,eax ;EBP --> next scan's COLOR mask ! 3103: jmp edx ;do the next scan line ! 3104: ! 3105: cps_exit: ! 3106: PLAIN_RET ! 3107: ! 3108: page ! 3109: ! 3110: ;--------------------------Private-Routine------------------------------; ! 3111: ; and_into_work ! 3112: ; ! 3113: ; All rectangles which are to be ANDed into the work area are ! 3114: ; dispatched to the routine which will do the actual ANDing. ! 3115: ; ! 3116: ; Entry: ! 3117: ; AL = fbAndRead ! 3118: ; Returns: ! 3119: ; None ! 3120: ; Error Returns: ! 3121: ; No error return. ! 3122: ; Registers Preserved: ! 3123: ; BP ! 3124: ; Registers Destroyed: ! 3125: ; AX,BX,CX,DX,SI,DI,FLAGS ! 3126: ; Calls: ! 3127: ; and_from_screen ! 3128: ; and_from_save ! 3129: ; ! 3130: ;-----------------------------------------------------------------------; ! 3131: ! 3132: align 4 ! 3133: and_into_work: ! 3134: ! 3135: push ebp ! 3136: ! 3137: ;-----------------------------------------------------------------------; ! 3138: ; Program the EGA for AND mode. This will be done using M_PROC_WRITE, ! 3139: ; M_DATA_READ, DR_AND, and setting GRAF_BIT_MASK to FF. All but setting ! 3140: ; DR_AND was set by save_hw_regs. All planes were also enabled for ! 3141: ; writing by save_hw_regs. ! 3142: ;-----------------------------------------------------------------------; ! 3143: ! 3144: mov ecx, eax ! 3145: mov dx, EGA_BASE + GRAF_ADDR ! 3146: mov ax, DR_AND SHL 8 + GRAF_DATA_ROT ! 3147: out dx, ax ! 3148: mov eax, ecx ! 3149: ! 3150: ;-----------------------------------------------------------------------; ! 3151: ; If FB_NEW_PTR or FB_WORK_AREA is set, then we only have a single ! 3152: ; rectangle to deal with, located on the screen. ! 3153: ;-----------------------------------------------------------------------; ! 3154: ! 3155: mov esi, ppdNew ! 3156: test al, FB_NEW_PTR ! 3157: jnz aiw_source_is_screen ! 3158: mov esi, offset FLAT:rdWork ! 3159: test al, FB_WORK_RECT ! 3160: jnz aiw_source_is_screen ! 3161: ! 3162: ; Some combination of FB_READ_X, FB_READ_Y, FB_OVERLAP exists ! 3163: ! 3164: test al, FB_READ_Y ! 3165: jz @F ! 3166: mov esi, offset FLAT:rdReadY ! 3167: call and_from_screen ! 3168: mov al, fbAndRead ! 3169: @@: ! 3170: ! 3171: test al, FB_READ_X ! 3172: jz @F ! 3173: mov esi, offset FLAT:rdReadX ! 3174: aiw_source_is_screen: ! 3175: call and_from_screen ! 3176: mov al, fbAndRead ! 3177: @@: ! 3178: ! 3179: test al, FB_OVERLAP ! 3180: jz @F ! 3181: mov esi, offset FLAT:rdOverlap ! 3182: call and_from_save ! 3183: @@: ! 3184: ! 3185: pop ebp ! 3186: ! 3187: PLAIN_RET ! 3188: ! 3189: page ! 3190: ! 3191: ;--------------------------Private-Routine------------------------------; ! 3192: ; and_from_screen ! 3193: ; ! 3194: ; The screen is ANDed with the AND mask and placed into the work area ! 3195: ; ! 3196: ; Entry: ! 3197: ; ESI --> RECT_DATA structure to use ! 3198: ; EGA programmed for AND mode ! 3199: ; Returns: ! 3200: ; None ! 3201: ; Error Returns: ! 3202: ; No error return. ! 3203: ; Registers Preserved: ! 3204: ; BP ! 3205: ; Registers Destroyed: ! 3206: ; AX,BX,CX,DX,SI,DI,FLAGS ! 3207: ; Calls: ! 3208: ; None ! 3209: ; ! 3210: ;-----------------------------------------------------------------------; ! 3211: ! 3212: align 4 ! 3213: and_from_screen: ! 3214: ! 3215: .ERRNZ pd_rd ;Must be at offset 0 ! 3216: ! 3217: mov eax,lNextScan ! 3218: sub eax,WORK_WIDTH ! 3219: mov ulNextSrcScan,eax ;set the source advance offset ! 3220: ! 3221: ;-----------------------------------------------------------------------; ! 3222: ; Map in the source and destination banks. ! 3223: ;-----------------------------------------------------------------------; ! 3224: ! 3225: ; Map the proper bank into the source window for the top source scan line. ! 3226: ! 3227: mov edi,pdsurf ! 3228: mov edx,[esi].rd_ptlScreen.ptl_y ! 3229: mov ulCurrentTopScan,edx ;remember where the top source scan is ! 3230: cmp edx,[edi].dsurf_rcl2WindowClipS.yTop ;is AND top less than ! 3231: ; current source bank? ! 3232: jl short afscr_map_init_bank ;yes, map in proper bank ! 3233: cmp edx,[edi].dsurf_rcl2WindowClipS.yBottom ;AND top greater than ! 3234: ; current source bank? ! 3235: jl short afscr_init_bank_mapped ;no, proper bank already mapped ! 3236: afscr_map_init_bank: ! 3237: ! 3238: ; Map bank containing the top destination (screen) scan line into dest window. ! 3239: ; Note: EBX, ESI, and EDI preserved, according to C calling conventions. ! 3240: ! 3241: ptrCall <dword ptr [edi].dsurf_pfnBankControl2Window>, \ ! 3242: <edi,edx,JustifyTop,MapSourceBank> ! 3243: ! 3244: afscr_init_bank_mapped: ! 3245: ! 3246: ! 3247: ; Map the cursor bank into the destination window. ! 3248: ! 3249: mov edx,ulPtrBankScan ;scan line at end of cursor work bank ! 3250: cmp edx,[edi].dsurf_rcl2WindowClipD.yTop ;is cursor scan less than ! 3251: ; current dest bank? ! 3252: jl short afscr_map_ptr_bank ;yes, map in proper bank ! 3253: cmp edx,[edi].dsurf_rcl2WindowClipD.yBottom ;cursor scan greater ! 3254: ; than current dest ! 3255: ; bank? ! 3256: jl short afscr_ptr_bank_mapped ;no, proper bank already mapped ! 3257: afscr_map_ptr_bank: ! 3258: ! 3259: ; Map cursor work bank into source window. ! 3260: ; Note: EBX, ESI, and EDI preserved, according to C calling conventions. ! 3261: ! 3262: ptrCall <dword ptr [edi].dsurf_pfnBankControl2Window>, \ ! 3263: <edi,edx,JustifyBottom,MapDestBank> ! 3264: ! 3265: afscr_ptr_bank_mapped: ! 3266: ! 3267: ! 3268: ;-----------------------------------------------------------------------; ! 3269: ; Compute the screen address of this rectangle and get its size ! 3270: ;-----------------------------------------------------------------------; ! 3271: ! 3272: mov ebx,lNextScan ! 3273: imul ebx,[esi].rd_ptlScreen.ptl_y ! 3274: add ebx,[esi].rd_ptlScreen.ptl_x ;start source offset in bitmap ! 3275: movzx ecx,WORD PTR [esi].rd_sizb ;CH = scans to copy ! 3276: ; CL = bytes across to copy ! 3277: ! 3278: .ERRNZ sizb_cy-sizb_cx-1 ! 3279: ! 3280: ;-----------------------------------------------------------------------; ! 3281: ; Compute the offset from the start of the work area and the AND mask ! 3282: ; (it's the same value). ! 3283: ;-----------------------------------------------------------------------; ! 3284: ! 3285: xor eax,eax ! 3286: movzx edx,WORD PTR [esi].rd_ptbWork ;Get origin in work area ! 3287: xchg al,dh ;AX = ptbWork.ptb_y, DX = ptbWork.ptb_x ! 3288: add edx,eax ;*1 + X component ! 3289: add eax,eax ;*2 ! 3290: add eax,eax ;*4 ! 3291: add eax,edx ;*5 + X = start from work/mask ! 3292: mov edi,eax ! 3293: ! 3294: .ERRNZ WORK_WIDTH-5 ! 3295: ! 3296: ;-----------------------------------------------------------------------; ! 3297: ; To save incrementing the source pointer (BX), subtract the AND ! 3298: ; mask pointer off of it. Then use [BX][SI] for addressing into the ! 3299: ; source. As SI is incremented, BX will effectively be incremented. ! 3300: ; ! 3301: ; The source pointer will have to be adjusted by lNextScan-sizb_cx. ! 3302: ;-----------------------------------------------------------------------; ! 3303: ! 3304: mov esi,pAndXor ;Set address of AND mask ! 3305: add esi,edi ! 3306: add edi,pPtrWork ;start dest offset in bitmap ! 3307: mov eax,pdsurf ! 3308: add edi,[eax].dsurf_pvBitmapStart2WindowD ;start dest virtual addr ! 3309: add ebx,[eax].dsurf_pvBitmapStart2WindowS ;start src virtual addr ! 3310: sub ebx,esi ;fudge back so we get away with one ! 3311: ; increment ! 3312: ! 3313: ; Calculate the number of scans we'll do in this bank. ! 3314: ! 3315: mov edx,[eax].dsurf_rcl2WindowClipS.yBottom ! 3316: sub edx,ulCurrentTopScan ;max # of scans that can be handled in ! 3317: ; the initial bank ! 3318: sub eax,eax ! 3319: mov al,ch ;total # of scans to copy ! 3320: cmp eax,edx ;can we handle all remaining scans in ! 3321: ; this bank? ! 3322: jb short @F ;yes ! 3323: mov eax,edx ;no, so we'll do the whole bank's worth ! 3324: @@: ! 3325: add ulCurrentTopScan,eax ;set top scan for next bank ! 3326: sub ch,al ;count this bank's scans off total ! 3327: mov byte ptr cjTotalScans,ch ;remember # of scans after this bank ! 3328: mov ch,al ;# of scans to do in this bank ! 3329: ! 3330: ; Compute the delta to the start of the next scanline of the AND mask ! 3331: ; and the work area, and the next scan of the screen ! 3332: ! 3333: sub eax,eax ! 3334: mov al,cl ! 3335: mov edx,WORK_WIDTH ! 3336: sub edx,eax ! 3337: ! 3338: ; Look up the loop entry point, and start ANDing. ! 3339: ! 3340: mov eax,and_from_screen_entry_table[eax*4] ;look up the loop entry ! 3341: push ebp ;preserve stack frame pointer ! 3342: mov ebp,ulNextSrcScan ;source offset to next scan ! 3343: jmp eax ;enter the ANDing loop ! 3344: ! 3345: .ERRNZ WORK_WIDTH-5 ! 3346: ;-----------------------------------------------------------------------; ! 3347: ; Register usage for the loop will be: ! 3348: ; ! 3349: ; EAX = loop entry address ! 3350: ; EBX = offset off of SI to the screen source ! 3351: ; CH = height ! 3352: ; EDX = offset to next scan of AND mask & work area ! 3353: ; ESI --> AND mask ! 3354: ; EDI --> Destination in work area ! 3355: ;-----------------------------------------------------------------------; ! 3356: ! 3357: align 4 ! 3358: and_from_screen_width_5: ! 3359: cmp al, [ebx][esi] ;Load latches from work area ! 3360: movsb ;AND from screen into work area ! 3361: and_from_screen_width_4: ! 3362: cmp al, [ebx][esi] ! 3363: movsb ! 3364: and_from_screen_width_3: ! 3365: cmp al, [ebx][esi] ! 3366: movsb ! 3367: and_from_screen_width_2: ! 3368: cmp al, [ebx][esi] ! 3369: movsb ! 3370: and_from_screen_width_1: ! 3371: cmp al, [ebx][esi] ! 3372: movsb ! 3373: and_from_screen_width_0: ! 3374: ! 3375: add esi,edx ;--> next AND mask ! 3376: add edi,edx ;--> next destination ! 3377: add ebx,ebp ;--> next source ! 3378: ! 3379: dec ch ;count down scans in this bank ! 3380: jz short @F ;bank is finished ! 3381: jmp eax ;do next scan in this bank ! 3382: ! 3383: align 4 ! 3384: @@: ! 3385: pop ebp ;restore stack frame pointer ! 3386: cmp byte ptr cjTotalScans,0 ;more lines (in next dest bank)? ! 3387: jz short afscr_done ;no, we're done ! 3388: ;advance to next dest bank and continue ! 3389: ; ANDing ! 3390: push eax ;preserve entry vector ! 3391: push edx ;preserve dest next scan ! 3392: mov eax,pdsurf ! 3393: sub ebx,[eax].dsurf_pvBitmapStart2WindowS ! 3394: ;calculate the source offset within the ! 3395: ; bitmap, because the start address is ! 3396: ; about to move ! 3397: mov edx,ulCurrentTopScan ! 3398: ! 3399: ; Note: EBX, ESI, and EDI preserved, according to C calling conventions. ! 3400: ! 3401: ptrCall <dword ptr [eax].dsurf_pfnBankControl2Window>, \ ! 3402: <eax,edx,JustifyTop,MapSourceBank> ;map in the next source bank ! 3403: ! 3404: mov eax,pdsurf ! 3405: add ebx,[eax].dsurf_pvBitmapStart2WindowS ! 3406: ;add back in the bitmap start address ! 3407: ; to yield the virtual source address ! 3408: mov edx,[eax].dsurf_rcl2WindowClipS.yBottom ! 3409: sub edx,ulCurrentTopScan ;max # of scans that can be handled in ! 3410: ; the new bank ! 3411: sub eax,eax ! 3412: mov al,byte ptr cjTotalScans ;remaining scan count ! 3413: cmp eax,edx ;can we handle all remaining scans in ! 3414: ; this bank? ! 3415: jb short @F ;yes ! 3416: mov eax,edx ;no, so we'll do the whole bank's worth ! 3417: @@: ! 3418: add ulCurrentTopScan,eax ;set top scan for next bank ! 3419: sub byte ptr cjTotalScans,al ;count this bank's scans off total ! 3420: mov ch,al ;# of scans to do in this bank ! 3421: ! 3422: pop edx ;restore dest next scan ! 3423: pop eax ;restore entry vector ! 3424: ! 3425: push ebp ;preserve stack frame pointer ! 3426: mov ebp,ulNextSrcScan ;source offset to next scan ! 3427: jmp eax ;do the next block of scans ! 3428: ! 3429: afscr_done: ! 3430: PLAIN_RET ! 3431: ! 3432: page ! 3433: ! 3434: ;--------------------------Private-Routine------------------------------; ! 3435: ; and_from_save ! 3436: ; ! 3437: ; The given area of the save buffer is ANDed into the work buffer ! 3438: ; ! 3439: ; Entry: ! 3440: ; ESI --> RECT_DATA structure to use ! 3441: ; EGA programmed for AND mode ! 3442: ; Returns: ! 3443: ; None ! 3444: ; Error Returns: ! 3445: ; No error return. ! 3446: ; Registers Preserved: ! 3447: ; EBP ! 3448: ; Registers Destroyed: ! 3449: ; EAX,EBX,ECX,EDX,ESI,EDI,EFLAGS ! 3450: ; Calls: ! 3451: ; None ! 3452: ; ! 3453: ;-----------------------------------------------------------------------; ! 3454: ! 3455: ;-----------------------------------------------------------------------; ! 3456: ; This is the key to wrapping in the buffer. It is a power of two, and ! 3457: ; in this case the entire size is 256 bytes. If it wasn't 256 bytes, an ! 3458: ; and mask could be used for wrapping. ! 3459: ;-----------------------------------------------------------------------; ! 3460: ! 3461: .ERRNZ SAVE_BUFFER_WIDTH-8 ! 3462: .ERRNZ SAVE_BUFFER_HEIGHT-32 ! 3463: .ERRNZ SAVE_BUFFER_WIDTH*SAVE_BUFFER_HEIGHT-256 ! 3464: ! 3465: align 4 ! 3466: and_from_save: ! 3467: ! 3468: .ERRNZ pd_rd ! 3469: ! 3470: ; See if we'll wrap in X. If so, split the operation into two parts ! 3471: ! 3472: movzx eax, WORD PTR [esi].rd_ptbWork ! 3473: movzx ecx, WORD PTR [esi].rd_ptbSave ! 3474: ! 3475: .ERRNZ ptb_y-ptb_x-1 ! 3476: ! 3477: movzx edx, WORD PTR [esi].rd_sizb ! 3478: ! 3479: .ERRNZ sizb_cy-sizb_cx-1 ! 3480: ! 3481: mov bl, cl ! 3482: add bl, dl ! 3483: sub bl, SAVE_BUFFER_WIDTH ;BL = is overhang ! 3484: jle and_from_save_do_last_pass ;No overhang ! 3485: ! 3486: sub dl, bl ;Set X extent for pass 1 ! 3487: mov bh, dl ;Need it for pass 2 ! 3488: push esi ;Must keep rectangle pointer around ! 3489: push ebx ! 3490: call and_from_save_do_a_pass ;Process first half ! 3491: pop ebx ! 3492: pop esi ! 3493: movzx eax, WORD PTR [esi].rd_ptbWork ! 3494: movzx ecx, WORD PTR [esi].rd_ptbSave ! 3495: ! 3496: .ERRNZ ptb_y-ptb_x-1 ! 3497: ! 3498: movzx edx, WORD PTR [esi].rd_sizb ! 3499: ! 3500: .ERRNZ sizb_cy-sizb_cx-1 ! 3501: ! 3502: add al, bh ;Move right in work area ! 3503: mov dl, bl ;Set new extent ! 3504: xor cl, cl ;X origin in save area is 0 ! 3505: ! 3506: and_from_save_do_last_pass: ! 3507: ! 3508: call and_from_save_do_a_pass ! 3509: ! 3510: PLAIN_RET ! 3511: ! 3512: ! 3513: ;--------------------------Private-Routine------------------------------; ! 3514: ; and_from_save ! 3515: ; ! 3516: ; Inner loop subroutine for and_from_save. ! 3517: ; ! 3518: ; Entry: ! 3519: ; AL = X dest start offset in work area (in bytes) ! 3520: ; AH = Y dest start offset in work area (in scans) ! 3521: ; CL = X source start offset in save area (in bytes) ! 3522: ; CH = Y source start offset in save area (in scans) ! 3523: ; Upper word of ECX *must* be 0! ! 3524: ; DL = width to AND (in bytes) ! 3525: ; DH = height to AND (in scans) ! 3526: ; EGA programmed for AND mode ! 3527: ; Returns: ! 3528: ; None ! 3529: ; Error Returns: ! 3530: ; No error return. ! 3531: ; Registers Preserved: ! 3532: ; EBP ! 3533: ; Registers Destroyed: ! 3534: ; EAX,EBX,ECX,EDX,ESI,EDI,EFLAGS ! 3535: ; Calls: ! 3536: ; None ! 3537: ; ! 3538: ;------------------------------------------------------------------------; ! 3539: ! 3540: align 4 ! 3541: and_from_save_do_a_pass: ! 3542: ! 3543: push ebp ;save stack frame pointer ! 3544: ! 3545: push eax ! 3546: push ecx ! 3547: push edx ! 3548: ! 3549: ; Map the cursor bank in as both the read window and the write window, because ! 3550: ; both the save and work areas are in the cursor bank. Note that we always know ! 3551: ; that the operation fits in a single bank, which simplifies things ! 3552: ; considerably. ! 3553: ! 3554: mov esi,pdsurf ! 3555: mov edx,ulPtrBankScan ;scan line at end of cursor work bank ! 3556: cmp edx,[esi].dsurf_rcl1WindowClip.yTop ;is cursor scan less than ! 3557: ; current bank? ! 3558: jl short afsav_map_ptr_bank ;yes, map in proper bank ! 3559: cmp edx,[esi].dsurf_rcl1WindowClip.yBottom ;cursor scan greater ! 3560: ; than current bank? ! 3561: jl short afsav_ptr_bank_mapped ;no, proper bank already mapped ! 3562: afsav_map_ptr_bank: ! 3563: ! 3564: ; Map cursor work bank into source window. ! 3565: ; Note: EBX, ESI, and EDI preserved, according to C calling conventions. ! 3566: ! 3567: ptrCall <dword ptr [esi].dsurf_pfnBankControl>,<esi,edx,JustifyBottom> ! 3568: ! 3569: afsav_ptr_bank_mapped: ! 3570: ! 3571: pop edx ! 3572: pop ecx ! 3573: pop eax ! 3574: ! 3575: ; Compute the offset within the work area, which is also the offset from ! 3576: ; the start of the AND mask. ! 3577: ! 3578: xor ebx,ebx ! 3579: xchg bl,ah ! 3580: add eax,ebx ;*1 + X ! 3581: add ebx,ebx ;*2 ! 3582: add ebx,ebx ;*4 ! 3583: add ebx,eax ;*5 + X ! 3584: mov edi,pPtrWork ! 3585: add edi,ebx ;--> destination in work area relative ! 3586: ; to start of bitmap ! 3587: mov esi,[esi].dsurf_pvBitmapStart ;bitmap start virtual address ! 3588: push esi ;remember bitmap start for calculating ! 3589: ; save area pointer ! 3590: add edi,esi ;virtual addresss of work area ! 3591: ; destination start ! 3592: mov esi,pAndXor ! 3593: add esi,ebx ;--> AND mask ! 3594: ; Compute the offset within the save ! 3595: ; area. Note that this is relative to ! 3596: ; screen_buf ! 3597: xor ebx,ebx ! 3598: xchg bl,ch ;EBX = ptbSave.ptb_y, ! 3599: ; ECX = ptbSave.ptb_x ! 3600: lea ebx,[ebx*8+ecx] ;EBX = offset in save area ! 3601: ! 3602: .ERRNZ SAVE_BUFFER_WIDTH-8 ! 3603: ! 3604: ; Compute the adjustment to each scanline. ! 3605: ! 3606: mov cl,dl ;width in bytes to AND ! 3607: mov eax,WORK_WIDTH ! 3608: sub eax,ecx ;width in bytes to skip from end of one ! 3609: ; mask/work buffer scan to start of ! 3610: ; next ! 3611: ! 3612: ; Look up the address at which to enter the AND loop. ! 3613: ! 3614: mov ecx,and_from_save_entry_table[ecx*4] ! 3615: ! 3616: ; Now get things into the correct registers and enter the loop ! 3617: ! 3618: pop ebp ;get back bitmap start virtual address ! 3619: add ebp,pPtrSave ;point to the save area ! 3620: push ebp ;remember save area virtual address ! 3621: add ebp,ebx ;set correct save buffer address ! 3622: sub ebp,esi ;want to use [SI][BP] ! 3623: jmp ecx ;enter following code ! 3624: ! 3625: ;-----------------------------------------------------------------------; ! 3626: ; Register usage for the loop will be: ! 3627: ; ! 3628: ; EAX = delta to next scan of AND mask and work area ! 3629: ; EBX = offset in save area of scan start ! 3630: ; ECX = loop address ! 3631: ; DH = height in scans ! 3632: ; ESI --> AND mask ! 3633: ; EDI --> Destination in work area ! 3634: ; EBP = delta from SI to next byte of save buffer ! 3635: ;-----------------------------------------------------------------------; ! 3636: ! 3637: align 4 ! 3638: and_from_save_width_5: ! 3639: cmp al, [ebp][esi] ;Load latches from screen ! 3640: movsb ;AND to the work area ! 3641: and_from_save_width_4: ! 3642: cmp al, [ebp][esi] ! 3643: movsb ! 3644: and_from_save_width_3: ! 3645: cmp al, [ebp][esi] ! 3646: movsb ! 3647: and_from_save_width_2: ! 3648: cmp al, [ebp][esi] ! 3649: movsb ! 3650: and_from_save_width_1: ! 3651: cmp al, [ebp][esi] ! 3652: movsb ! 3653: and_from_save_width_0: ! 3654: ! 3655: .ERRNZ and_from_save_width_0-and_from_save_width_1-5 ! 3656: .ERRNZ and_from_save_width_1-and_from_save_width_2-5 ! 3657: .ERRNZ and_from_save_width_2-and_from_save_width_3-5 ! 3658: .ERRNZ and_from_save_width_3-and_from_save_width_4-5 ! 3659: .ERRNZ and_from_save_width_4-and_from_save_width_5-5 ! 3660: ! 3661: dec dh ! 3662: jz and_from_save_done ! 3663: add esi,eax ;--> next AND mask ! 3664: add edi,eax ;--> next work buffer scan ! 3665: add bl,SAVE_BUFFER_WIDTH ;--> compute address of next ! 3666: ; scan in the work area ! 3667: pop ebp ;restore save area pointer ! 3668: push ebp ;push it again, for next time ! 3669: add ebp,ebx ! 3670: sub ebp,esi ;Want to use SI for incrementing ! 3671: ! 3672: jmp ecx ! 3673: ! 3674: and_from_save_done: ! 3675: pop ebp ;clear pushed save area pointer ! 3676: ! 3677: pop ebp ;restore stack frame pointer ! 3678: ! 3679: PLAIN_RET ! 3680: ! 3681: page ! 3682: ! 3683: ;--------------------------Private-Routine------------------------------; ! 3684: ; copy_things_around ! 3685: ; ! 3686: ; Rectangles to be copied from the save area to the screen are ! 3687: ; processed, followed by the rectangles to be copied from the ! 3688: ; screen to the save area. ! 3689: ; ! 3690: ; Entry: ! 3691: ; AL = fbFlush ! 3692: ; Returns: ! 3693: ; None ! 3694: ; Error Returns: ! 3695: ; No error return. ! 3696: ; Registers Preserved: ! 3697: ; BP ! 3698: ; Registers Destroyed: ! 3699: ; AX,BX,CX,DX,SI,DI,BP,FLAGS ! 3700: ; Calls: ! 3701: ; copy_save_to_screen ! 3702: ; copy_screen_to_save ! 3703: ; ! 3704: ;-----------------------------------------------------------------------; ! 3705: ! 3706: align 4 ! 3707: copy_things_around: ! 3708: ! 3709: ;-----------------------------------------------------------------------; ! 3710: ; Program the EGA for COPY mode. This will be done using M_PROC_WRITE, ! 3711: ; M_DATA_READ, DR_???, and setting GRAF_BIT_MASK to 00. All but setting ! 3712: ; GRAF_BIT_MASK was done by save_hw_regs. All planes were also enabled ! 3713: ; for writing by save_hw_regs. ! 3714: ;-----------------------------------------------------------------------; ! 3715: ! 3716: mov ecx, eax ! 3717: mov dx, EGA_BASE + GRAF_ADDR ! 3718: mov ax, GRAF_BIT_MASK ! 3719: out dx, ax ;Disable all bits ! 3720: mov eax, ecx ! 3721: ! 3722: ;-----------------------------------------------------------------------; ! 3723: ; Process any copying from the save area to the screen. If FB_OLD_PTR ! 3724: ; is set, then there cannot be a FB_FLUSH_X or FB_FLUSH_Y. ! 3725: ;-----------------------------------------------------------------------; ! 3726: ! 3727: mov esi, ppdOld ! 3728: test al, FB_OLD_PTR ! 3729: jnz cta_copy_from_save ;The old rectangle goes ! 3730: test al, FB_FLUSH_X ! 3731: jz @F ! 3732: mov esi, offset FLAT:rdFlushX ! 3733: call copy_save_to_screen ! 3734: mov al, fbFlush ! 3735: @@: ! 3736: test al, FB_FLUSH_Y ! 3737: jz @F ! 3738: mov esi, offset FLAT:rdFlushY ! 3739: cta_copy_from_save: ! 3740: call copy_save_to_screen ! 3741: @@: ! 3742: ! 3743: ;-----------------------------------------------------------------------; ! 3744: ; Process any copying from the screen to the save area. If FB_NEW_PTR ! 3745: ; or FB_WORK_RECT is set, then there can't be a FB_FLUSH_X or FB_FLUSH_Y ! 3746: ;-----------------------------------------------------------------------; ! 3747: ! 3748: mov al, fbAndRead ! 3749: mov esi, ppdNew ! 3750: test al, FB_NEW_PTR ! 3751: jnz cta_copy_to_save ! 3752: mov esi, offset FLAT:rdWork ! 3753: test al, FB_WORK_RECT ! 3754: jnz cta_copy_to_save ! 3755: ! 3756: ; Some combination of FB_READ_X, FB_READ_Y ! 3757: ! 3758: test al, FB_READ_X ! 3759: jz @F ! 3760: mov esi, offset FLAT:rdReadX ! 3761: call copy_screen_to_save ! 3762: mov al, fbAndRead ! 3763: @@: ! 3764: test al, FB_READ_Y ! 3765: jz @F ! 3766: mov esi, offset FLAT:rdReadY ! 3767: cta_copy_to_save: ! 3768: call copy_screen_to_save ! 3769: @@: ! 3770: PLAIN_RET ! 3771: ! 3772: page ! 3773: ! 3774: ;--------------------------Private-Routine------------------------------; ! 3775: ; copy_save_to_screen ! 3776: ; ! 3777: ; The given rectangle is copied from the save area to the screen ! 3778: ; ! 3779: ; Entry: ! 3780: ; ESI --> RECT_DATA structure to use ! 3781: ; EGA programmed for COPY mode ! 3782: ; Returns: ! 3783: ; None ! 3784: ; Error Returns: ! 3785: ; No error return. ! 3786: ; Registers Preserved: ! 3787: ; EBP ! 3788: ; Registers Destroyed: ! 3789: ; EAX,EBX,ECX,EDX,ESI,EDI,EFLAGS ! 3790: ; Calls: ! 3791: ; None ! 3792: ; ! 3793: ;-----------------------------------------------------------------------; ! 3794: ! 3795: ;-----------------------------------------------------------------------; ! 3796: ; This is the key to wrapping in the buffer. It is a power of two, and ! 3797: ; in this case the entire size is 256 bytes. If it wasn't 256 bytes, an ! 3798: ; and mask could be used for wrapping. ! 3799: ;-----------------------------------------------------------------------; ! 3800: ! 3801: .ERRNZ SAVE_BUFFER_WIDTH-8 ! 3802: .ERRNZ SAVE_BUFFER_HEIGHT-32 ! 3803: .ERRNZ SAVE_BUFFER_WIDTH*SAVE_BUFFER_HEIGHT-256 ! 3804: ! 3805: align 4 ! 3806: copy_save_to_screen: ! 3807: ! 3808: .ERRNZ pd_rd ! 3809: ! 3810: ; Map the proper bank into the destination window for the top destination ! 3811: ; scan line. ! 3812: ! 3813: mov ebx,pdsurf ! 3814: mov edx,[esi].rd_ptlScreen.ptl_y ! 3815: mov ulCurrentTopScan,edx ;remember where the top dest scan is ! 3816: cmp edx,[ebx].dsurf_rcl2WindowClipD.yTop ;is copy top less than ! 3817: ; current dest bank? ! 3818: jl short sts_map_init_bank ;yes, map in proper bank ! 3819: cmp edx,[ebx].dsurf_rcl2WindowClipD.yBottom ;copy top greater than ! 3820: ; current dest bank? ! 3821: jl short sts_init_bank_mapped ;no, proper bank already mapped ! 3822: sts_map_init_bank: ! 3823: ! 3824: ; Map bank containing the top destination (screen) scan line into dest window. ! 3825: ; Note: EBX, ESI, and EDI preserved, according to C calling conventions. ! 3826: ! 3827: ptrCall <dword ptr [ebx].dsurf_pfnBankControl2Window>, \ ! 3828: <ebx,edx,JustifyTop,MapDestBank> ! 3829: ! 3830: sts_init_bank_mapped: ! 3831: ! 3832: ! 3833: ; Map the cursor bank into the source window. ! 3834: ! 3835: mov edx,ulPtrBankScan ;scan line at end of cursor work bank ! 3836: cmp edx,[ebx].dsurf_rcl2WindowClipS.yTop ;is cursor scan less than ! 3837: ; current source bank? ! 3838: jl short sts_map_ptr_bank ;yes, map in proper bank ! 3839: cmp edx,[ebx].dsurf_rcl2WindowClipS.yBottom ;cursor scan greater ! 3840: ; than current source ! 3841: ; bank? ! 3842: jl short sts_ptr_bank_mapped ;no, proper bank already mapped ! 3843: sts_map_ptr_bank: ! 3844: ! 3845: ; Map cursor work bank into source window. ! 3846: ; Note: EBX, ESI, and EDI preserved, according to C calling conventions. ! 3847: ! 3848: ptrCall <dword ptr [ebx].dsurf_pfnBankControl2Window>, \ ! 3849: <ebx,edx,JustifyBottom,MapSourceBank> ! 3850: ! 3851: sts_ptr_bank_mapped: ! 3852: ! 3853: ! 3854: ; Compute the virtual address of the save area. ! 3855: ! 3856: mov eax,pPtrSave ! 3857: add eax,[ebx].dsurf_pvBitmapStart2WindowS ;save area virtual addr ! 3858: mov pSaveAddr,eax ! 3859: ! 3860: ; Compute the screen address and delta to next scan of the screen. ! 3861: ! 3862: mov edi,lNextScan ! 3863: imul edi,[esi].rd_ptlScreen.ptl_y ! 3864: add edi,[esi].rd_ptlScreen.ptl_x ;start dest offset in bitmap ! 3865: add edi,[ebx].dsurf_pvBitmapStart2WindowD ;start dest virtual addr ! 3866: movzx edx,WORD PTR [esi].rd_sizb ! 3867: ! 3868: .ERRNZ sizb_cy-sizb_cx-1 ! 3869: ! 3870: ; Calculate the number of scans we'll do in this bank. ! 3871: ! 3872: mov ecx,[ebx].dsurf_rcl2WindowClipD.yBottom ! 3873: sub ecx,ulCurrentTopScan ;max # of scans that can be handled in ! 3874: ; the initial bank ! 3875: sub eax,eax ! 3876: mov al,dh ;total # of scans to copy ! 3877: cmp eax,ecx ;can we handle all remaining scans in ! 3878: ; this bank? ! 3879: jb short @F ;yes ! 3880: mov eax,ecx ;no, so we'll do the whole bank's worth ! 3881: @@: ! 3882: add ulCurrentTopScan,eax ;set top scan for next bank ! 3883: sub dh,al ;count this bank's scans off total ! 3884: mov byte ptr cjTotalScans,dh ;remember # of scans after this bank ! 3885: mov dh,al ;# of scans to do in this bank ! 3886: ! 3887: ; Calculate the offset from the end of one dest scan line to the next. ! 3888: ! 3889: mov al,dl ;width to copy in bytes ! 3890: neg eax ! 3891: add eax,lNextScan ;offset from end of one dest scan to start of ! 3892: ; next ! 3893: ! 3894: ; Compute the save area offset. ! 3895: ! 3896: movzx ecx,WORD PTR [esi].rd_ptbSave ! 3897: ! 3898: .ERRNZ ptb_y-ptb_x-1 ! 3899: ! 3900: xor ebx,ebx ! 3901: xchg bl,ch ! 3902: lea ebx,[ebx*8+ecx] ! 3903: ! 3904: .ERRNZ SAVE_BUFFER_WIDTH-8 ! 3905: ! 3906: ; Determine if any wrap will occur, and handle it if so. ! 3907: ! 3908: add cl,dl ;add extent (DL) to start X (CL) ! 3909: sub cl,SAVE_BUFFER_WIDTH ! 3910: jg short save_to_screen_wraps ;CL = amount of wrap ! 3911: ! 3912: ;-----------------------------------------------------------------------; ! 3913: ; The copy will not wrap, so we can get into some tighter code for it. ! 3914: ; ! 3915: ; Currently: ! 3916: ; EAX = delta to next destination scan ! 3917: ; EBX = offset into the save buffer ! 3918: ; DL = width of copy ! 3919: ; DH = height of copy ! 3920: ; EDI --> destination ! 3921: ;-----------------------------------------------------------------------; ! 3922: ! 3923: copy_save_next_scan: ! 3924: sub ecx,ecx ;prepare for loading CL in loop ! 3925: push ebp ;preserve stack frame pointer ! 3926: mov ebp,pSaveAddr ! 3927: copy_save_next_scan_loop: ! 3928: lea esi,[ebp+ebx] ! 3929: mov cl,dl ! 3930: rep movsb ! 3931: add bl,SAVE_BUFFER_WIDTH ! 3932: add edi,eax ! 3933: dec dh ! 3934: jnz copy_save_next_scan_loop ! 3935: ! 3936: pop ebp ;restore stack frame pointer ! 3937: cmp byte ptr cjTotalScans,0 ;more lines (in next dest bank)? ! 3938: jz short sts_done ;no, we're done ! 3939: ;advance to next dest bank and continue ! 3940: ; copying ! 3941: push eax ;preserve dest next scan ! 3942: push edx ;preserve width of copy ! 3943: mov esi,pdsurf ! 3944: sub edi,[esi].dsurf_pvBitmapStart2WindowD ! 3945: ;calculate the destination offset ! 3946: ; within the bitmap, because the start ! 3947: ; address is about to move ! 3948: mov edx,ulCurrentTopScan ! 3949: ! 3950: ; Note: EBX, ESI, and EDI preserved, according to C calling conventions. ! 3951: ! 3952: ptrCall <dword ptr [esi].dsurf_pfnBankControl2Window>, \ ! 3953: <esi,edx,JustifyTop,MapDestBank> ;map in the next dest bank ! 3954: ! 3955: add edi,[esi].dsurf_pvBitmapStart2WindowD ! 3956: ;add back in the bitmap start address ! 3957: ; to yield the virtual dest address ! 3958: mov edx,[esi].dsurf_rcl2WindowClipD.yBottom ! 3959: sub edx,ulCurrentTopScan ;max # of scans that can be handled in ! 3960: ; the new bank ! 3961: sub eax,eax ! 3962: mov al,byte ptr cjTotalScans ;remaining scan count ! 3963: cmp eax,edx ;can we handle all remaining scans in ! 3964: ; this bank? ! 3965: jb short @F ;yes ! 3966: mov eax,edx ;no, so we'll do the whole bank's worth ! 3967: @@: ! 3968: add ulCurrentTopScan,eax ;set top scan for next bank ! 3969: sub byte ptr cjTotalScans,al ;count this bank's scans off total ! 3970: pop edx ;restore copy width in DL ! 3971: mov dh,al ;# of scans to do in this bank ! 3972: pop eax ;restore dest next scan ! 3973: jmp copy_save_next_scan ;do the next block of scans ! 3974: ! 3975: sts_done: ! 3976: PLAIN_RET ! 3977: ! 3978: ;-----------------------------------------------------------------------; ! 3979: ; The copy will wrap, so we have to handle it as two copies ! 3980: ; ! 3981: ; Currently: ! 3982: ; EDI --> destination ! 3983: ; EAX = delta to next destination scan ! 3984: ; DL = width of copy ! 3985: ; DH = height of copy ! 3986: ; EBX = offset into the save buffer ! 3987: ; CL = amount of overflow ! 3988: ;-----------------------------------------------------------------------; ! 3989: ! 3990: align 4 ! 3991: save_to_screen_wraps: ! 3992: sub dl,cl ;set extent of first copy ! 3993: mov byte ptr jPostWrapWidth,cl ;set extent of second copy ! 3994: sub ecx,ecx ;prepare for loading CL in loop ! 3995: ! 3996: copy_save_next_scan_wrap_loop: ! 3997: mov esi,pSaveAddr ! 3998: add esi,ebx ! 3999: mov cl,dl ! 4000: rep movsb ! 4001: sub esi,SAVE_BUFFER_WIDTH ! 4002: mov cl,byte ptr jPostWrapWidth ! 4003: rep movsb ! 4004: add bl,SAVE_BUFFER_WIDTH ! 4005: add edi,eax ! 4006: dec dh ! 4007: jnz copy_save_next_scan_wrap_loop ! 4008: ! 4009: cmp byte ptr cjTotalScans,0 ;more lines (in next dest bank)? ! 4010: jz short sts_done ;no, we're done ! 4011: ;advance to next dest bank and continue ! 4012: ; copying ! 4013: push eax ;preserve dest next scan ! 4014: push edx ;preserve width of copy ! 4015: mov esi,pdsurf ! 4016: sub edi,[esi].dsurf_pvBitmapStart2WindowD ! 4017: ;calculate the destination offset ! 4018: ; within the bitmap, because the start ! 4019: ; address is about to move ! 4020: mov edx,ulCurrentTopScan ! 4021: ! 4022: ; Note: EBX, ESI, and EDI preserved, according to C calling conventions. ! 4023: ! 4024: ptrCall <dword ptr [esi].dsurf_pfnBankControl2Window>, \ ! 4025: <esi,edx,JustifyTop,MapDestBank> ;map in the next dest bank ! 4026: ! 4027: add edi,[esi].dsurf_pvBitmapStart2WindowD ! 4028: ;add back in the bitmap start address ! 4029: ; to yield the virtual dest address ! 4030: mov edx,[esi].dsurf_rcl2WindowClipD.yBottom ! 4031: sub edx,ulCurrentTopScan ;max # of scans that can be handled in ! 4032: ; the new bank ! 4033: sub eax,eax ! 4034: mov al,byte ptr cjTotalScans ;remaining scan count ! 4035: cmp eax,edx ;can we handle all remaining scans in ! 4036: ; this bank? ! 4037: jb short @F ;yes ! 4038: mov eax,edx ;no, so we'll do the whole bank's worth ! 4039: @@: ! 4040: add ulCurrentTopScan,eax ;set top scan for next bank ! 4041: sub byte ptr cjTotalScans,al ;count this bank's scans off total ! 4042: pop edx ;restore copy width in DL ! 4043: mov dh,al ;# of scans to do in this bank ! 4044: pop eax ;restore dest next scan ! 4045: sub ecx,ecx ;prepare for loading CL in loop ! 4046: jmp copy_save_next_scan_wrap_loop ;do the next block of scans ! 4047: ! 4048: page ! 4049: ! 4050: ;--------------------------Private-Routine------------------------------; ! 4051: ; copy_screen_to_save ! 4052: ; ! 4053: ; The given rectangle is copied from the screen to the save area ! 4054: ; ! 4055: ; Entry: ! 4056: ; ESI --> RECT_DATA structure to use ! 4057: ; EGA programmed for COPY mode ! 4058: ; Returns: ! 4059: ; None ! 4060: ; Error Returns: ! 4061: ; No error return. ! 4062: ; Registers Preserved: ! 4063: ; EBP ! 4064: ; Registers Destroyed: ! 4065: ; EAX,EBX,ECX,EDX,ESI,EDI,EFLAGS ! 4066: ; Calls: ! 4067: ; None ! 4068: ; ! 4069: ;-----------------------------------------------------------------------; ! 4070: ! 4071: ! 4072: ;-----------------------------------------------------------------------; ! 4073: ; This is the key to wrapping in the buffer. It is a power of two, and ! 4074: ; in this case the entire size is 256 bytes. If it wasn't 256 bytes, an ! 4075: ; and mask could be used for wrapping. ! 4076: ;-----------------------------------------------------------------------; ! 4077: ! 4078: .ERRNZ SAVE_BUFFER_WIDTH-8 ! 4079: .ERRNZ SAVE_BUFFER_HEIGHT-32 ! 4080: .ERRNZ SAVE_BUFFER_WIDTH*SAVE_BUFFER_HEIGHT-256 ! 4081: ! 4082: align 4 ! 4083: copy_screen_to_save: ! 4084: ! 4085: .ERRNZ pd_rd ! 4086: ! 4087: ; Map the proper bank into the source window for the top source scan line. ! 4088: ! 4089: mov ebx,pdsurf ! 4090: mov edx,[esi].rd_ptlScreen.ptl_y ! 4091: mov ulCurrentTopScan,edx ;remember where the top source scan is ! 4092: cmp edx,[ebx].dsurf_rcl2WindowClipS.yTop ;is copy top less than ! 4093: ; current source bank? ! 4094: jl short scrts_map_init_bank ;yes, map in proper bank ! 4095: cmp edx,[ebx].dsurf_rcl2WindowClipS.yBottom ;copy top greater than ! 4096: ; current source bank? ! 4097: jl short scrts_init_bank_mapped ;no, proper bank already mapped ! 4098: scrts_map_init_bank: ! 4099: ! 4100: ; Map bank containing the top source (screen) scan line into source window. ! 4101: ; Note: EBX, ESI, and EDI preserved, according to C calling conventions. ! 4102: ! 4103: ptrCall <dword ptr [ebx].dsurf_pfnBankControl2Window>, \ ! 4104: <ebx,edx,JustifyTop,MapSourceBank> ! 4105: ! 4106: scrts_init_bank_mapped: ! 4107: ! 4108: ! 4109: ; Map the cursor bank into the dest window. ! 4110: ! 4111: mov edx,ulPtrBankScan ;scan line at end of cursor work bank ! 4112: cmp edx,[ebx].dsurf_rcl2WindowClipD.yTop ;is cursor scan less than ! 4113: ; current dest bank? ! 4114: jl short scrts_map_ptr_bank ;yes, map in proper bank ! 4115: cmp edx,[ebx].dsurf_rcl2WindowClipD.yBottom ;cursor scan greater ! 4116: ; than current dest ! 4117: ; bank? ! 4118: jl short scrts_ptr_bank_mapped ;no, proper bank already mapped ! 4119: scrts_map_ptr_bank: ! 4120: ! 4121: ; Map cursor work bank into dest window. ! 4122: ; Note: EBX, ESI, and EDI preserved, according to C calling conventions. ! 4123: ! 4124: ptrCall <dword ptr [ebx].dsurf_pfnBankControl2Window>, \ ! 4125: <ebx,edx,JustifyBottom,MapDestBank> ! 4126: ! 4127: scrts_ptr_bank_mapped: ! 4128: ! 4129: ! 4130: ; Compute the virtual address of the save area. ! 4131: ! 4132: mov eax,pPtrSave ! 4133: add eax,[ebx].dsurf_pvBitmapStart2WindowD ;save area virtual addr ! 4134: mov pSaveAddr,eax ! 4135: ! 4136: ; Compute the source screen address and delta to next scan of the screen. ! 4137: ! 4138: mov edi,lNextScan ! 4139: imul edi,[esi].rd_ptlScreen.ptl_y ! 4140: add edi,[esi].rd_ptlScreen.ptl_x ;start source offset in bitmap ! 4141: add edi,[ebx].dsurf_pvBitmapStart2WindowS ;start source virtual ! 4142: ; address ! 4143: movzx edx,WORD PTR [esi].rd_sizb ! 4144: ! 4145: .ERRNZ sizb_cy-sizb_cx-1 ! 4146: ! 4147: ; Calculate the number of scans we'll do in this bank. ! 4148: ! 4149: mov ecx,[ebx].dsurf_rcl2WindowClipS.yBottom ! 4150: sub ecx,ulCurrentTopScan ;max # of scans that can be handled in ! 4151: ; the initial bank ! 4152: sub eax,eax ! 4153: mov al,dh ;total # of scans to copy ! 4154: cmp eax,ecx ;can we handle all remaining scans in ! 4155: ; this bank? ! 4156: jb short @F ;yes ! 4157: mov eax,ecx ;no, so we'll do the whole bank's worth ! 4158: @@: ! 4159: add ulCurrentTopScan,eax ;set top scan for next bank ! 4160: sub dh,al ;count this bank's scans off total ! 4161: mov byte ptr cjTotalScans,dh ;remember # of scans after this bank ! 4162: mov dh,al ;# of scans to do in this bank ! 4163: ! 4164: ; Calculate the offset from the end of one source scan line to the next. ! 4165: ! 4166: mov al,dl ;width to copy in bytes ! 4167: neg eax ! 4168: add eax,lNextScan ;offset from end of one source scan to start of ! 4169: ; next ! 4170: ! 4171: ; Compute the save area offset. ! 4172: ! 4173: movzx ecx,WORD PTR [esi].rd_ptbSave ! 4174: ! 4175: .ERRNZ ptb_y-ptb_x-1 ! 4176: ! 4177: xor ebx,ebx ! 4178: xchg bl,ch ! 4179: lea ebx,[ebx*8+ecx] ! 4180: ! 4181: .ERRNZ SAVE_BUFFER_WIDTH-8 ! 4182: ! 4183: mov esi,edi ;ESI -> initial source byte ! 4184: ! 4185: ; Determine if any wrap will occur, and handle it if so. ! 4186: ! 4187: add cl,dl ;add extent (DL) to start X (CL) ! 4188: sub cl,SAVE_BUFFER_WIDTH ! 4189: jg short screen_to_save_wraps ;CL = amount of wrap ! 4190: ! 4191: ;-----------------------------------------------------------------------; ! 4192: ; The copy will not wrap, so we can get into some tighter code for it. ! 4193: ; ! 4194: ; Currently: ! 4195: ; EAX = delta to next source scan ! 4196: ; EBX = offset into the save buffer ! 4197: ; DL = width of copy ! 4198: ; DH = height of copy ! 4199: ; ESI --> source ! 4200: ;-----------------------------------------------------------------------; ! 4201: ! 4202: copy_screen_next_scan: ! 4203: sub ecx,ecx ;prepare for loading CL in loop ! 4204: push ebp ;preserve stack frame pointer ! 4205: mov ebp,pSaveAddr ! 4206: copy_screen_next_scan_loop: ! 4207: lea edi,[ebp+ebx] ! 4208: mov cl,dl ! 4209: rep movsb ! 4210: add bl,SAVE_BUFFER_WIDTH ! 4211: add esi,eax ! 4212: dec dh ! 4213: jnz copy_screen_next_scan_loop ! 4214: ! 4215: pop ebp ;restore stack frame pointer ! 4216: cmp byte ptr cjTotalScans,0 ;more lines (in next source bank)? ! 4217: jz short scrts_done ;no, we're done ! 4218: ;advance to next source bank and ! 4219: ; continue copying ! 4220: push eax ;preserve source next scan ! 4221: push edx ;preserve width of copy ! 4222: mov edi,pdsurf ! 4223: sub esi,[edi].dsurf_pvBitmapStart2WindowS ! 4224: ;calculate the source offset ! 4225: ; within the bitmap, because the start ! 4226: ; address is about to move ! 4227: mov edx,ulCurrentTopScan ! 4228: ! 4229: ; Note: EBX, ESI, and EDI preserved, according to C calling conventions. ! 4230: ! 4231: ptrCall <dword ptr [edi].dsurf_pfnBankControl2Window>, \ ! 4232: <edi,edx,JustifyTop,MapSourceBank> ;map in the next source bank ! 4233: ! 4234: add esi,[edi].dsurf_pvBitmapStart2WindowS ! 4235: ;add back in the bitmap start address ! 4236: ; to yield the virtual source address ! 4237: mov edx,[edi].dsurf_rcl2WindowClipS.yBottom ! 4238: sub edx,ulCurrentTopScan ;max # of scans that can be handled in ! 4239: ; the new bank ! 4240: sub eax,eax ! 4241: mov al,byte ptr cjTotalScans ;remaining scan count ! 4242: cmp eax,edx ;can we handle all remaining scans in ! 4243: ; this bank? ! 4244: jb short @F ;yes ! 4245: mov eax,edx ;no, so we'll do the whole bank's worth ! 4246: @@: ! 4247: add ulCurrentTopScan,eax ;set top scan for next bank ! 4248: sub byte ptr cjTotalScans,al ;count this bank's scans off total ! 4249: pop edx ;restore copy width in DL ! 4250: mov dh,al ;# of scans to do in this bank ! 4251: pop eax ;restore source next scan ! 4252: jmp copy_screen_next_scan ;do the next block of scans ! 4253: ! 4254: scrts_done: ! 4255: PLAIN_RET ! 4256: ! 4257: ;-----------------------------------------------------------------------; ! 4258: ; The copy will wrap, so we have to handle it as two copies ! 4259: ; ! 4260: ; Currently: ! 4261: ; EAX = delta to next source scan ! 4262: ; EBX = offset into the save buffer ! 4263: ; CL = amount of overflow ! 4264: ; DL = width of copy ! 4265: ; DH = height of copy ! 4266: ; ESI --> source ! 4267: ;-----------------------------------------------------------------------; ! 4268: ! 4269: align 4 ! 4270: screen_to_save_wraps: ! 4271: sub dl,cl ;set extent of first copy ! 4272: mov byte ptr jPostWrapWidth,cl ;set extent of second copy ! 4273: sub ecx,ecx ;prepare for loading CL in loop ! 4274: ! 4275: copy_screen_next_scan_wrap_loop: ! 4276: mov edi,pSaveAddr ! 4277: add edi,ebx ! 4278: mov cl,dl ! 4279: rep movsb ! 4280: sub edi,SAVE_BUFFER_WIDTH ! 4281: mov cl,byte ptr jPostWrapWidth ! 4282: rep movsb ! 4283: add bl,SAVE_BUFFER_WIDTH ! 4284: add esi,eax ! 4285: dec dh ! 4286: jnz copy_screen_next_scan_wrap_loop ! 4287: ! 4288: cmp byte ptr cjTotalScans,0 ;more lines (in next source bank)? ! 4289: jz short scrts_done ;no, we're done ! 4290: ;advance to next source bank and ! 4291: ; continue copying ! 4292: push eax ;preserve source next scan ! 4293: push edx ;preserve width of copy ! 4294: mov edi,pdsurf ! 4295: sub esi,[edi].dsurf_pvBitmapStart2WindowS ! 4296: ;calculate the source offset ! 4297: ; within the bitmap, because the start ! 4298: ; address is about to move ! 4299: mov edx,ulCurrentTopScan ! 4300: ! 4301: ; Note: EBX, ESI, and EDI preserved, according to C calling conventions. ! 4302: ! 4303: ptrCall <dword ptr [edi].dsurf_pfnBankControl2Window>, \ ! 4304: <edi,edx,JustifyTop,MapSourceBank> ;map in the next source bank ! 4305: ! 4306: add esi,[edi].dsurf_pvBitmapStart2WindowS ! 4307: ;add back in the bitmap start address ! 4308: ; to yield the virtual source address ! 4309: mov edx,[edi].dsurf_rcl2WindowClipS.yBottom ! 4310: sub edx,ulCurrentTopScan ;max # of scans that can be handled in ! 4311: ; the new bank ! 4312: sub eax,eax ! 4313: mov al,byte ptr cjTotalScans ;remaining scan count ! 4314: cmp eax,edx ;can we handle all remaining scans in ! 4315: ; this bank? ! 4316: jb short @F ;yes ! 4317: mov eax,edx ;no, so we'll do the whole bank's worth ! 4318: @@: ! 4319: add ulCurrentTopScan,eax ;set top scan for next bank ! 4320: sub byte ptr cjTotalScans,al ;count this bank's scans off total ! 4321: pop edx ;restore copy width in DL ! 4322: mov dh,al ;# of scans to do in this bank ! 4323: pop eax ;restore source next scan ! 4324: sub ecx,ecx ;prepare for loading CL in loop ! 4325: jmp copy_screen_next_scan_wrap_loop ;do the next block of scans ! 4326: ! 4327: endProc vDrawPointer ! 4328: ! 4329: ;-----------------------------------------------------------------------; ! 4330: ; vDIB4Convert* ! 4331: ; ! 4332: ; Converts the specified number of source 4 bpp bits into the ! 4333: ; buffer. These are support routines for vDIB4Planer, where a ! 4334: ; source byte converts into two aligned bits ! 4335: ; ! 4336: ; Entry: ! 4337: ; EAX 31:8 = 0 ! 4338: ; EBP --> Bit conversion table ! 4339: ; ESI --> Source bitmap ! 4340: ; EDI --> Planer destination ! 4341: ; ECX = Loop count ! 4342: ; Exit: ! 4343: ; EBP --> Bit conversion table ! 4344: ; ESI --> Next source byte ! 4345: ; EDI --> Next planer destination ! 4346: ; EDX = Last planer byte accumulated ! 4347: ; Registers Destroyed: ! 4348: ; EAX,ECX,EDX ! 4349: ; Registers Preserved: ! 4350: ;-----------------------------------------------------------------------; ! 4351: extrn aulDefBitMapping:dword ! 4352: ! 4353: align 4 ! 4354: vDIB4Convert8 proc ! 4355: lodsb ! 4356: mov ebx,eax ! 4357: shr eax,4 ! 4358: and ebx,00001111b ! 4359: mov edx,[ebp][eax*4] ! 4360: shl edx,1 ! 4361: or edx,[ebp][ebx*4] ! 4362: vDIB4Convert6: ! 4363: lodsb ! 4364: shl edx,1 ! 4365: mov ebx,eax ! 4366: shr eax,4 ! 4367: and ebx,00001111b ! 4368: or edx,[ebp][eax*4] ! 4369: shl edx,1 ! 4370: or edx,[ebp][ebx*4] ! 4371: vDIB4Convert4: ! 4372: lodsb ! 4373: shl edx,1 ! 4374: mov ebx,eax ! 4375: shr eax,4 ! 4376: and ebx,00001111b ! 4377: or edx,[ebp][eax*4] ! 4378: shl edx,1 ! 4379: or edx,[ebp][ebx*4] ! 4380: vDIB4Convert2: ! 4381: lodsb ! 4382: shl edx,1 ! 4383: mov ebx,eax ! 4384: shr eax,4 ! 4385: and ebx,00001111b ! 4386: or edx,[ebp][eax*4] ! 4387: shl edx,1 ! 4388: or edx,[ebp][ebx*4] ! 4389: mov [edi][4*0],dl ! 4390: mov [edi][4*1],dh ! 4391: ror edx,16 ! 4392: mov [edi][4*2],dl ! 4393: mov [edi][4*3],dh ! 4394: inc edi ! 4395: dec ecx ! 4396: jnz vDIB4Convert8 ! 4397: ret ! 4398: ! 4399: vDIB4Convert8 endp ! 4400: ! 4401: page ! 4402: ;-----------------------------------------------------------------------; ! 4403: ; vConvertDIBPointer ! 4404: ; ! 4405: ; Converts the passed DIB into a planer format, then synthesizes the ! 4406: ; XOR mask. ! 4407: ; ! 4408: ; Entry: ! 4409: ; ESI --> Color Bits, 4bpp format ! 4410: ; EDI --> Planer destination ! 4411: ; ECX = Bitmap height ! 4412: ; EBP = pulXlate for color mapping ! 4413: ; DX = wFlags ! 4414: ; Exit: ! 4415: ; None ! 4416: ; Registers Destroyed: ! 4417: ; EAX,EBX,ECX,EDX,ESI,EDI,Flags ! 4418: ; Registers Preserved: ! 4419: ;-----------------------------------------------------------------------; ! 4420: ! 4421: align 4 ! 4422: vConvertDIBPointer proc ! 4423: ! 4424: ; Convert the scans as necessary into planer format. We'll assume a fixed ! 4425: ; size of 32 bits wide ! 4426: ! 4427: push edx ;Save ! 4428: push edi ! 4429: @@: ! 4430: push ecx ;Save loop count ! 4431: push edi ;Save destination pointer ! 4432: push esi ;Save source pointer ! 4433: mov ecx,PTR_WIDTH ! 4434: xor eax,eax ;Needs to be zero initialized ! 4435: call vDIB4Convert8 ;Convert one scan ! 4436: pop esi ! 4437: pop edi ! 4438: pop ecx ! 4439: add edi,16 ;--> next destination scan ! 4440: add esi,16 ;--> next source scan ! 4441: dec ecx ! 4442: jnz @B ! 4443: ! 4444: ; The bitmap has been converted into planer format. If it needs flipping, ! 4445: ; then flip it ! 4446: ! 4447: pop esi ;Start of plane 0 ! 4448: pop edx ! 4449: or dl,dl ! 4450: js skipping_first_invert ;Color bitmap is TOPDOWN ! 4451: mov ecx,PTR_HEIGHT / 2 ;* scans to flip ! 4452: lea edi,[esi][PTR_HEIGHT*4*4] ;--> last scan ! 4453: ! 4454: flip_next_scan: ! 4455: sub edi,16 ;decrement target pointer ! 4456: ! 4457: mov eax,[esi][00h] ;Load ! 4458: xchg [edi][00h],eax ;Swap ! 4459: mov [esi][00h],eax ;Save ! 4460: ! 4461: mov eax,[esi][04h] ;Load ! 4462: xchg [edi][04h],eax ;Swap ! 4463: mov [esi][04h],eax ;Save ! 4464: ! 4465: mov eax,[esi][08h] ;Load ! 4466: xchg [edi][08h],eax ;Swap ! 4467: mov [esi][08h],eax ;Save ! 4468: ! 4469: mov eax,[esi][0Ch] ;Load ! 4470: xchg [edi][0Ch],eax ;Swap ! 4471: mov [esi][0Ch],eax ;Save ! 4472: ! 4473: add esi,16 ;increment source pointer ! 4474: loop flip_next_scan ! 4475: ! 4476: skipping_first_invert: ! 4477: ret ! 4478: ! 4479: vConvertDIBPointer endp ! 4480: ! 4481: _TEXT$01 ends ! 4482: ! 4483: end ! 4484:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.