[Scummvm-cvs-logs] CVS: scummvm/scumm akos.cpp,1.23,1.24 gfx.cpp,1.49,1.50 object.cpp,1.8,1.9 scumm.h,1.53,1.54

Pawe? Ko?odziejski aquadran at users.sourceforge.net
Tue Nov 5 23:29:07 CET 2002


Update of /cvsroot/scummvm/scummvm/scumm
In directory usw-pr-cvs1:/tmp/cvs-serv32361

Modified Files:
	akos.cpp gfx.cpp object.cpp scumm.h 
Log Message:
rewrote akos5 and bomp, corrected pitch in akos16, increased range of gfxbits

Index: akos.cpp
===================================================================
RCS file: /cvsroot/scummvm/scummvm/scumm/akos.cpp,v
retrieving revision 1.23
retrieving revision 1.24
diff -u -d -r1.23 -r1.24
--- akos.cpp	25 Oct 2002 13:44:03 -0000	1.23
+++ akos.cpp	6 Nov 2002 07:28:38 -0000	1.24
@@ -137,6 +137,15 @@
 	for (i = 0; i < size; i++) {
 		palette[i] = new_palette[i] != 0xFF ? new_palette[i] : the_akpl[i];
 	}
+
+	if (size == 256) {
+		byte color = new_palette[0];
+		if (color == 255) {
+			palette[0] = color;
+		} else {
+			_vm->_bompActorPalletePtr = palette;
+		}
+	}
 }
 
 void AkosRenderer::setCostume(int costume)
@@ -842,143 +851,87 @@
 	} while (1);
 }
 
