RedAlert/WIN32LIB/SHAPE/DRAWSHP.ASM

;
;	Command & Conquer Red Alert(tm)
;	Copyright 2025 Electronic Arts Inc.
;
;	This program is free software: you can redistribute it and/or modify
;	it under the terms of the GNU General Public License as published by
;	the Free Software Foundation, either version 3 of the License, or
;	(at your option) any later version.
;
;	This program is distributed in the hope that it will be useful,
;	but WITHOUT ANY WARRANTY; without even the implied warranty of
;	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
;	GNU General Public License for more details.
;
;	You should have received a copy of the GNU General Public License
;	along with this program.  If not, see <http://www.gnu.org/licenses/>.
;

;***************************************************************************
;**   C O N F I D E N T I A L --- W E S T W O O D    S T U D I O S        **
;***************************************************************************
;*                                                                         *
;*                 Project Name : WWLIB32                                  *
;*                                                                         *
;*                    File Name : DRAWSHP.ASM                              *
;*                                                                         *
;*                   Programmer : Phil W. Gorrow                           *
;*                                                                         *
;*                   Start Date : April 13, 1992                           *
;*                                                                         *
;*                  Last Update : September 14, 1994   [IML]               *
;*                                                                         *
;*-------------------------------------------------------------------------*
;* Functions:                                                              *
;*   Draw_Shape -- Draws a shape at given buffer coordinates and clips     *
;*   Not_Supported -- Replacement function for Draw_Shape routines not used*
;* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - *
;********************* Model & Processor Directives ************************
IDEAL
P386
MODEL USE32 FLAT


; this struct is here to remove the hardwire way of programing
; implemented in the funtion Draw_Shape in ian image of 

STRUC	VVPC_IMAGE
   		Off  	dd  ?  
		Width  	dd  ?  
		Height  dd  ?  
  		Page    dd  ?  
ENDS



STRUC GVPC_IMAGE 
		 vvpc		VVPC_IMAGE	<>
		 Xpos		dd	   	?
		 Ypos		dd	   	?
		 GraphicBuff	dd	   	?
ENDS


;******************************** Includes *********************************
INCLUDE "shape.inc"


;****************************** Declarations ********************************
GLOBAL	 Draw_Shape:NEAR
GLOBAL	 LCW_Uncompress:NEAR
GLOBAL	_ShapeBuffer:DWORD
GLOBAL	_ShapeBufferSize:DWORD

GLOBAL	MaskPage	       : dword
GLOBAL	BackGroundPage	       : dword


;********************************* Data ************************************
	DATASEG
;---------------------------------------------------------------------------
; Shape buffer & its size, set by Set_Shape_Buffer()
;---------------------------------------------------------------------------
_ShapeBuffer		DD	0
_ShapeBufferSize	DD	0

;---------------------------------------------------------------------------
; Address of MaskPage & BackGroundPage, set by Init_Priority_System()
;---------------------------------------------------------------------------
MaskPage		DD	0
BackGroundPage		DD	0

;---------------------------------------------------------------------------
; Predator effect variables 
;---------------------------------------------------------------------------
PredCount	DD	0
PredTable	DB	1, 3, 2, 5, 4, 3, 2, 1
PredValue	DD	1
PartialPred	DD	0	; partially faded predator effect value
PartialCount	DD	0

;---------------------------------------------------------------------------
; 32 bit versions of 16 bit stack variables
;---------------------------------------------------------------------------
Flags		DD	?	; globally accessible copy of flags

viewport_ptr	DD	?	; pointer to upper-left corner of viewport 
viewport_width	DD	?	; viewport width
viewport_height DD	?	; viewport height
viewport_yadd	DD	?	; viewport y add
viewport_x	DD	?	; viewport x-coord
viewport_y	DD	?	; viewport y-coord
buff_ptr	DD	?	; pointer to buffer containing viewport

;********************************* Code ************************************
	CODESEG


;***************************************************************************
;* Draw_Shape -- Draws a shape at given buffer coordinates and clips       *
;*                                                                         *
;* INPUT:                                                                  *
;*  DWORD	gvp_ptr		; pointer to graphic viewport info	   *
;*  DWORD	shape_ptr	; the shape pointer to draw		   *
;*  DWORD	draw_x		; x-coord of hotspot in viewport	   *
;*  DWORD	draw_y		; y-coord of hotspot in viewport	   *
;*  DWORD	flags		; the flags for drawing the shape	   *
;*									   *
;* Optional Arguments: If the following flags are used, the given args	   *
;* MUST be present.  Note that, if more than one one set of args is used,  *
;* they must appear in this order (alphabetical).			   *
;*  SHAPE_COLOR:	DWORD color_table (256 bytes)			   *
;*  SHAPE_FADING:	DWORD fade_table (256 bytes), DWORD fade_count	   *
;*  SHAPE_GHOST:	DWORD is_translucent tbl, DWORD translucent tbl    *
;*  SHAPE_PARTIAL:	DWORD predator partial_value (0-255)		   *
;*  SHAPE_PRIORITY:	DWORD priority_level				   *
;*  SHAPE_SCALING:	DWORD x_scale, WORD y_scale			   *
;*  SHAPE_SHADOW:	DWORD shadowing_table (256 bytes)		   *
;*                                                                         *
;* OUTPUT:                                                                 *
;*  none.								   *
;*                                                                         *
;* WARNINGS:								   *
;*  none.								   *
;*                                                                         *
;*-------------------------------------------------------------------------*
;*									   *
;* File Organization:							   *
;* drawshp.asm : this file						   *
;* shape.inc   : main shape header file; contains declarations for all	   *
;* 		  globals, procedures and constants			   *
;* ds_table.asm: contains the procedure address tables for LSkipRout,	   *
;*		  RSkipRout, DrawRout, & PixelRout			   *
;* ds_l*.asm   : left-skip routines					   *
;* ds_r*.asm   : right-skip routines					   *
;* ds_d*.asm   : drawing routines					   *
;* 									   *
;*-------------------------------------------------------------------------*
;*                                                                         *
;* Shape format:							   *
;* Header:								   *
;*   UWORD  SType (0=normal, 1=16-color, 2=uncompressed, 4=variable-color) *
;*   UBYTE  Height							   *
;*   UWORD  Width							   *
;*   UBYTE  unmodified height						   *
;*   UWORD  size of shape in memory, including this header		   *
;*   UWORD  uncompressed data size					   *
;* Normal Shape:							   *
;*   UBYTE  [compressed] Shape data					   *
;* 16-color shape:							   *
;*   UBYTE  16-color table						   *
;*   UBYTE  [compressed] Shape data					   *
;* variable-color shape:						   *
;*   UBYTE  # colors							   *
;*   UBYTE  color table (variable-length)				   *
;*   UBYTE  [compressed] Shape data					   *
;*									   *
;*-------------------------------------------------------------------------*
;*                                                                         *
;* Uncompressed shape data format:					   *
;* Data is stored as a bitmap, with 0's treated as a special case.  Every  *
;* 0 byte is followed by a repetition count byte.  Every scan line is	   *
;* compressed separately.  Thus, the following bitmap results in the	   *
;* following shape data:						   *
;*	0 0 0 5 6 7 0 0 0 0						   *
;*	0 0 0 5 6 7 0 0 0 0						   *
;*	0 0 0 5 6 7 0 0 0 0						   *
;*									   *
;*	0 3 5 6 7 0 4							   *
;*	0 3 5 6 7 0 4							   *
;*	0 3 5 6 7 0 4							   *
;*                                                                         *
;*-------------------------------------------------------------------------*
;*                                                                         *
;* How scaling is handled:						   *
;*  Scaling is done by accumulating the x & y scale values.  When the high *
;*  byte of the accumulated value is set, the pixel (for x-scaling) or	   *
;*  the line (for y-scaling) is drawn.  The high byte is then cleared,	   *
;*  and the low byte is left so roundoffs continue to accumulate.	   *
;*									   *
;*-------------------------------------------------------------------------*
;*                                                                         *
;* Drawing Procedures:							   *
;*                                                                         *
;*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*
;*                                                                         *
;*  RSkipRout: skips given # bytes of data on the right-hand side of a	   *
;*  shape.  Just has to handle changing the current byte offset in the 	   *
;*  shape data buffer, since the draw routine knows where the left-hand	   *
;*  side of the drawable region is.  The routine may skip more bytes than  *
;*  it was told if it encounters a run of 0's, but it's assumed that a	   *
;*  run of 0's will never go past the right edge of a shape.		   *
;*    Input:								   *
;*		ECX - number of uncompressed bytes to skip		   *
;*		ESI - shape buffer data address				   *
;*    Output:								   *
;* 		ECX - negative # bytes overrun, or 0			   *
;*		ESI - updated to the current location in the shape data	   *
;*									   *
;*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*
;*                                                                         *
;*  LSkipRout: skips given # bytes of data on the left-hand side of a	   *
;*  shape.  This routine must update the shape data byte offset, and it	   *
;*  must properly update the current drawing position due to scaling, so   *
;*  it's a little more involved than the RSkip routine.  The routine may   *
;*  skip more bytes than it's told if it encounters a run of 0's.  If this *
;*  happens, the draw routine must take these extra bytes into 		   *
;*  consideration.							   *
;*    Input:								   *
;*		ECX = number of uncompressed bytes to skip		   *
;*		ESI = shape (source) buffer data address		   *
;*		EDI = viewport (destination) address			   *
;*		[WidthCount] = shape's width in bytes			   *
;*    Output:								   *
;* 		ECX - negative # pixels (not bytes) overrun, or 0	   *
;*		EDX - accumulated XTotal value at new pixel location	   *
;*		ESI - updated to the current location in the shape data	   *
;*		EDI - incr/decr by # pixels (not bytes) overrun		   *
;*		[WidthCount] - decremented by # bytes skipped		   *
;*									   *
;*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*
;*									   *
;*  DrawRout: draws one row of pixels, handles scaling, reversal and 	   *
;*	      any per pixel effects like predator, shadow etc.		   *
;*  EDX must be set up as follows:					   *
;*  - No scaling: 0							   *
;*  - No left-clipping: 0						   *
;*  - Left clipping, but no overrun: set to computed initial value for	   *
;*    that viewport coordinate						   *
;*  - Left clipping, with overrun: set to XTotal value for that coordinate *
;*  In any case, only the low byte of DL should contain data; the current  *
;*  byte in the shapebuffer should always be the first drawable pixel,	   *
;*  even if it's partially clipped (in which case DL will contain data).   *
;*    Input:								   *
;*		ECX = number of pixels (not bytes) to draw		   *
;*		EDX = XTotal initializer value				   *
;*		ESI = shape (source) buffer address			   *
;*		EDI = viewport (destination) address			   *
;*		[WidthCount] = remaining bytes on the line		   *
;*    Output:								   *
;*		ESI - updated to current location in the shape data	   *
;*		EDI - incr/decr by # pixels (not bytes) drawn/skipped	   *
;*		[WidthCount] - decremented by # bytes (not pixels) drawn   *
;*									   *
;*-------------------------------------------------------------------------*
;*                                                                         *
;* Algorithm:								   *
;* - Initialize globals							   *
;* - Pull optional arguments off the stack				   *
;* - Set up drawing procedure pointers based on drawing flags		   *
;* - Read the values from the shape header				   *
;* - Compute the shape's scaled width & height				   *
;* - Adjust the shape's drawing coordinates based on centering & 	   *
;*   viewport-relative flag settings					   *
;* - Compute the clipped areas of the shape				   *
;* - Compute the number of drawn pixels horizontally & vertically	   *
;* - Compute the starting drawing offset in the viewport		   *
;* - Draw the shape							   *
;*									   *
;*-------------------------------------------------------------------------*
;*                                                                         *
;* HISTORY:                                                                *
;*   04/13/1992 PWG : Created.                                             *
;*   08/19/1993 SKB : Split drawshp.asm into several modules.              *
;*   05/26/1994 BR  : Converted to 32-bit, restructured quite a bit.	   *
;*   08/09/1994 IML : Added C++ style interface. Various optimizations.	   *	
;*   09/06/1994 IML : Ammendments for integration of p_* and ds_* routines.*
;*   09/14/1994 IML : Now handles LCW compression.			   *		
;*=========================================================================*
PROC	Draw_Shape C NEAR 	
	USES eax,ebx,ecx,edx,edi,esi

	;--------------------------------------------------------------------
	; Arguments:
	;--------------------------------------------------------------------
	ARG	gvp_ptr:DWORD		; pointer to graphic viewport info
	ARG	shape_ptr:DWORD		; the shape pointer to draw
	ARG	draw_x:DWORD		; the destination x pixel
	ARG	draw_y:DWORD		; the destination y pixel
	ARG	flags:DWORD		; the flags for drawing the shape