+void AkosRenderer::codec5() {
+	int32 clip_left, clip_right, clip_top, clip_bottom, maxw, maxh, tmp_x, tmp_y;
 
-void AkosRenderer::codec5()
-{
-	int left, right, top, bottom;
-	int clip_left, clip_right, clip_top, clip_bottom;
-
-	byte *src, *dest;
-	int src_x, src_y;
-	int dst_x, dst_y;
-
-	bool masking;
-	byte maskbit;
-	byte *mask = NULL;
+	_vm->_bompShadowMode = shadow_mode;
 
-	// I don't know if this is complete. It used to simply call drawBomp()
-	// to draw an unscaled image, but I don't know if that was because it
-	// will never have to scale, or if it's because until quite recently
-	// drawBomp() didn't know how to scale images.
-	//
-	// What I do know is that drawBomp() doesn't care about masking and
-	// shadows, and these are both needed for Full Throttle and The Dig.
-	
 	if (!mirror) {
-		left = (_x - move_x_cur - _width) + 1;
+		clip_left = (_x - move_x_cur - _width) + 1;
 	} else {
-		left = _x + move_x_cur - 1;
+		clip_left = _x + move_x_cur - 1;
 	}
 
-	right = left + _width;
-	top = _y + move_y_cur;
-	bottom = top + _height;
+	clip_right = (clip_left + _width) - 1;
+	clip_top = _y + move_y_cur;
+	clip_bottom = (clip_top + _height) - 1;
+	maxw = outwidth - 1;
+	maxh = outheight - 1;
 
-	if (left >= (int) outwidth || top >= (int) outheight)
+	if (clip_left < 0) {
+		clip_left = 0;
+	}
+
+	tmp_x = clip_right - maxw;
+	if (tmp_x > 0) {
+		clip_right -= tmp_x;
+	}
+
+	tmp_y = clip_top;
+	if (tmp_y < 0) {
+		clip_top -= tmp_y;
+	}
+
+	tmp_y = clip_bottom - maxh;
+	if (tmp_y > 0) {
+		clip_bottom -= tmp_y;
+	}
+
+	if ((clip_right <= clip_left) || (clip_top >= clip_bottom))
 		return;
 
-	// The actual drawing code shouldn't survive even if the image is
-	// partially outside the screen, but something before that seems to
-	// be less tolerant...
+	_vm->updateDirtyRect(0, clip_left, clip_right + 1, clip_top, clip_bottom + 1, 1 << dirty_id);
 
-	clip_left = (left >= 0) ? left : 0;
-	clip_right = (right > (int) outwidth) ? (int) outwidth : right;
-	clip_top = (top >= 0) ? top : 0;
-	clip_bottom = (bottom > (int) outheight) ? (int) outheight : bottom;
-	
 	if (clip_top < draw_top)
 		draw_top = clip_top;
 	if (clip_bottom > draw_bottom)
-		draw_bottom = clip_bottom;
-
-	_vm->updateDirtyRect(0, clip_left, clip_right, clip_top, clip_bottom, 1 << dirty_id);
-
-	masking = false;
-	if (clipping) {
-		masking = _vm->isMaskActiveAt(clip_left, clip_top, clip_right, clip_bottom,
-			_vm->getResourceAddress(rtBuffer, 9) +
-			_vm->gdi._imgBufOffs[clipping] +
-			_vm->_screenStartStrip) != 0;
-	}
-
-	v1.mask_ptr = NULL;
+		draw_bottom = clip_bottom + 1;
 
-	if (masking || charsetmask) {
-		v1.mask_ptr = _vm->getResourceAddress(rtBuffer, 9) + _vm->_screenStartStrip;
-		v1.imgbufoffs = _vm->gdi._imgBufOffs[clipping];
-		if (!charsetmask && masking) {
-			v1.mask_ptr += v1.imgbufoffs;
-			v1.imgbufoffs = 0;
-		}
-	}
+	BompDrawData bdd;
 
-	src = srcptr;
-	dest = outptr;
+	bdd.srcwidth = _width;
+	bdd.srcheight = _height;
+	bdd.out = outptr;
+	bdd.outwidth = outwidth;
+	bdd.outheight = outheight;
+	bdd.dataptr = srcptr;
+	bdd.scale_x = 255;
+	bdd.scale_y = 255;
 
-	for (src_y = 0, dst_y = top; src_y < _height; src_y++) {
-		byte code, color;
-		uint num, i;
-		byte *d = dest + dst_y * outwidth + left;
-		byte *s;
-		uint data_length;
+	_vm->_bompScallingXPtr = NULL;
+	_vm->_bompScallingYPtr = NULL;
 
-		data_length = READ_LE_UINT16(src) + 2;
+	int decode_mode;
 
-		if (dst_y < 0 || dst_y >= (int) outheight) {
-			src += data_length;
-			dst_y++;
-			continue;
-		}
+	if (!mirror) {
+		bdd.x = (_x - move_x_cur - _width) + 1;
+		decode_mode = 3;
+	} else {
+		bdd.x = _x + move_x_cur;
+		decode_mode = 1;
+	}
 
-		src_x = 0;
-		dst_x = left;
-		s = src + 2;
+	bdd.y = _y + move_y_cur;
 
-		while (src_x < _width) {
-			code = *s++;
-			num = (code >> 1) + 1;
-			if (code & 1) {
-				color = *s++;
-				for (i = 0; i < num; i++) {
-					if (dst_x >= 0 && dst_x < (int) outwidth) {
-						if (color != 255) {
-							if (v1.mask_ptr)
-								mask = v1.mask_ptr + _numStrips * dst_y + (dst_x >> 3);
-							maskbit = revBitMask[dst_x & 7];
-							if (shadow_mode && color == 13)
-								color = shadow_table[*d];
-							if (!mask || !((mask[0] | mask[v1.imgbufoffs]) & maskbit))
-								*d = color;
-						}
-					}
-					d++;
-					dst_x++;
-					src_x++;
-				}
-			} else {
-				for (i = 0; i < num; i++) {
-					color = s[i];
-					if (dst_x >= 0 && dst_x < (int) outwidth) {
-						if (color != 255) {
-							if (v1.mask_ptr)
-								mask = v1.mask_ptr + _numStrips * dst_y + (dst_x >> 3);
-							maskbit = revBitMask[dst_x & 7];
-							if (shadow_mode && color == 13)
-								color = shadow_table[*d];
-							if (!mask || !((mask[0] | mask[v1.imgbufoffs]) & maskbit))
-								*d = color;
-						}
-					}
-					d++;
-					dst_x++;
-					src_x++;
-				}
-				s += num;
-			}
-		}
-		src += data_length;
-		dst_y++;
+	if (clipping != 0) {
+		_vm->_bompMaskPtr = _vm->getResourceAddress(rtBuffer, 9) + _vm->_screenStartStrip + _vm->gdi._imgBufOffs[clipping];
+		_vm->_bompMaskPitch = _vm->_realWidth / 8;
+		_vm->drawBomp(&bdd, 0, bdd.dataptr, decode_mode, 1);
+	} else {
+		_vm->drawBomp(&bdd, 0, bdd.dataptr, decode_mode, 0);
 	}
+
+	_vm->_bompActorPalletePtr = NULL;
 }
 
 void AkosRenderer::akos16SetupBitReader(byte *src) {
@@ -1195,7 +1148,7 @@
 		akos16SkipData(numskip_before);
 	}
 
-	maskpitch = _numStrips + 1;
+	maskpitch = _numStrips ;
 
 	while (t_height != 0) {
 		akos16DecodeLine(tmp_buf, t_width, dir);
@@ -1286,7 +1239,7 @@
 
 	if (!mirror) {
 		dir = -1;
-    
+
     int tmp_skip_x = skip_x;
     skip_x = _width-1-cur_x;
     cur_x = _width-1-tmp_skip_x;
@@ -1331,7 +1284,7 @@
 	}
 
 	byte * ptr = _vm->_screenStartStrip + _vm->getResourceAddress(rtBuffer, 9) + _vm->gdi._imgBufOffs[clipping];
-	ptr += (_numStrips + 1) * clip_top + (clip_left / 8);
+	ptr += _numStrips * clip_top + (clip_left / 8);
 	akos16DecompressMask(dest, pitch, srcptr, cur_x, out_height, dir, numskip_before, numskip_after, 255, ptr, clip_left / 8);
 }
 

Index: gfx.cpp
===================================================================
RCS file: /cvsroot/scummvm/scummvm/scumm/gfx.cpp,v
retrieving revision 1.49
retrieving revision 1.50
diff -u -d -r1.49 -r1.50
--- gfx.cpp	5 Nov 2002 07:15:31 -0000	1.49
+++ gfx.cpp	6 Nov 2002 07:28:38 -0000	1.50
@@ -3155,137 +3155,294 @@
 	return blend_cache[cache][dest_color];
 }
 
-// param3= clipping
-// param2= mirror
-// param1= never used ?
+int32 Scumm::bompDecodeLineMode0(byte * src, byte * line_buffer, int32 size) {
+	if (size <= 0)
+		return size;
 
-void Scumm::drawBomp(BompDrawData *bd, int param1, byte *dataPtr, int param2, int param3)
-{
-	byte *scale_rows = NULL;
-	byte *scale_cols = NULL;
-	byte *dest = bd->out + bd->y * bd->outwidth, *src;
-	int src_x, src_y, dst_x, dst_y;
-	uint scaled_width, scaled_height;
-	int h = bd->srcheight;
-	byte *mask = NULL;
-	uint i;
+	for (int32 l = 0; l < size; l++) {
+		*(line_buffer++) = *(src++);
+	}
+	return size;
+}
 
-	if (h == 0 || bd->srcwidth == 0)
-		return;
+int32 Scumm::bompDecodeLineMode1(byte * src, byte * line_buffer, int32 size) {
+	int32 t_size = READ_LE_UINT16(src) + 2;
+	if (size <= 0)
+		return t_size;
+	
+	int32 len = size;
+	src += 2;
+	while (len) {
+		byte code = *src++;
+		int32 num = (code >> 1) + 1;
+		if (num > len)
+			num = len;
+		len -= num;
+		if (code & 1) {
+			byte color = *src++;
+			do
+				*line_buffer++ = color;
+			while (--num);
+		} else {
+			do
+				*line_buffer++ = *src++;
+			while (--num);
+		}
+	}
+	return t_size;
+}
 
-	if (bd->scale_x != 255) {
-		scale_rows = (byte *) calloc(bd->srcheight, 1);
-		if (scale_rows == NULL) {
-			warning("drawBomp: out of memory");
+int32 Scumm::bompDecodeLineMode3(byte * src, byte * line_buffer, int32 size) {
+	int32 t_size = READ_LE_UINT16(src) + 2;
+	line_buffer += size;
+	if (size <= 0)
+		return t_size;
+	
+	int32 len = size;
+	src += 2;
+	while (len) {
+		byte code = *src++;
+		int32 num = (code >> 1) + 1;
+		if (num > len)
+			num = len;
+		len -= num;
+		if (code & 1) {
+			byte color = *src++;
+			do
+				*--line_buffer = color;
+			while (--num);
+		} else {
+			do
+				*--line_buffer = *src++;
+			while (--num);
+		}
+	}
+	return t_size;
+}
+
+void Scumm::bompApplyMask(byte * line_buffer, byte * mask_src, byte bits, int32 size) {
+	while(1) {
+		byte tmp = *(mask_src++);
+		do {
+			if (size-- == 0) 
+				return;
+			if (tmp & bits) {
+				*(line_buffer) = 255;
+			}
+			line_buffer++;
+			bits >>= 1;
+		} while	(bits != 0);
+		bits = 128;
+	}
+}
+
+void Scumm::bompApplyShadow0(byte * line_buffer, byte * dst, int32 size) {
+	while(1) {
+		if (size-- == 0)
 			return;
+		byte tmp = *(line_buffer++);
+		if (tmp != 255) {
+			*(dst) = tmp;
 		}
+		dst++;
 	}
+}
 
-	if (bd->scale_y != 255) {	
-		scale_cols = (byte *) calloc(bd->srcwidth, 1);
-		if (scale_cols == NULL) {
-			warning("drawBomp: out of memory");
-			if (scale_rows)
-				free(scale_rows);
+void Scumm::bompApplyShadow1(byte * line_buffer, byte * dst, int32 size) {
+	while(1) {
+		if (size-- == 0)
 			return;
+		byte tmp = *(line_buffer++);
+		if (tmp != 255) {
+			if (tmp == 13) {
+				tmp = _shadowPalette[*(dst)];
+			}
+			*(dst) = tmp;
 		}
+		dst++;
 	}
+}
 
-	// We take charset masking into consideration, because otherwise the
-	// inventory window in The Dig may overwrite text.
+void Scumm::bompApplyShadow3(byte * line_buffer, byte * dst, int32 size) {
+	while(1) {
+		if (size-- == 0)
+			return;
+		byte tmp = *(line_buffer++);
+		if (tmp != 255) {
+			if (tmp < 8) {
+				tmp = _shadowPalette[*(dst) + (tmp << 8)];
+			}
+			*(dst) = tmp;
+		}
+		dst++;
+	}
+}
 
-	mask = getResourceAddress(rtBuffer, 9) + _screenStartStrip;
-	
-	// Select which rows and columns from the original to show in the
-	// scaled version of the image. This is a pretty stupid way of scaling
-	// images, but it will have to do for now.
+void Scumm::bompApplyActorPalette(byte * line_buffer, int32 size) {
+	if (_bompActorPalletePtr != 0) {
+		*(_bompActorPalletePtr + 255) = 255;
+		while(1) {
+			if (size-- == 0)
+				break;
+			*(line_buffer++) = *(_bompActorPalletePtr + *(line_buffer));
+		}
+	}
+}
 
-	if (bd->scale_x < 255) {
-		scaled_width = (bd->srcwidth * bd->scale_x) / 255;
-		for (i = 0; i < scaled_width; i++)
-			scale_cols[(i * 255) / bd->scale_x] = 1;
+void Scumm::bompScaleFuncX(byte * line_buffer, byte * scalling_x_ptr, byte skip, int32 size) {
+	byte * line_ptr1 = line_buffer;
+	byte * line_ptr2 = line_buffer;
+
+	byte tmp = *(scalling_x_ptr++);
+
+	while (size--) {
+		if ((skip & tmp) == 0) {
+			*(line_ptr1++) = *(line_ptr2);
+		}
+		line_ptr2++;
+		skip >>= 1;
+		if (skip == 0) {
+			skip = 128;
+			tmp = *(scalling_x_ptr++);
+		}
 	}
+}
 
-	if (bd->scale_y < 255) {
-		scaled_height = (bd->srcheight * bd->scale_y) / 255;
-		for (i = 0; i < scaled_height; i++)
-			scale_rows[(i * 255) / bd->scale_y] = 1;
+void Scumm::drawBomp(BompDrawData * bd, int param1, byte * data_ptr, int decode_mode, int mask) {
+	byte skip_y = 128, skip_y_new;
+	byte bits, tmp;
+	int32 clip_left, clip_right, clip_top, clip_bottom, tmp_x, tmp_y;
+	byte * mask_out;
+
+	if (bd->x < 0) {
+		clip_left = -bd->x;
+	} else {
+		clip_left = 0;
 	}
 
-	// FIXME: Be more intelligent about clearing the blend cache. It
-	// should be possible to clear it only for the parts of the palette
-	// that have changed since the last time.
+	if (bd->y < 0) {
+		clip_top = -bd->y;
+	} else {
+		clip_top = 0;
+	}
 
-	clear_blend_cache();
+	clip_right = bd->srcwidth - clip_left;
+	tmp_x = bd->x + bd->srcwidth;
+	if (tmp_x > bd->outwidth) {
+		clip_right -= tmp_x - bd->outwidth;
+	}
 
-	dest += bd->x;
-	src = bd->dataptr;
+	clip_bottom = bd->srcheight;
+	tmp_y = bd->y + bd->srcheight;
+	if (tmp_y > bd->outheight) {
+		clip_bottom -= tmp_y - bd->outheight;
+	}
 
-	for (src_y = 0, dst_y = bd->y; src_y < bd->srcheight; src_y++) {
-		byte code, color;
-		uint len, num;
-		byte *d = dest;
+	byte * src = bd->dataptr;
+	byte * dst = bd->out + bd->y * bd->outwidth + bd->x + clip_left;
 
-		if ((dst_y < 0 || dst_y >= bd->outheight) || (bd->scale_y != 255 && !scale_rows[src_y])) {
-			src += READ_LE_UINT16(src) + 2;
-			continue;
+	if (mask == 1) {
+		mask_out = _bompMaskPtr + (bd->y * _bompMaskPitch) + ((bd->x + clip_left) >> 3);
+		bits = 128 >> ((bd->x + clip_left) & 7);
+	}
+
+	if (mask == 3) {
+		if (_bompScallingYPtr != NULL) {
+			skip_y_new = *(_bompScallingYPtr++);
 		}
 
-		len = bd->srcwidth;
-		src_x = 0;
-		dst_x = bd->x;
-		src += 2;
-		
-		while (src_x < bd->srcwidth) {
-			code = *src++;
-			num = (code >> 1) + 1;
-			if (num > len)
-				num = len;
-			len -= num;
-			if (code & 1) {
-				color = *src++;
-				for (i = 0; i < num; i++) {
-					if (bd->scale_x == 255 || scale_cols[src_x]) {
-						if (dst_x >= 0 && dst_x < bd->outwidth) {
-							if (!(*(mask + dst_y * gdi._numStrips + (dst_x >> 3)) & revBitMask[dst_x & 7]))
-							
-								*d = blend(_currentPalette, color, *d);
-						}
-						d++;
-						dst_x++;
-					}
-					src_x++;
-				}
-			} else {
-				for (i = 0; i < num; i++) {
-					if (bd->scale_x == 255 || scale_cols[src_x]) {
-						if (dst_x >= 0 && dst_x < bd->outwidth)
-							if (!(*(mask + dst_y * gdi._numStrips + (dst_x >> 3)) & revBitMask[dst_x & 7]))
-								*d = blend(_currentPalette, src[i], *d);
-						d++;
-						dst_x++;
-					}
-					src_x++;
+		if ((clip_right + clip_left) > _bompScaleRight) {
+			clip_right = _bompScaleRight - clip_left;
+		}
+
+		if (clip_bottom > _bompScaleBottom) {
+			clip_bottom = _bompScaleBottom;
+		}
+	}
+
+	if ((clip_right <= 0) || (clip_bottom <= 0))
+		return;
+
+	int32 pos_y = 0;
+
+	byte line_buffer[1024];
+
+	byte * line_ptr = (byte*)&line_buffer + clip_left;
+
+	while(1) {
+		switch(decode_mode) {
+		case 0:
+			{
+				src += bompDecodeLineMode0(src, (byte*)&line_buffer, bd->srcwidth);
+				break;
+			}
+		case 1:
+			{
+				src += bompDecodeLineMode1(src, (byte*)&line_buffer, bd->srcwidth);
+				break;
+			}
+		case 3:
+			{
+				src += bompDecodeLineMode3(src, (byte*)&line_buffer, bd->srcwidth);
+				break;
+			}
+		}
+
+		if (mask == 3) {
+			if (bd->scale_y != 255) {
+				tmp = skip_y_new & skip_y;
+				skip_y >>= 1;
+				if (skip_y == 0) {
+					skip_y = 128;
+					skip_y_new = *(_bompScallingYPtr++);
 				}
-				src += num;
+
+				if (tmp != 0) 
+					continue;
+			}
+
+			if (bd->scale_x != 255) {
+				bompScaleFuncX((byte*)&line_buffer, _bompScallingXPtr, 128, bd->srcwidth);
 			}
 		}
-		dest += bd->outwidth;
-		dst_y++;
-		
-	}
 
-	if (scale_rows)
-		free(scale_rows);
-	if (scale_cols)
-		free(scale_cols);
-	CHECK_HEAP;
-}
+		if (clip_top-- > 0)
+			goto labelBompSkip;
 
+		if (mask == 1) {
+			bompApplyMask(line_ptr, mask_out, bits, clip_right);
+		}
 
-/* Yazoo: This function create the specialPalette used for semi-transparency in SamnMax */
+		bompApplyActorPalette(line_ptr, clip_right);
+
+		switch(_bompShadowMode) {
+		case 0:
+			{
+				bompApplyShadow0(line_ptr, dst, clip_right);
+				break;
+			}
+		case 1:
+			{
+				bompApplyShadow1(line_ptr, dst, clip_right);
+				break;
+			}
+		case 3:
+			{
+				bompApplyShadow3(line_ptr, dst, clip_right);
+				break;
+			}
+		}
 
+labelBompSkip:
+		mask_out += _bompMaskPitch;
+		pos_y++;
+		dst += bd->outwidth;
+		if (pos_y >= clip_bottom)
+			break;
+	}
+}
 
+/* Yazoo: This function create the specialPalette used for semi-transparency in SamnMax */
 void Scumm::createSpecialPalette(int16 a, int16 b, int16 c, int16 d, int16 e, int16 colorMin,
 																 int16 colorMax)
 {

Index: object.cpp
===================================================================
RCS file: /cvsroot/scummvm/scummvm/scumm/object.cpp,v
retrieving revision 1.8
retrieving revision 1.9
diff -u -d -r1.8 -r1.9
--- object.cpp	27 Oct 2002 09:06:20 -0000	1.8
+++ object.cpp	6 Nov 2002 07:28:39 -0000	1.9
@@ -1248,13 +1248,154 @@
 	bdd.dataptr = bomp + 10;
 	bdd.x = eo->posX;
 	bdd.y = eo->posY;
-	bdd.scale_x = (unsigned char)eo->scaleX;
-	bdd.scale_y = (unsigned char)eo->scaleY;
+	bdd.scale_x = (byte)eo->scaleX;
+	bdd.scale_y = (byte)eo->scaleY;
+
+	byte bomp_scalling_x[64], bomp_scalling_y[64];
+
+	_bompShadowMode = 0;
+
+	if ((bdd.scale_x != 255) || (bdd.scale_y != 255)) {
+		_bompScallingXPtr = (byte*)&bomp_scalling_x;
+		_bompScallingYPtr = (byte*)&bomp_scalling_y;
+		_bompScaleRight = setupBompScale(_bompScallingXPtr, bdd.srcwidth, bdd.scale_x);
+		_bompScaleBottom = setupBompScale(_bompScallingYPtr, bdd.srcheight, bdd.scale_y);
+		drawBomp(&bdd, 0, bdd.dataptr, 1, 3);
+	}	else {
+		_bompShadowMode = eo->mode;
+		drawBomp(&bdd, 0, bdd.dataptr, 1, 0);
+	}
+
+	_bompShadowMode = 0;
+	_bompScallingXPtr = NULL;
+	_bompScallingYPtr = NULL;
+	_bompScaleRight = 0;
+	_bompScaleBottom = 0;
 
-	drawBomp(&bdd, 0, bdd.dataptr, 1, 0);
 	updateDirtyRect(vs->number, bdd.x, bdd.x + bdd.srcwidth, bdd.y, bdd.y + bdd.srcheight, 0);
 }
 
+byte _bompScaleTable[] =	{
+    0, 128,  64, 192,  32, 160,  96, 224,
+   16, 144,  80, 208,  48, 176, 112, 240,
+    8, 136,  72, 200,  40, 168, 104, 232,
+   24, 152,  88, 216,  56, 184, 120, 248,
+    4, 132,  68, 196,  36, 164, 100, 228,
+   20, 148,  84, 212,  52, 180, 116, 244,
+   12, 140,  76, 204,  44, 172, 108, 236,
+   28, 156,  92, 220,  60, 188, 124, 252,
+    2, 130,  66, 194,  34, 162,  98, 226,
+   18, 146,  82, 210,  50, 178, 114, 242,
+   10, 138,  74, 202,  42, 170, 106, 234,
+   26, 154,  90, 218,  58, 186, 122, 250,
+    6, 134,  70, 198,  38, 166, 102, 230,
+   22, 150,  86, 214,  54, 182, 118, 246,
+   14, 142,  78, 206,  46, 174, 110, 238,
+   30, 158,  94, 222,  62, 190, 126, 254,
+    1, 129,  65, 193,  33, 161,  97, 225,
+   17, 145,  81, 209,  49, 177, 113, 241,
+    9, 137,  73, 201,  41, 169, 105, 233,
+   25, 153,  89, 217,  57, 185, 121, 249,
+    5, 133,  69, 197,  37, 165, 101, 229,
+   21, 149,  85, 213,  53, 181, 117, 245,
+   13, 141,  77, 205,  45, 173, 109, 237,
+   29, 157,  93, 221,  61, 189, 125, 253,
+    3, 131,  67, 195,  35, 163,  99, 227,
+   19, 147,  83, 211,  51, 179, 115, 243,
+   11, 139,  75, 203,  43, 171, 107, 235,
+   27, 155,  91, 219,  59, 187, 123, 251,
+    7, 135,  71, 199,  39, 167, 103, 231,
+   23, 151,  87, 215,  55, 183, 119, 247,
+   15, 143,  79, 207,  47, 175, 111, 239,
+   31, 159,  95, 223,  63, 191, 127, 255,
+};
+
+byte _bompBitsTable[] = {
+  8, 7, 7, 6, 7, 6, 6, 5, 7, 6, 6, 5, 6, 5, 5, 4,
+  7, 6, 6, 5, 6, 5, 5, 4, 6, 5, 5, 4, 5, 4, 4, 3,
+  7, 6, 6, 5, 6, 5, 5, 4, 6, 5, 5, 4, 5, 4, 4, 3,
+  6, 5, 5, 4, 5, 4, 4, 3, 5, 4, 4, 3, 4, 3, 3, 2,
+  7, 6, 6, 5, 6, 5, 5, 4, 6, 5, 5, 4, 5, 4, 4, 3,
+  6, 5, 5, 4, 5, 4, 4, 3, 5, 4, 4, 3, 4, 3, 3, 2,
+  6, 5, 5, 4, 5, 4, 4, 3, 5, 4, 4, 3, 4, 3, 3, 2,
+  5, 4, 4, 3, 4, 3, 3, 2, 4, 3, 3, 2, 3, 2, 2, 1,
+  7, 6, 6, 5, 6, 5, 5, 4, 6, 5, 5, 4, 5, 4, 4, 3,
+  6, 5, 5, 4, 5, 4, 4, 3, 5, 4, 4, 3, 4, 3, 3, 2,
+  6, 5, 5, 4, 5, 4, 4, 3, 5, 4, 4, 3, 4, 3, 3, 2,
+  5, 4, 4, 3, 4, 3, 3, 2, 4, 3, 3, 2, 3, 2, 2, 1,
+  6, 5, 5, 4, 5, 4, 4, 3, 5, 4, 4, 3, 4, 3, 3, 2,
+  5, 4, 4, 3, 4, 3, 3, 2, 4, 3, 3, 2, 3, 2, 2, 1,
+  5, 4, 4, 3, 4, 3, 3, 2, 4, 3, 3, 2, 3, 2, 2, 1,
+  4, 3, 3, 2, 3, 2, 2, 1, 3, 2, 2, 1, 2, 1, 1, 0,
+};
+
+int32 Scumm::setupBompScale(byte * scalling, int32 size, byte scale) {
+	uint32 tmp;
+	int32 count = (size + 7) >> 3;
+	byte * tmp_ptr = _bompScaleTable + (256 - (size >> 1));
+	byte * tmp_scalling = scalling;
+	byte a = 0;
+
+	while((count--) != 0) {
+		tmp = *(tmp_ptr + 3);
+		a <<= 1;
+		if (scale < tmp) {
+			a |= 1;
+		}
+		tmp = *(tmp_ptr + 2);
+		a <<= 1;
+		if (scale < tmp) {
+			a |= 1;
+		}
+		tmp = *(tmp_ptr + 1);
+		a <<= 1;
+		if (scale < tmp) {
+			a |= 1;
+		}
+		tmp = *(tmp_ptr + 0);
+		a <<= 1;
+		if (scale < tmp) {
+			a |= 1;
+		}
+		tmp_ptr += 4;
+
+		tmp = *(tmp_ptr + 3);
+		a <<= 1;
+		if (scale < tmp) {
+			a |= 1;
+		}
+		tmp = *(tmp_ptr + 2);
+		a <<= 1;
+		if (scale < tmp) {
+			a |= 1;
+		}
+		tmp = *(tmp_ptr + 1);
+		a <<= 1;
+		if (scale < tmp) {
+			a |= 1;
+		}
+		tmp = *(tmp_ptr + 0);
+		a <<= 1;
+		if (scale < tmp) {
+			a |= 1;
+		}
+		tmp_ptr += 4;
+
+		*(tmp_scalling++) = a;
+	}
+	if ((size & 7) != 0) {
+		*(tmp_scalling - 1) |= revBitMask[size & 7];
+	}
+
+	count = (size + 7) >> 3;
+	byte ret_value = 0;
+	while((count--) != 0) {
+		ret_value += *(*(scalling++) + _bompBitsTable);
+	}
+
+	return ret_value;
+}
+
 void Scumm::removeBlastObjects()
 {
 	BlastObject *eo;
@@ -1298,8 +1439,8 @@
 
 	if (left_strip < 0)
 		left_strip = 0;
-	if (right_strip >= 240)
-		right_strip = 240;
+	if (right_strip >= 409)
+		right_strip = 409;
 
 	for (i = left_strip; i <= right_strip; i++)
 		gdi.resetBackground(top, bottom, i);

Index: scumm.h
===================================================================
RCS file: /cvsroot/scummvm/scummvm/scumm/scumm.h,v
retrieving revision 1.53
retrieving revision 1.54
diff -u -d -r1.53 -r1.54
--- scumm.h	5 Nov 2002 10:36:30 -0000	1.53
+++ scumm.h	6 Nov 2002 07:28:39 -0000	1.54
@@ -778,7 +778,17 @@
 	void drawRoomObjects(int arg);
 	void drawRoomObject(int i, int arg);
 	void drawBox(int x, int y, int x2, int y2, int color);
-	void drawBomp(BompDrawData *bd, int param1, byte *dataPtr, int param2, int param3);
+	void drawBomp(BompDrawData * bd, int param1, byte *data_ptr, int decode_mode, int mask);
+	int32 setupBompScale(byte * scalling, int32 size, byte scale);
+	void bompScaleFuncX(byte * line_buffer, byte * scalling_x_ptr, byte skip, int32 size);
+	int32 bompDecodeLineMode0(byte * src, byte * line_buffer, int32 size);
+	int32 bompDecodeLineMode1(byte * src, byte * line_buffer, int32 size);
+	int32 bompDecodeLineMode3(byte * src, byte * line_buffer, int32 size);
+	void bompApplyMask(byte * line_buffer, byte * mask_out, byte bits, int32 size);
+	void bompApplyShadow0(byte * line_buffer, byte * dst, int32 size);
+	void bompApplyShadow1(byte * line_buffer, byte * dst, int32 size);
+	void bompApplyShadow3(byte * line_buffer, byte * dst, int32 size);
+	void bompApplyActorPalette(byte * line_buffer, int32 size);
 
 	void restoreBG(int left, int top, int right, int bottom);
 	void redrawBGStrip(int start, int num);	
@@ -865,13 +875,20 @@
 	void removeBlastObjects();
 	void removeBlastObject(BlastObject *eo);
 
+	uint16 _bompShadowMode;
+	int32 _bompScaleRight, _bompScaleBottom;
+	byte * _bompScallingXPtr, * _bompScallingYPtr;
+	byte * _bompMaskPtr;
+	int32 _bompMaskPitch;
+	byte * _bompActorPalletePtr;
+
 	int _drawObjectQueNr;
 	byte _drawObjectQue[200];
 	byte _palManipStart, _palManipEnd;
 	uint16 _palManipCounter;
 	byte *_palManipPalette;
 	byte *_palManipIntermediatePal;
-	uint32 gfxUsageBits[240];
+	uint32 gfxUsageBits[409];
 	byte *_shadowPalette;
 	int _shadowPaletteSize;
 	byte _currentPalette[0x300];





More information about the Scummvm-git-logs mailing list