IF FALSE
	;--------------------------------------------------------------------
	; Define the local stack variables that Draw_Shape needs. These 
	; parameters are defined in shape.inc.  They're included here 
	; just for reference.
	;--------------------------------------------------------------------
	;
	;...................... proc addresses ..............................
	;
	LOCAL	LSkipRout:DWORD		; pointer to the skip routine
	LOCAL	RSkipRout:DWORD		; pointer to the skip routine
	LOCAL	DrawRout:DWORD		; pointer to the draw routine
	;
	;.................... optional arguments ............................
	;
	LOCAL	ColorTable:DWORD	; ptr to the shapes color table
	LOCAL	FadingTable:DWORD	; extracted fading table pointer
	LOCAL	FadingNum:DWORD		; get the number of times to fade
	LOCAL	IsTranslucent:DWORD	; ptr to "are we translucent?" tbl
	LOCAL	Translucent:DWORD	; ptr to "ok we are translucent!" tbl
	LOCAL	PriLevel:BYTE		; the priority level of the object
	LOCAL	ScaleX:DWORD		; the x increment to scale by
	LOCAL	ScaleY:DWORD		; the y increment to scale by
	LOCAL	ShadowingTable:DWORD	; ptr to the shadowing table
	;
	;.................... Shape header values ...........................
	;
	LOCAL	ShapeType:DWORD		; shape type
	LOCAL	ShapeWidth:DWORD	; shape's unscaled width
	LOCAL	ShapeHeight:DWORD	; shape's unscaled height
	LOCAL	UncompDataLen:DWORD	; uncompressed data length
	LOCAL	ShapeData:DWORD		; pointer to [compressed] shape data
	;
	;.................. Scaled shape dimensions .........................
	;
	LOCAL	ScaledWidth:DWORD	; shape's scaled width
	LOCAL	ScaledHeight:DWORD	; shape's scaled height
	;
	;.................. Pixel clipping variables ........................
	;
	LOCAL	LeftClipPixels:DWORD	; # left-clipped pixels
	LOCAL	RightClipPixels:DWORD	; # right-clipped pixels
	LOCAL	TopClipPixels:DWORD	; # top-clipped pixels
	LOCAL	BotClipPixels:DWORD	; # bottom-clipped pixels
	LOCAL	PixelWidth:DWORD	; width of drawable area in pixels
	LOCAL	PixelHeight:DWORD	; height of drawable area in pixels
	;
	;..................... Drawing variables ............................
	;
	LOCAL	NumColors:DWORD		; # colors for 16-color shapes
	LOCAL	StartDraw:DWORD		; ptr to starting draw position
	LOCAL	NextLine:DWORD		; offset of next drawing line
	LOCAL	LeftClipBytes:DWORD	; # left-clipped bytes
	LOCAL	XTotal:DWORD		; accumulated x-pixels for scaling
	LOCAL	XTotalInit:DWORD	; initial roundoff bits for XTotal
	LOCAL	YTotal:DWORD		; accumulated y-pixels for scaling
	LOCAL	HeightCount:DWORD	; height counter for drawing lines
	LOCAL	LineStart:DWORD		; address of start of line
	LOCAL	WidthCount:DWORD	; counts down # bytes skipped
	LOCAL	StashReg:DWORD		; temp variable for draw routines
	LOCAL	MaskAdjust:DWORD	; priority buffer offset
	LOCAL	BackAdjust:DWORD	; background buffer offset
	LOCAL	StashECX:DWORD		; temp variable for ECX register
	LOCAL	StashEDX:DWORD		; temp variable for EDX register

ENDIF

	;====================================================================
	; Initialization:
	; - allocate space for globals
	; - validate shape pointer
	; - set SHAPE_COMPACT flag if needed
	;====================================================================
	;--------------------------------------------------------------------
	; Allocate stack space for our local variables.
	;--------------------------------------------------------------------
	LOCAL	Local_Stack:BYTE:Local_Size

	;--------------------------------------------------------------------
	; Make sure the shape pointer is not NULL
	;--------------------------------------------------------------------
	cmp	[shape_ptr],0			; compare shape ptr value to NULL
	jnz	??valid_shp			; if non-zero, it's valid
	jmp	??exit				; otherwise get the heck outta here

	;--------------------------------------------------------------------
	; Move gvp info into local variables
	;--------------------------------------------------------------------
??valid_shp:
	mov	edi,[gvp_ptr]					; get pointer to graphic viewport info
	mov	esi, [(type GVPC_IMAGE  ptr edi). vvpc . Off ] ; extract viewport pointer
	mov	[viewport_ptr],esi
	mov	ebx,[(type GVPC_IMAGE ptr edi) . vvpc . Width ]	; extract viewport width
	mov	[viewport_width],ebx			
	mov	eax,[(type GVPC_IMAGE ptr edi) . vvpc . Height ]	; extract viewport height
	mov	[viewport_height],eax				
	mov	ecx,[(type GVPC_IMAGE ptr edi) . vvpc . Page ]	; calculate y add value
	add	ecx,ebx
	mov	[viewport_yadd],ecx
	mov	eax,[(type GVPC_IMAGE ptr edi) . Xpos ]		; extract viewport x-coord
	mov	[viewport_x],eax
	mov	eax, [(type GVPC_IMAGE ptr edi) . Ypos ]	; extract viewport y-coord
	mov	[viewport_y],eax
	mul	ecx				; calculate buffer pointer
	add	eax,[viewport_x]
	sub	esi,eax
	mov	[buff_ptr],esi


	;--------------------------------------------------------------------
	; If this shape is a compact shape, set that bit in the flags arg
	;--------------------------------------------------------------------
	mov	edi,[shape_ptr]			; check for compact shape flag
	test	[BYTE PTR edi],MAKESHAPE_COMPACT	 
							
	jz	??do_args			; if not process flags as is
	or	[flags],SHAPE_COMPACT		; mark it as a compact shape

	;====================================================================
	; Pull off optional arguments:
	; EDI is used as an offset from the 'flags' parameter, to point
	; to the optional argument currently being processed.
	;====================================================================
??do_args:
	mov	edi,4	 			; optional params start past flags

	;--------------------------------------------------------------------
	; Initialize optional argument values:
	;--------------------------------------------------------------------
	mov	[ColorTable],0			; default = NULL
	mov	[FadingTable],0			; default = NULL
	mov	[FadingNum],0			; default = no fading
	mov	[IsTranslucent],0		; default = NULL
	mov	[Translucent],0			; default = NULL
	mov	[PriLevel],0			; default = no priority
	mov	[ScaleX],100h			; default = unity X scaling
	mov	[ScaleY],100h			; default = unity Y scaling
	mov	[ShadowingTable],0		; default = NULL

	;--------------------------------------------------------------------
	; SHAPE_COLOR: DWORD color_table[256]
	;--------------------------------------------------------------------
??color:
	test	[flags],SHAPE_COLOR 		; does it have a color table
	jz	??fading 			; if not skip to fading 
	or	[flags],SHAPE_COMPACT		; mark it as a compact shape
						;  (for remapping purposes only)
	mov	eax,[flags + edi]
	mov	[ColorTable],eax		; save address of color table
	add	edi,4				; point to next optional argument

	;--------------------------------------------------------------------
	; SHAPE_FADING: DWORD fade_table[256], DWORD fade_count
	;--------------------------------------------------------------------
??fading:
	test	[flags],SHAPE_FADING		; are we fading this shape
	jz	??ghost				; skip to ghosting check
	mov	eax,[flags + edi]
	mov	[FadingTable],eax		; save address of fading tbl

	mov	eax,[flags + edi + 4]		; get fade num

	add	edi,8				; next argument
	cmp	eax,0				; check if it's 0
	jnz	??set_fading			; if not, store fade num
	and	[flags],NOT SHAPE_FADING	; otherwise, don't fade

??set_fading:
	mov	[FadingNum],eax

	;--------------------------------------------------------------------
	; SHAPE_GHOST: DWORD is_translucent tbl, DWORD translucent tbl
	;--------------------------------------------------------------------
??ghost:
	test	[flags],SHAPE_GHOST		; are we ghosting this shape
	jz	??init_predator			; skip to predator check
	mov	eax,[flags + edi]
	mov	[IsTranslucent],eax		; save ptr to is_trans. tbl
	mov	eax,[flags + edi + 4]
	mov	[Translucent],eax		; save ptr to translucent tbl
	add	edi,8				; next argument

	;--------------------------------------------------------------------
	; SHAPE_PREDATOR: Initialize the predator effect variables
	;--------------------------------------------------------------------
??init_predator:
	test	[flags],SHAPE_PREDATOR		; is predator effect on
	jz	??partial			; if not skip to partial 
	inc	[PredCount]			; the pred table is byte aligned
	and	[PredCount],PRED_MASK		; keep entries within bounds
	mov	eax,[PredCount]		 
	mov	al,[BYTE PTR PredTable + eax]
	mov	[PredValue],eax			; put the pred value cs
	mov	[PartialCount],0		; clear the partial count
	mov	[PartialPred],100h		; init partial to off

	;--------------------------------------------------------------------
	; SHAPE_PARTIAL: DWORD partial_pred_value (0-255)
	;--------------------------------------------------------------------
??partial:
	test	[flags],SHAPE_PARTIAL		; is this a partial pred?
	jz	??priority			; if not check priority
	mov	eax,[flags + edi]		; pull the partial value
	mov	[PartialPred],eax		; store it off
	add	edi,4				; next argument

	;--------------------------------------------------------------------
	; SHAPE_PRIORITY: DWORD priority_level
	;--------------------------------------------------------------------
??priority:
	test	[flags],SHAPE_PRIORITY		; is this a priority draw
	jz	??scale				; if not skip to scale
	mov	eax,[flags + edi]
	mov	[PriLevel],al			; store priority level
	add	edi,4				; next argument
	mov	eax,[MaskPage]			; calculate priority buffer
	sub	eax,[buff_ptr]			;  offset
	mov	[MaskAdjust],eax
	mov	eax,[BackGroundPage]		; calculate background buffer
	sub	eax,[buff_ptr]			;  offset
	mov	[BackAdjust],eax

	;--------------------------------------------------------------------
	; SHAPE_SCALING: DWORD x_scale, WORD y_scale
	;--------------------------------------------------------------------
??scale:
	test	[flags],SHAPE_SCALING		; are we scaling this shape.
	jz	??shadow			; if not then skip scale y value
	mov	eax,[flags + edi]	
	mov	[ScaleX],eax
	mov	eax,[flags + edi + 4]	
	mov	[ScaleY],eax
	add	edi,8				; next argument

	;--------------------------------------------------------------------
	; SHAPE_SHADOW: DWORD shadow_table[256]
	;--------------------------------------------------------------------
??shadow:
	test	[flags],SHAPE_SHADOW		; are we ghosting this shape
	jz	short ??get_header		; if not then skip
	mov	eax,[flags + edi]
	mov	[ShadowingTable],eax		; save address of shadow table 
	add	edi,4				; next argument


??get_header:	
	;====================================================================
	; Get Shape header values
	;====================================================================
	mov	esi,[shape_ptr]			; prepare to read header
	movzx	eax,[WORD PTR esi]
	mov	[ShapeType],eax			; extract shape type
	movzx	eax,[BYTE PTR esi + 2]
	mov	[ShapeHeight],eax
	movzx	eax,[WORD PTR esi + 3]		; extract shape height
	mov	[ShapeWidth],eax
	movzx	eax,[WORD PTR esi + 8]		; extract uncompressed data length
	mov	[UncompDataLen],eax
	add	esi,10				; reposition index

	;--------------------------------------------------------------------
	; Now get NumColors, ColorTable address, & data pointer:
	; <16-color shape:
	;   shape.Colortable[0] = # colors
	;   shape data is after that many colors
	; 16-color shape:
	;   shape.Colortable[] contains colors
	;   shape data is after those colors
	; default 256-color shape:
	;   shape data starts at shape.Colortable[0]
	; Note: ColorTable is set only if flags & SHAPE_COLOR is 0; otherwise,
	;   the color table was passed in & we already have a pointer to it
	;--------------------------------------------------------------------
	;
	;....................... <16-color shape: ...........................
	;
	test	[ShapeType],MAKESHAPE_VARIABLE
	jz	??check_16
	movzx	eax,[BYTE PTR esi]		; read # colors
	mov	[NumColors],eax			; save # colors
	inc	esi
	test	[flags],SHAPE_COLOR		; don't set ColorTable if
	jnz	??norm_get_data_addr		;  it was passed in
	mov	[ColorTable],esi		; save color table pointer

??norm_get_data_addr:
	add	esi,[NumColors]			; skip past color data
	mov	[ShapeData],esi			; set data address
	jmp	??setup_procs

	;....................... 16-color shape: ............................
??check_16:
	test	[ShapeType],MAKESHAPE_COMPACT
	jz	??256_get_data_addr
	mov	[NumColors],16			; save # colors
	test	[flags],SHAPE_COLOR		; don't set ColorTable if
	jnz	??16_get_data_addr		;  it was passed in
	mov	[ColorTable],esi		; save color table pointer

??16_get_data_addr:
	add	esi,[NumColors]			; skip past color data
	mov	[ShapeData],esi			; set data address
	jmp	??setup_procs
	;
	;....................... 256-color shape: ...........................
	;
??256_get_data_addr:
	mov	[ShapeData],esi			; set data address

	;====================================================================
	; Set up the drawing procedure addresses
	;====================================================================
	;--------------------------------------------------------------------
	; This code uses HORZ_REV, VERT_REV, & SCALING flags as an 
	; offset into the LSkipTable, RSkipTable, and DrawTable.  These
	; flags combined have values from 00h-07h, so each table must have
	; at least 8 entries.
	;--------------------------------------------------------------------
??setup_procs:
	mov	ebx,[flags]		; load flags value
	and	ebx,07h			; clip high bits
	add	ebx,ebx			; mult by 4 to get DWORD offset
	add	ebx,ebx
	mov	eax,[LSkipTable + ebx]	; get table value
	mov	[LSkipRout],eax		; store it in the function pointer
	mov	eax,[RSkipTable + ebx]	; get table value
	mov	[RSkipRout],eax		; store it in the function pointer
	mov	eax,[DrawTable + ebx]	; get table value
	mov	[DrawRout],eax		; store it in the function pointer

??compute_scalevals:
	;====================================================================
	; Now compute scaled width & height.  If the shape scales down to 0 
	; either horizontally or vertically, exit.
	;====================================================================
	test	[flags],SHAPE_SCALING	; skip if no scaling
	jz	??no_scaling
	;
	;........................ scaled width: .............................
	;
	mov	eax,[ShapeWidth]	; get byte width
	mov	ebx,[ScaleX]		; prepare for register mul
	mul	ebx			; EDX:EAX = result
	shrd	eax,edx,8		; EAX = result rounded down
	or	eax,eax
	jz	??exit			; exit if EAX is 0
	mov	[ScaledWidth],eax	; save the scaled width
	;
	;........................ scaled height: ............................
	;
	mov	eax,[ShapeHeight]	; get byte height
	mov	ebx,[ScaleY]		; prepare for register mul
	mul	ebx			; EDX:EAX = result
	shrd	eax,edx,8		; EAX = result rounded down
	or	eax,eax
	jz	??exit			; exit if EAX is 0
	mov	[ScaledHeight],eax	; save the scaled height
	jmp	??handle_centering
	;
	;......................... no scaling: ..............................
	;
??no_scaling:
	mov	eax,[ShapeWidth]
	mov	[ScaledWidth],eax	; pixel width = byte width
	mov	eax,[ShapeHeight]
	mov	[ScaledHeight],eax	; pixel height = byte height

	;====================================================================
	; Allow for SHAPE_CENTER by adjusting the draw_x & draw_y arguments:
	; draw_x -= ScaledWidth / 2
	; draw_y -= ScaledHeight / 2
	;====================================================================
??handle_centering:
	;
	;........................ adjust draw_x .............................
	;
	test	[flags],SHAPE_CENTER	; skip if not centered
	jz	??handle_vp_rel
	mov	eax,[draw_x]		; load in draw_x
	mov	edx,[ScaledWidth]	; load in ScaledWidth
	shr	edx,1			; divide it by 2
	sub	eax,edx			; subract it from eax
	mov	[draw_x],eax		; store it back into draw_x
	;
	;........................ adjust draw_y .............................
	;
	mov	eax,[draw_y]		; load in draw_y
	mov	edx,[ScaledHeight]	; load in ScaledHeight
	shr	edx,1			; divide it by 2
	sub	eax,edx			; subract it from eax
	mov	[draw_y],eax		; store it back into draw_y

	;====================================================================
	; Allow for SHAPE_VIEWPORT_REL by adjusting draw_x & draw_y by the 
	; viewport's coordinates
	;====================================================================
??handle_vp_rel:
	test	[flags],SHAPE_VIEWPORT_REL	; skip if not vp-relative
	jz	??compute_horz_clip
	mov	eax,[viewport_x]
	add	[draw_x],eax			; draw_x += viewport_x
	mov	eax,[viewport_y]
	add	[draw_y],eax			; draw_y += viewport_y

	;====================================================================
	; Now that we have the scaled size and adjusted x & y drawing
	; coordinates, we can compute the clipped areas of the shape:
	;   LeftClipPixels =	viewport_x - draw_x
	;	- if negative, set to 0
	;   RightClipPixels =	(draw_x + ScaledWidth) - 
	;				(viewport_x + viewport_width)
	;	- if negative, set to 0
	;
	;   TopClipPixels =	viewport_y - draw_y
	;	- if negative, set to 0
	;   BotClipPixels =	(draw_y + ScaledHeight) -
	;				(viewport_y + viewport_height)
	;	- if negative, set to 0
	;====================================================================
??compute_horz_clip:
	;
	;...................... left-clipped pixels .........................
	;
	mov	eax,[viewport_x]
	sub	eax,[draw_x]		; EAX = viewport_x - draw_x
	jge	??set_left_clip
	mov	eax,0			; if EAX<0, set to 0
??set_left_clip:
	mov	[LeftClipPixels],eax	; store # left-clipped pixels
	;
	;...................... right-clipped pixels ........................
	;
	mov	eax,[draw_x]
	add	eax,[ScaledWidth]	; EAX = draw_x + ScaledWidth
	mov	edx,[viewport_x]
	add	edx,[viewport_width]	; EDX = viewport_x + viewport_width
	sub	eax,edx
	jge	??set_right_clip
	mov	eax,0			; if EAX<0, set to 0
??set_right_clip:
	mov	[RightClipPixels],eax	; store # right-clipped pixels
	;
	;...................... top-clipped pixels ..........................
	;
??compute_vert_clip:
	mov	eax,[viewport_y]
	sub	eax,[draw_y]		; EAX = viewport_y - draw_y
	jge	??set_top_clip
	mov	eax,0			; if EAX<0, set to 0
??set_top_clip:
	mov	[TopClipPixels],eax	; store # top-clipped pixels
	;
	;.................... bottom-clipped pixels .........................
	;
	mov	eax,[draw_y]
	add	eax,[ScaledHeight]	; EAX = draw_y + ScaledHeight
	mov	edx,[viewport_y]
	add	edx,[viewport_height]	; EDX = viewport_y + viewport_height
	sub	eax,edx
	jge	??set_bottom_clip
	mov	eax,0			; if EAX<0, set to 0
??set_bottom_clip:
	mov	[BotClipPixels],eax	; store # bottom-clipped pixels

	;====================================================================
	; Now compute the number of pixels actually drawn, horizontally and
	; vertically; exit if either is <= 0
	;====================================================================
??compute_drawn_pixels:
	;
	;.................... pixel width of drawn area .....................
	;
	mov	eax,[ScaledWidth]	; get total width in pixels
	sub	eax,[LeftClipPixels]	; subtract off left-clipped pixels
	sub	eax,[RightClipPixels]	; subtract off right-clipped pixels
	jle	??exit			; exit if no horizontal pixels drawn
	mov	[PixelWidth],eax	; store drawn pixel width
	;
	;.................... pixel height of drawn area ....................
	;
	mov	eax,[ScaledHeight]	; get total height in pixels
	sub	eax,[TopClipPixels]	; subtract off top-clipped pixels
	sub	eax,[BotClipPixels]	; subtract off bottom-clipped pixels
	jle	??exit			; exit if no horizontal pixels drawn
	mov	[PixelHeight],eax	; store drawn pixel height

	;====================================================================
	; So, we're actually going to draw something; if (ShapeType & 
	; MAKESHAPE_NOCOMP == 0) decompress the shape data into _ShapeBuffer:
	; LCW_Uncompress(ShapeData, _ShapeBuffer, UncompDataLen);
	;	shape.DataLength
	;	&_ShapeBuffer
	;	&(shape's data)
	; - otherwise the shape data is already uncompressed
	;====================================================================
	test	[ShapeType],MAKESHAPE_NOCOMP
	jnz	??uncompressed

	mov	eax,[UncompDataLen]
	push	eax			; push arg 3
	mov	eax,[_ShapeBuffer]
	push	eax			; push arg 2
	mov	eax,[ShapeData]
	push	eax			; push arg 1
	call	LCW_Uncompress		; call routine
	add	esp,12			; restore stack
	mov	eax,[_ShapeBuffer]
	mov	[ShapeData],eax
	jmp	??copy_flags

??uncompressed:
;	mov	eax,[ShapeData]		; set up pointer to shape data
;	mov	[_ShapeBuffer],eax


	;--------------------------------------------------------------------
	; Set the global Flags variable
	;--------------------------------------------------------------------
??copy_flags:
	mov	eax,[flags]
	mov	[Flags],eax		

	;====================================================================
	; Now compute the actual buffer offset where drawing (not skipping)
	; will begin
	;====================================================================
	;--------------------------------------------------------------------
	; First, compute the x & y offsets of the shape's clipped upper-left 
	; corner,  relative to the viewport's upper-left corner:
	; x-offset = draw_x + LeftClipPixels - viewport_x
	; y-offset = draw_y + TopClipPixels - viewport_y
	;--------------------------------------------------------------------
	mov	ebx,[draw_x]
	add	ebx,[LeftClipPixels]
	sub	ebx,[viewport_x]	; EBX = viewport x-offset

	mov	eax,[draw_y]
	add	eax,[TopClipPixels]
	sub	eax,[viewport_y]	; EAX = viewport y-offset

	;--------------------------------------------------------------------
	; Then, adjust the viewport offsets due to horizontal & vertical
	; reversal:
	; if HORZ_REV, x-offset += (PixelWidth - 1)
	; if VERT_REV, y-offset += (PixelHeight - 1)
	;--------------------------------------------------------------------
	;
	;................. Adjust for horizontal reversal ...................
	;
	test	[flags],SHAPE_HORZ_REV
	jz	??adjust_vert_offset
	add	ebx,[PixelWidth]
	dec	ebx			; EBX = true x-offset
	;
	;................ Swap LeftClip & RightClip pixels ..................
	;
	mov	edx,[LeftClipPixels]	; exchange left & right-clipped pixels
	xchg	edx,[RightClipPixels]
	mov	[LeftClipPixels],edx

	;
	;.................. Adjust for vertical reversal ....................
	;
??adjust_vert_offset:
	test	[flags],SHAPE_VERT_REV
	jz	??adjust_pointer
	add	eax,[PixelHeight]
	dec	eax			; EAX = true y-offset
	;
	;.................. Swap TopClip & BotClip pixels ...................
	;
	mov	edx,[TopClipPixels]
	xchg	edx,[BotClipPixels]
	mov	[TopClipPixels],edx

	;--------------------------------------------------------------------
	; Now, adjust the starting position pointer:
	;--------------------------------------------------------------------
??adjust_pointer:	;!!!!!!! convert to register mul for speed !!!!!!!!
	add	ebx,[viewport_ptr]	; add initial ptr to x-offset
	mul	[viewport_yadd]		; convert y-offset (EAX) to bytes
	add	ebx,eax			; add those bytes in
	mov	[StartDraw],ebx		; store the starting pointer

	;--------------------------------------------------------------------
	; Finally, if VERT_REV, negate yadd to move up not down:
	;--------------------------------------------------------------------
	test	[flags],SHAPE_VERT_REV
	jz	??init_xtotal
	neg	[viewport_yadd]		; move up, not down

	;====================================================================
	; Initialize the horizontal scale accumulation value:
	;   If there are any left-clipped pixels, the scale accumulator will
	;   have to be initialized with the value it >would< have by stepping
	;   over that many pixels.  This initial value can be computed by
	;   dividing the # of left-clipped pixels by the x-scale value itself,
	;   picking off the remainder from this division & negating it.  This
	;   sets the low byte of the remainder to the correct accumulation
	;   value (the high bytes will be garbage).
	;   (The alternative to this approach would be to multiply the
	;   scale factor by the # clipped bytes, which is the result of the
	;   division; however, negating the remainder is much faster than
	;   the multiply would be.)
	;====================================================================
??init_xtotal:
	mov	edx,0			; prepare for divide
	mov	eax,[LeftClipPixels]	; get # left-clipped pixels
	shl	eax,8			; multiply by 100h
	mov	ebx,[ScaleX]		; load ScaleX value
	div	bx			; 16-bit div: AX = rslt, DX = rem
	mov	[LeftClipBytes],eax	; save # left-clipped bytes
	neg	edx			; generate roundoff bits
	and	edx,0Fh			; only save low byte
	mov	[XTotalInit],edx	; save initial roundoff value

	;====================================================================
	; Initialize drawing variables:
	;====================================================================
	mov	esi,[ShapeData]		; ESI = shape buffer starting point
	mov	edi,[StartDraw]		; EDI = drawing address
	mov	[YTotal],0		; initialize accumulated scale

	;====================================================================
	; Clip the top-clipped lines. The object here is to set ESI to the 
	; first drawable line in the _ShapeBuffer, and YTotal to: 
	;   high byte = # times to draw that line, 
	;   low byte = roundoff bits
	;
	; - Initialize values (ESI, HeightCount, YTotal)
	; - Skip loop if no top lines to clip
	; - Loop:
	;   - save this line's byte position in _ShapeBuffer, in case we
	;     overrun
	;   - call RSkipRout with ECX set to # bytes to skip (one row)
	;   - accumulate ScaleY into YTotal
	;   - if high byte is non-zero, there are that many drawn lines:
	;     - decrement HeightCount by that many lines
	;     - clear the high byte in YTotal, but keep the roundoff bits
	;     - if HeightCount > 0, loop again to clip more lines
	;     - if HeightCount is 0, start drawing:
	;	- ESI points to first non-clipped line in _ShapeBuffer
	;	- YTotal contains 0 in high byte, roundoff bits in low byte
	;     - otherwise, we've clipped too many lines:
	;	- put ESI back to the line we just clipped
	;	- set high byte of YTotal to # lines overrun
	;	- subtract ScaleY from YTotal, to set it up for drawing loop
	;====================================================================
	;
	;..................... skip if nothing to clip ......................
	;
	mov	eax,[TopClipPixels]
	cmp	eax,0			; see if any top-clipped pixels
	jz	??draw_loop		; if not, skip this
	mov	[HeightCount],eax	; save off # lines to clip

??clip_y_loop:
	;
	;...................... skip this row of bytes ......................
	;
	mov	[LineStart],esi		; save this line's byte position
	mov	ecx,[ShapeWidth]	; set up ECX for RSkipRout
	call	[RSkipRout]		; skip 'ShapeWidth' bytes
	;
	;............... see if this row would have been drawn ..............
	;
	mov	eax,[ScaleY]
	add	[YTotal],eax		; accumulate scale factor
	test	[YTotal],0FF00h		; check to see if we draw the line
	jz	??clip_y_loop		; if not loop again
	;
	;...................... decrement HeightCount .......................
	;
	mov	eax,0			; clear EAX
	xchg	al,[BYTE PTR YTotal+1]	; get # lines, clear it in YTotal
	sub	[HeightCount],eax	; subtract # drawn lines from HtCt
	jg	??clip_y_loop		; if more lines remain, loop again
	jns	??draw_loop		; is exactly 0; we're done clipping
	;
	;....................... adjust for overrun .........................
	;
	mov	esi,[LineStart]		; point ESI back to this line
	mov	eax,[HeightCount]
	neg	eax			; EAX = # lines overrun
	shl	eax,8			; multiply by 100h
	add	eax,[YTotal]		; add in roundoff bits
	sub	eax,[ScaleY]		; adjust down by y-scale
	mov	[YTotal],eax		; store in YTotal

	;====================================================================
	; The drawing loop (at long last!):
	; - Accumulate YTotal; if high byte is 0, skip this row of bytes & 
	;   loop again
	; - Skip left-clipped pixels:
	;   - If we've skipped all the bytes on the line, just go to the
	;     next line
	; - Draw middle pixels:
	;   - Add the shape's pixel width to ECX (which could be negative 
	;     if we left-skipped into the drawable area)
	;   - If ECX is still 0, there are no pixels to draw
	;   - Otherwise, leave ECX as is & draw the pixels
	; - Skip right-clipped pixels:
	;   - Add # right-clipped pixels to ECX (which could be negative if
	;     the draw routine  uncompressed 0's into the right-clipped 
	;     region)
	;   - if ECX > 0, skip the remaining bytes
	; - Go to the next line:
	;   - point EDI to the start of the next line in the viewport
	;   - decrement the height counter, exit if it's 0
	;   - decrement YTotal's high byte
	;     - if it's 0, go to the loop top
	;     - otherwise, reset ESI to this line's start & redraw the line,
	;       starting at left-clipped pixels
	;       (NOTE: why not start drawing at middle pixels??????????)
	;====================================================================
??draw_loop:
	;
	;................... accumulate YTotal & test it ....................
	;
	mov	eax,[ScaleY]		; get y scaling factor
	add	[YTotal],eax		; accumulate YTotal
	test	[YTotal],0FF00h		; see if we need to draw anything
	jnz  	??draw_line		; draw this line
	;
	;......................... skip this line ...........................
	;
	mov	ecx,[ShapeWidth]	; load shape's width in bytes
	call	[RSkipRout]		; skip this row & loop again
	jmp	??draw_loop

	;
	;--------------------- start drawing this line ----------------------
	;
??draw_line:
	mov	[LineStart],esi		; save current byte position
	;....................................................................
	; Skip left-clipped pixels:
	; - initialize [WidthCount] to total shape width in bytes
	; - set ECX to # >bytes< to clip
	; When LSkipRout returns: 
	;	- ECX will contain # >pixels< overrun
	;	- EDX will contain the XTotal init value
	;	- [WidthCount] will be decremented by total bytes skipped
	;....................................................................
??draw_left:
	mov	eax,[ShapeWidth]	; load shape width
	mov	[WidthCount],eax	; set up for LSkipRout
	mov	ecx,[LeftClipBytes]	; bytes, not pixels!
	call	[LSkipRout]		; skip the bytes
	cmp	[WidthCount],0
	jz	??next_line		; The whole line was 0's
	;....................................................................
	; Draw middle pixels:
	; - add PixelWidth to ECX (which may be negative)
	; - if ECX is 0, don't bother drawing
	; When DrawRout returns:
	;	- ECX will contain # >pixels< overrun
	;	- [WidthCount] will be decremented by # bytes drawn
	;....................................................................
??draw_middle:
	add	ecx,[PixelWidth]	; since ECX could overrun, add width
	jle	??draw_right		; if ECX<=0, no middle pixels to draw
	call	[DrawRout]		; draw the pixels
	;
	;................... skip past right-clipped pixels .................
	;
??draw_right:
	mov	ecx,[WidthCount]	; ECX = remaining # bytes
	jecxz	??next_line		; don't bother if no bytes remain
	call	[RSkipRout]		; skip right-clipped bytes
	;
	;----------------------- go to the next line ------------------------
	;
??next_line:
	;
	;................. adjust EDI to start of next line .................
	;
	mov	eax,[viewport_yadd]	; get yadd
	add	[StartDraw],eax		; add it to this line's position
	mov	edi,[StartDraw]		; EDI = next line
	;
	;................. decrement our pixel row counter ..................
	;
	dec	[PixelHeight]		; count down a line
	jz	??exit			; we're done!
	;
	;.................. decrement YTotal's high byte ....................
	;
	dec	[BYTE PTR YTotal + 1]	; decrement high byte
	jz	??draw_loop		; draw next line if 0
	;
	;....................... re-draw this line ..........................
	;
	mov	esi,[LineStart]		; reset to this line's start
	jmp	??draw_left		; redraw this line

??exit:
	ret

	ENDP	Draw_Shape


;***************************************************************************
;* Not_Supported -- Replacement function for Draw_Shape routines not used. *
;*                                                                         *
;* INPUT:                                                                  *
;*	none.								   *
;*                                                                         *
;* OUTPUT:                                                                 *
;*	none.								   *
;*                                                                         *
;* WARNINGS:                                                               *
;*	none.								   *
;*                                                                         *
;* HISTORY:                                                                *
;*   08/24/1993 SKB : Created.                                             *
;*=========================================================================*
PROC	Not_Supported NOLANGUAGE NEAR

	ret

	ENDP Not_Supported 

	END

;************************** End of drawshp.asm *****************************