/* ScummVM - Graphic Adventure Engine
 *
 * ScummVM is the legal property of its developers, whose names
 * are too numerous to list here. Please refer to the COPYRIGHT
 * file distributed with this source distribution.
 *
 * Additional copyright for this file:
 * Copyright (C) 1999-2000 Revolution Software Ltd.
 * This code is based on source code created by Revolution Software,
 * used with permission.
 *
 * 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/>.
 *
 */

#include "engines/icb/common/px_common.h"
#include "engines/icb/global_objects.h"
#include "engines/icb/p4_generic_pc.h"

namespace ICB {

// This type is used by General_quad_draw_24_32().
typedef struct { int32 nX, nY; } Span;

// This function is used only inside this file.
static void RawSpriteDraw(uint8 *pSurfaceBitmap, uint32 nPitch, uint32 nSurfaceWidth, uint32 nSurfaceHeight, _pxSprite *pSprite, uint8 *pPalette, int32 nX, int32 nY,
						  uint32 *nTransparencyRef, uint8 nOpacity);

void Draw_horizontal_line(int32 xx, int32 yy, uint32 len, _rgb *pen, uint8 *ad, uint32 pitch) {
	// viewport coordinates
	// 640*480 screen
	// 24 or 32but colour

	uint32 j;

	// check top and bottom
	if (yy < 0)
		return;
	if (yy > 479)
		return;

	// line totaly off left
	if ((int32)(xx + len) < 0)
		return;

	// line totally off right
	if (xx > 639)
		return;

	// clip left
	if (xx < 0) {
		len -= (0 - xx); // 0 - -5 == 5 so len=len-5
		xx = 0;
	}

	// clip right
	if ((xx + len) > 639) {
		len -= ((xx + len) - 639);
	}

	// move to y
	ad += (yy * pitch);

	//	move to x
	ad += (xx * 4);

	for (j = 0; j < len; j++) {
		*(ad++) = pen->blue;
		*(ad++) = pen->green;
		*(ad++) = pen->red;
		ad++;
	}
}

void Draw_vertical_line(int32 xx, int32 yy, uint32 len, _rgb *pen, uint8 *ad, uint32 pitch) {
	// viewport coordinates
	// 640*480 screen
	// 24 or 32but colour

	uint32 j;

	// check left/right
	if (xx < 0)
		return;
	if (xx > 639)
		return;

	// line totaly off top
	if ((int32)(yy + len) < 0)
		return;

	// line totally off bottom
	if (yy > 479)
		return;

	// clip top
	if (yy < 0) {
		len -= (0 - yy); // 0 - -5 == 5 so len=len-5
		yy = 0;
	}

	// clip bottom
	if ((yy + len) > 479) {
		len -= ((yy + len) - 479);
	}

	// move to y
	ad += (yy * pitch);

	// ove to x
	ad += (xx * 4);

	for (j = 0; j < len; j++) {
		*(ad) = pen->blue;
		*(ad + 1) = pen->green;
		*(ad + 2) = pen->red;
		ad += pitch;
	}
}

void Fill_rect(int32 x, int32 y, int32 x2, int32 y2, uint32 pen, int32 /*z*/) {
	// put a filled rectangle on the screen
	// backbuffer must be unlocked

	LRECT blank;

	// completely off screen
	if ((x2 <= 0) || (x >= 640) || (y >= 480) || (y2 <= 0))
		return;

	// clip
	if (x < 0)
		x = 0;

	if (x2 > 640)
		x2 = 640;

	if (y < 0)
		y = 0;

	if (y2 > 480)
		y2 = 480;

	// setup LRECT for bottom line of the screen
	blank.left = x;
	blank.right = x2;
	blank.top = y;
	blank.bottom = y2;

	surface_manager->Blit_fillfx(working_buffer_id, &blank, pen);
}

void General_draw_line_24_32(int16 x0, int16 y0, int16 x1, int16 y1, _rgb *colour, uint8 *myScreenBuffer, uint32 pitch, int32 surface_width, int32 surface_height) {
	// Uses Bressnham's incremental algorithm!
	// we pass a colour
	// we pass the surface base
	// assume 640*480

	int32 dx, dy;
	int32 dxmod, dymod;
	int32 ince, incne;
	int32 d;
	int32 x, y;
	int32 addTo;
	uint32 BYTEWIDE;
	uint32 vram = 4;

	//#define  RENDERWIDE  640
	//#define  RENDERDEEP  480
	BYTEWIDE = pitch;

	// Make sure we're going from left to right
	if (x1 < x0) {
		x = x1;
		x1 = x0;
		x0 = (int16)x;
		y = y1;
		y1 = y0;
		y0 = (int16)y;
	}
	dx = x1 - x0;
	dy = y1 - y0;

	if (dx < 0)
		dxmod = -dx;
	else
		dxmod = dx;

	if (dy < 0)
		dymod = -dy;
	else
		dymod = dy;

	if (dxmod >= dymod) {
		if (dy > 0) {
			d = 2 * dy - dx;
			ince = 2 * dy;
			incne = 2 * (dy - dx);
			x = x0;
			y = y0;
			if ((x >= 0) && (x < surface_width) && (y >= 0) && (y < surface_height)) {
				myScreenBuffer[y * BYTEWIDE + (x * vram)] = colour->blue;
				myScreenBuffer[y * BYTEWIDE + (x * vram) + 1] = colour->green;
				myScreenBuffer[y * BYTEWIDE + (x * vram) + 2] = colour->red;
			}

			while (x < x1) {
				if (d <= 0) {
					d += ince;
					x += 1;
				} else {
					d += incne;
					x += 1;
					y += 1;
				}
				if ((x >= 0) && (x < surface_width) && (y >= 0) && (y < surface_height)) {
					myScreenBuffer[y * BYTEWIDE + (x * vram)] = colour->blue;
					myScreenBuffer[y * BYTEWIDE + (x * vram) + 1] = colour->green;
					myScreenBuffer[y * BYTEWIDE + (x * vram) + 2] = colour->red;
				}
			}
		} else {
			addTo = y0;
			y0 = 0;
			y1 = (int16)(y1 - addTo);
			y1 = (int16)-y1;
			dy = y1 - y0;

			d = 2 * dy - dx;
			ince = 2 * dy;
			incne = 2 * (dy - dx);
			x = x0;
			y = y0;
			if ((x >= 0) && (x < surface_width) && (addTo - y >= 0) && (addTo - y < surface_height)) {
				// myScreenBuffer[(addTo - y) * surface_width + x] = colour;

				myScreenBuffer[(addTo - y) * BYTEWIDE + (x * vram)] = colour->blue;
				myScreenBuffer[(addTo - y) * BYTEWIDE + ((x * vram) + 1)] = colour->green;
				myScreenBuffer[(addTo - y) * BYTEWIDE + ((x * vram) + 2)] = colour->red;
			}

			while (x < x1) {
				if (d <= 0) {
					d += ince;
					x += 1;
				} else {
					d += incne;
					x += 1;
					y += 1;
				}
				if ((x >= 0) && (x < surface_width) && (addTo - y >= 0) && (addTo - y < surface_height)) {
					// myScreenBuffer[(addTo - y) * surface_width + x] = colour;

					myScreenBuffer[(addTo - y) * BYTEWIDE + (x * vram)] = colour->blue;
					myScreenBuffer[(addTo - y) * BYTEWIDE + ((x * vram) + 1)] = colour->green;
					myScreenBuffer[(addTo - y) * BYTEWIDE + ((x * vram) + 2)] = colour->red;
				}
			}
		}
	} else {
		// OK, y is now going to be the single increment.
		//  Ensure the line is going top to bottom
		if (y1 < y0) {
			x = x1;
			x1 = x0;
			x0 = (int16)x;
			y = y1;
			y1 = y0;
			y0 = (int16)y;
		}
		dx = x1 - x0;
		dy = y1 - y0;

		if (dx > 0) {
			d = 2 * dx - dy;
			ince = 2 * dx;
			incne = 2 * (dx - dy);
			x = x0;
			y = y0;
			if ((x >= 0) && (x < surface_width) && (y >= 0) && (y < surface_height)) {
				myScreenBuffer[y * BYTEWIDE + (x * vram)] = colour->blue;
				myScreenBuffer[y * BYTEWIDE + (x * vram) + 1] = colour->green;
				myScreenBuffer[y * BYTEWIDE + (x * vram) + 2] = colour->red;
			}
			while (y < y1) {
				if (d <= 0) {
					d += ince;
					y += 1;
				} else {
					d += incne;
					x += 1;
					y += 1;
				}
				if ((x >= 0) && (x < surface_width) && (y >= 0) && (y < surface_height)) {
					myScreenBuffer[y * BYTEWIDE + (x * vram)] = colour->blue;
					myScreenBuffer[y * BYTEWIDE + (x * vram) + 1] = colour->green;
					myScreenBuffer[y * BYTEWIDE + (x * vram) + 2] = colour->red;
				}
			}
		} else {
			addTo = x0;
			x0 = 0;
			x1 = (int16)(x1 - addTo);
			x1 = (int16)-x1;
			dx = x1 - x0;

			d = 2 * dx - dy;
			ince = 2 * dx;
			incne = 2 * (dx - dy);
			x = x0;
			y = y0;
			if ((addTo - x >= 0) && (addTo - x < surface_width) && (y >= 0) && (y < surface_height)) {
				// myScreenBuffer[y * surface_width + addTo - x] = colour;

				myScreenBuffer[y * BYTEWIDE + ((addTo - x) * vram)] = colour->blue;
				myScreenBuffer[y * BYTEWIDE + (((addTo - x) * vram) + 1)] = colour->green;
				myScreenBuffer[y * BYTEWIDE + (((addTo - x) * vram) + 2)] = colour->red;
			}

			while (y < y1) {
				if (d <= 0) {
					d += ince;
					y += 1;
				} else {
					d += incne;
					x += 1;
					y += 1;
				}
				if ((addTo - x >= 0) && (addTo - x < surface_width) && (y >= 0) && (y < surface_height)) {
					// myScreenBuffer[y * surface_width + addTo - x] = colour;

					myScreenBuffer[y * BYTEWIDE + ((addTo - x) * vram)] = colour->blue;
					myScreenBuffer[y * BYTEWIDE + (((addTo - x) * vram) + 1)] = colour->green;
					myScreenBuffer[y * BYTEWIDE + (((addTo - x) * vram) + 2)] = colour->red;
				}
			}
		}
	}
}

void AdditiveGouraudLine(int16 x0, int16 y0, _rgb c0, int16 x1, int16 y1, _rgb c1, uint32 surface_id) {
	// Uses Bressnham's incremental algorithm!
	// We have a start colour and an end colour
	int32 dx, dy;
	int32 dxmod, dymod;
	int32 ince, incne;
	int32 d;
	int32 x, y;
	int32 addTo;

	uint8 *surface = (uint8 *)surface_manager->Lock_surface(surface_id);
	uint32 pitch = surface_manager->Get_pitch(surface_id);
	int32 surface_width = surface_manager->Get_width(surface_id);
	int32 surface_height = surface_manager->Get_height(surface_id);

	// Make sure we're going from left to right
	if (x1 < x0) {
		x = x1;
		x1 = x0;
		x0 = (int16)x;
		y = y1;
		y1 = y0;
		y0 = (int16)y;

		_rgb tC = c1;
		c1 = c0;
		c0 = tC;
	}
	dx = x1 - x0;
	dy = y1 - y0;

	if (dx < 0)
		dxmod = -dx;
	else
		dxmod = dx;

	if (dy < 0)
		dymod = -dy;
	else
		dymod = dy;

	if (dxmod >= dymod) {
		if (dy > 0) {
			d = 2 * dy - dx;
			ince = 2 * dy;
			incne = 2 * (dy - dx);
			x = x0;
			y = y0;
			uint8 r = c0.red;
			uint8 g = c0.green;
			uint8 b = c0.blue;
			int32 dr = (dx) ? (c1.red - c0.red) / dx : 0;
			int32 dg = (dx) ? (c1.green - c0.green) / dx : 0;
			int32 db = (dx) ? (c1.blue - c0.blue) / dx : 0;
			uint32 offset = y * pitch + (x << 2);
			if ((x >= 0) && (x < surface_width) && (y >= 0) && (y < surface_height)) {
				surface[offset] = ((surface[offset] + b) > 255) ? (uint8)255 : (uint8)(surface[offset] + b);
				surface[offset + 1] = ((surface[offset] + g) > 255) ? (uint8)255 : (uint8)(surface[offset + 1] + g);
				surface[offset + 2] = ((surface[offset] + r) > 255) ? (uint8)255 : (uint8)(surface[offset + 2] + r);
			}

			while (x < x1) {
				r = (uint8)(r + dr);
				g = (uint8)(g + dg);
				b = (uint8)(b + db);
				offset += 4;
				x++;

				if (d <= 0) {
					d += ince;
				} else {
					d += incne;
					y++;
					offset += pitch;
				}
				if ((x >= 0) && (x < surface_width) && (y >= 0) && (y < surface_height)) {
					surface[offset] = ((surface[offset] + b) > 255) ? (uint8)255 : (uint8)(surface[offset] + b);
					surface[offset + 1] = ((surface[offset] + g) > 255) ? (uint8)255 : (uint8)(surface[offset + 1] + g);
					surface[offset + 2] = ((surface[offset] + r) > 255) ? (uint8)255 : (uint8)(surface[offset + 2] + r);
				}
			}
		} else {
			addTo = y0;
			y0 = 0;
			y1 = (int16)(y1 - addTo);
			y1 = (int16)-y1;
			dy = y1 - y0;

			d = 2 * dy - dx;
			ince = 2 * dy;
			incne = 2 * (dy - dx);
			x = x0;
			y = y0;
			uint8 r = c0.red;
			uint8 g = c0.green;
			uint8 b = c0.blue;
			int32 dr = (dx) ? (c1.red - c0.red) / dx : 0;
			int32 dg = (dx) ? (c1.green - c0.green) / dx : 0;
			int32 db = (dx) ? (c1.blue - c0.blue) / dx : 0;

			uint32 offset = (addTo - y) * pitch + (x << 2);
			if ((x >= 0) && (x < surface_width) && (addTo - y >= 0) && (addTo - y < surface_height)) {
				surface[offset] = ((surface[offset] + b) > 255) ? (uint8)255 : (uint8)(surface[offset] + b);
				surface[offset + 1] = ((surface[offset] + g) > 255) ? (uint8)255 : (uint8)(surface[offset + 1] + g);
				surface[offset + 2] = ((surface[offset] + r) > 255) ? (uint8)255 : (uint8)(surface[offset + 2] + r);
			}

			while (x < x1) {
				r = (uint8)(r + dr);
				g = (uint8)(g + dg);
				b = (uint8)(b + db);

				x++;
				offset += 4;
				if (d <= 0) {
					d += ince;
				} else {
					d += incne;
					y++;
					offset -= pitch;
				}
				if ((x >= 0) && (x < surface_width) && (addTo - y >= 0) && (addTo - y < surface_height)) {
					surface[offset] = ((surface[offset] + b) > 255) ? (uint8)255 : (uint8)(surface[offset] + b);
					surface[offset + 1] = ((surface[offset] + g) > 255) ? (uint8)255 : (uint8)(surface[offset + 1] + g);
					surface[offset + 2] = ((surface[offset] + r) > 255) ? (uint8)255 : (uint8)(surface[offset + 2] + r);
				}
			}
		}
	} else {
		// OK, y is now going to be the single increment.
		//  Ensure the line is going top to bottom
		if (y1 < y0) {
			x = x1;
			x1 = x0;
			x0 = (int16)x;
			y = y1;
			y1 = y0;
			y0 = (int16)y;

			_rgb tC = c1;
			c1 = c0;
			c0 = tC;
		}
		dx = x1 - x0;
		dy = y1 - y0;

		if (dx > 0) {
			d = 2 * dx - dy;
			ince = 2 * dx;
			incne = 2 * (dx - dy);
			x = x0;
			y = y0;

			uint8 r = c0.red;
			uint8 g = c0.green;
			uint8 b = c0.blue;
			int32 dr = (dy) ? (c1.red - c0.red) / dy : 0;
			int32 dg = (dy) ? (c1.green - c0.green) / dy : 0;
			int32 db = (dy) ? (c1.blue - c0.blue) / dy : 0;

			uint32 offset = y * pitch + (x << 2);

			if ((x >= 0) && (x < surface_width) && (y >= 0) && (y < surface_height)) {
				surface[offset] = ((surface[offset] + b) > 255) ? (uint8)255 : (uint8)(surface[offset] + b);
				surface[offset + 1] = ((surface[offset] + g) > 255) ? (uint8)255 : (uint8)(surface[offset + 1] + g);
				surface[offset + 2] = ((surface[offset] + r) > 255) ? (uint8)255 : (uint8)(surface[offset + 2] + r);
			}
			while (y < y1) {
				r = (uint8)(r + dr);
				g = (uint8)(g + dg);
				b = (uint8)(b + db);

				offset += pitch;
				y++;
				if (d <= 0) {
					d += ince;
				} else {
					d += incne;
					x++;
					offset += 4;
				}
				if ((x >= 0) && (x < surface_width) && (y >= 0) && (y < surface_height)) {
					surface[offset] = ((surface[offset] + b) > 255) ? (uint8)255 : (uint8)(surface[offset] + b);
					surface[offset + 1] = ((surface[offset] + g) > 255) ? (uint8)255 : (uint8)(surface[offset + 1] + g);
					surface[offset + 2] = ((surface[offset] + r) > 255) ? (uint8)255 : (uint8)(surface[offset + 2] + r);
				}
			}
		} else {
			addTo = x0;
			x0 = 0;
			x1 = (int16)(x1 - addTo);
			x1 = (int16)-x1;
			dx = x1 - x0;

			d = 2 * dx - dy;
			ince = 2 * dx;
			incne = 2 * (dx - dy);
			x = x0;
			y = y0;

			uint8 r = c0.red;
			uint8 g = c0.green;
			uint8 b = c0.blue;
			int32 dr = (dy) ? (c1.red - c0.red) / dy : 0;
			int32 dg = (dy) ? (c1.green - c0.green) / dy : 0;
			int32 db = (dy) ? (c1.blue - c0.blue) / dy : 0;

			uint32 offset = y * pitch + ((addTo - x) << 2);

			if ((addTo - x >= 0) && (addTo - x < surface_width) && (y >= 0) && (y < surface_height)) {
				surface[offset] = ((surface[offset] + b) > 255) ? (uint8)255 : (uint8)(surface[offset] + b);
				surface[offset + 1] = ((surface[offset] + g) > 255) ? (uint8)255 : (uint8)(surface[offset + 1] + g);
				surface[offset + 2] = ((surface[offset] + r) > 255) ? (uint8)255 : (uint8)(surface[offset + 2] + r);
			}

			while (y < y1) {
				r = (uint8)(r + dr);
				g = (uint8)(g + dg);
				b = (uint8)(b + db);

				offset += pitch;
				y++;
				if (d <= 0) {
					d += ince;

				} else {
					d += incne;
					x += 1;
					offset -= 4;
				}
				if ((addTo - x >= 0) && (addTo - x < surface_width) && (y >= 0) && (y < surface_height)) {
					surface[offset] = ((surface[offset] + b) > 255) ? (uint8)255 : (uint8)(surface[offset] + b);
					surface[offset + 1] = ((surface[offset] + g) > 255) ? (uint8)255 : (uint8)(surface[offset + 1] + g);
					surface[offset + 2] = ((surface[offset] + r) > 255) ? (uint8)255 : (uint8)(surface[offset + 2] + r);
				}
			}
		}
	}

	surface_manager->Unlock_surface(surface_id);
}

void BlendedLine(int32 x0, int32 y0, int32 x1, int32 y1, _rgb c, uint32 surface_id) {
	uint8 *surface = (uint8 *)surface_manager->Lock_surface(surface_id);
	uint32 pitch = surface_manager->Get_pitch(surface_id);
	int32 surface_width = surface_manager->Get_width(surface_id);
	int32 surface_height = surface_manager->Get_height(surface_id);

	BlendedLine(x0, y0, x1, y1, c, surface_width, surface_height, pitch, surface);

	surface_manager->Unlock_surface(surface_id);
}

void BlendedLine(int32 x0, int32 y0, int32 x1, int32 y1, _rgb c, int32 surface_width, int32 surface_height, uint32 pitch, uint8 *surface) {
	// Uses Bressnham's incremental algorithm!
	// We have a start colour and an end colour
	int32 dx, dy;
	int32 dxmod, dymod;
	int32 ince, incne;
	int32 d;
	int32 x, y;
	int32 addTo;

	// Make sure we're going from left to right
	if (x1 < x0) {
		x = x1;
		x1 = x0;
		x0 = (int16)x;
		y = y1;
		y1 = y0;
		y0 = (int16)y;
	}
	dx = x1 - x0;
	dy = y1 - y0;

	if (dx < 0)
		dxmod = -dx;
	else
		dxmod = dx;

	if (dy < 0)
		dymod = -dy;
	else
		dymod = dy;

	if (dxmod >= dymod) {
		if (dy > 0) {
			d = 2 * dy - dx;
			ince = 2 * dy;
			incne = 2 * (dy - dx);
			x = x0;
			y = y0;
			uint8 r = c.red;
			uint8 g = c.green;
			uint8 b = c.blue;
			uint32 offset = y * pitch + (x << 2);

			while (x < 0 || y < 0) {
				offset += 4;
				x++;

				if (d <= 0) {
					d += ince;
				} else {
					d += incne;
					y++;
					offset += pitch;
				}
			}

			if (x1 >= surface_width)
				x1 = surface_width - 1;

			while (x < x1) {
				offset += 4;
				x++;

				if (d <= 0) {
					d += ince;
				} else {
					d += incne;
					y++;
					offset += pitch;
				}
				if (y < surface_height) {
					surface[offset] = (uint8)((surface[offset] + b) >> 1);
					surface[offset + 1] = (uint8)((surface[offset + 1] + g) >> 1);
					surface[offset + 2] = (uint8)((surface[offset + 2] + r) >> 1);
				}
			}
		} else {
			addTo = y0;
			y0 = 0;
			y1 = (int16)(y1 - addTo);
			y1 = (int16)-y1;
			dy = y1 - y0;

			d = 2 * dy - dx;
			ince = 2 * dy;
			incne = 2 * (dy - dx);
			x = x0;
			y = y0;
			uint8 r = c.red;
			uint8 g = c.green;
			uint8 b = c.blue;

			uint32 offset = (addTo - y) * pitch + (x << 2);

			while ((x < 0) || ((addTo - y) >= surface_height)) {
				x++;
				offset += 4;
				if (d <= 0) {
					d += ince;
				} else {
					d += incne;
					y++;
					offset -= pitch;
				}
			}

			if (x1 >= surface_width)
				x1 = surface_width - 1;

			while (x < x1) {
				x++;
				offset += 4;
				if (d <= 0) {
					d += ince;
				} else {
					d += incne;
					y++;
					offset -= pitch;
				}
				if ((addTo - y) >= 0) {
					surface[offset] = (uint8)((surface[offset] + b) >> 1);
					surface[offset + 1] = (uint8)((surface[offset + 1] + g) >> 1);
					surface[offset + 2] = (uint8)((surface[offset + 2] + r) >> 1);
				}
			}
		}
	} else {
		// OK, y is now going to be the single increment.
		//  Ensure the line is going top to bottom
		if (y1 < y0) {
			x = x1;
			x1 = x0;
			x0 = (int16)x;
			y = y1;
			y1 = y0;
			y0 = (int16)y;
		}
		dx = x1 - x0;
		dy = y1 - y0;

		if (dx > 0) {
			d = 2 * dx - dy;
			ince = 2 * dx;
			incne = 2 * (dx - dy);
			x = x0;
			y = y0;

			uint8 r = c.red;
			uint8 g = c.green;
			uint8 b = c.blue;
			uint32 offset = y * pitch + (x << 2);

			while ((y < 0) || (x < 0)) {
				offset += pitch;
				++y;
				if (d <= 0) {
					d += ince;
				} else {
					d += incne;
					++x;
					offset += 4;
				}
			}

			if (y1 >= surface_height)
				y1 = surface_height - 1;

			while (y < y1) {
				offset += pitch;
				++y;
				if (d <= 0) {
					d += ince;
				} else {
					d += incne;
					++x;
					offset += 4;
				}
				if (x < surface_width) {
					surface[offset] = (uint8)((surface[offset] + b) >> 1);
					surface[offset + 1] = (uint8)((surface[offset + 1] + g) >> 1);
					surface[offset + 2] = (uint8)((surface[offset + 2] + r) >> 1);
				}
			}
		} else {
			addTo = x0;
			x0 = 0;
			x1 = (int16)(x1 - addTo);
			x1 = (int16)-x1;
			dx = x1 - x0;

			d = 2 * dx - dy;
			ince = 2 * dx;
			incne = 2 * (dx - dy);
			x = x0;
			y = y0;

			uint8 r = c.red;
			uint8 g = c.green;
			uint8 b = c.blue;
			uint32 offset = y * pitch + ((addTo - x) << 2);

			while ((y < 0) || (addTo - x >= surface_width)) {
				offset += pitch;
				++y;
				if (d <= 0) {
					d += ince;

				} else {
					d += incne;
					++x;
					offset -= 4;
				}
			}

			if (y1 >= surface_height)
				y1 = surface_height - 1;

			while (y < y1) {
				offset += pitch;
				y++;
				if (d <= 0) {
					d += ince;

				} else {
					d += incne;
					x += 1;
					offset -= 4;
				}
				if ((addTo - x) >= 0) {
					surface[offset] = (uint8)((surface[offset] + b) >> 1);
					surface[offset + 1] = (uint8)((surface[offset + 1] + g) >> 1);
					surface[offset + 2] = (uint8)((surface[offset + 2] + r) >> 1);
				}
			}
		}
	}
}

void SpriteFrameDraw(uint8 *pSurfaceBitmap,     // IN:  Pointer to the surface's drawing area.
					 uint32 nPitch,             // IN:  Pitch for the surface.
					 uint32 nSurfaceWidth,      // IN:  Width of the surface.
					 uint32 nSurfaceHeight,     // IN:  Height of the surface.
					 _pxBitmap *pBitmap,        // IN:  Pointer to the bitmap to render.
					 uint32 nFrameNumber,       // IN:  Frame to draw.
					 uint32 *pnTransparencyRef, // IN:  Colour to use for transparency.
					 uint8 nOpacity             // IN:  Opacity 0-255 to draw sprite into surface.
					 ) {
	uint8 *pPalette;
	_pxSprite *pSprite;

	// Get to the sprite frame.
	pSprite = (_pxSprite *)((byte *)pBitmap + FROM_LE_32(pBitmap->sprite_offsets[nFrameNumber]));

	// Get the palette pointer.
	pPalette = &pBitmap->palette[0];

	// Now do the actual drawing.
	RawSpriteDraw(pSurfaceBitmap, nPitch, nSurfaceWidth, nSurfaceHeight, pSprite, pPalette, pSprite->x, pSprite->y, pnTransparencyRef, nOpacity);
}

void SpriteXYFrameDraw(uint8 *pSurfaceBitmap,     // IN:  Pointer to the surface's drawing area.
					   uint32 nPitch,             // IN:  Pitch for the surface.
					   uint32 nSurfaceWidth,      // IN:  Width of the surface.
					   uint32 nSurfaceHeight,     // IN:  Height of the surface.
					   _pxBitmap *pBitmap,        // IN:  Pointer to the bitmap to render.
					   int32 nX,                  // IN:  X-position to draw sprite at (relative to the surface).
					   int32 nY,                  // IN:  Y-position to draw sprite at (relative to the surface).
					   uint32 nFrameNumber,       // IN:  Frame to draw.
					   bool8 bCenter,             // IN:  If true, centre the sprite.
					   uint32 *pnTransparencyRef, // IN:  Colour to use for transparency.
					   uint8 nOpacity             // IN:  Opacity 0-255 to draw sprite into surface.
					   ) {
	uint8 *pPalette;
	_pxSprite *pSprite;

	// Get to the sprite frame.
	pSprite = (_pxSprite *)((byte *)pBitmap + FROM_LE_32(pBitmap->sprite_offsets[nFrameNumber]));

	// Work out a new plotting position if it is to be centred.
	if (bCenter) {
		nX -= (pSprite->width >> 1);
		nY -= (pSprite->height >> 1);
	}

	// Get the palette pointer.
	pPalette = &pBitmap->palette[0];

	// Now do the actual drawing.
	RawSpriteDraw(pSurfaceBitmap, nPitch, nSurfaceWidth, nSurfaceHeight, pSprite, pPalette, nX, nY, pnTransparencyRef, nOpacity);
}

void RawSpriteDraw(uint8 *pSurfaceBitmap,    // IN:  Pointer to the surface's drawing area.
				   uint32 nPitch,            // IN:  Pitch for the surface.
				   uint32 nSurfaceWidth,     // IN:  Width of surface in pixels.
				   uint32 nSurfaceHeight,    // IN:  Height of surface in pixels.
				   _pxSprite *pSprite,       // IN:  Pointer to one frame of a sprite.
				   uint8 *pPalette,          // IN:  Pointer to the palette.
				   int32 nX,                 // IN:  X-position to draw sprite at (relative to the surface).
				   int32 nY,                 // IN:  Y-position to draw sprite at (relative to the surface).
				   uint32 *pnTransparentRef, // IN:  Colour to use for transparency.
				   uint8 nOpacity            // IN:  If true, pixels are blended into the surface.
				   ) {
	uint32 x, y;
	uint32 *pSurfaceRowStart32;
	uint8 *pSurfaceRowStart8;
	uint8 *pSpriteData;
	uint8 *pPaletteEntry;
	int32 nSpriteTop, nSpriteLeft;
	int32 nSurfaceTop, nSurfaceLeft;
	uint32 nNumRowsToRender, nNumColumnsToRender;
	uint32 nSurfaceSkipToNextRow, nSpriteSkipToNextRow;
	uint32 nSpriteRowStart;
	uint8 nExistingB, nExistingG, nExistingR;
	uint8 nNewB, nNewG, nNewR;

	// This used to be variable; now it's fixed.
	const uint32 nBytesPerPixel = 4;

	// If the start position of the sprite is below the bottom row of the surface or its end position
	// is before the first row of the surface, there can be nothing to display.
	if ((nY >= (int32)nSurfaceHeight) || ((nY + (int32)pSprite->height) <= 0))
		return;

	// Now do the same check in the horizontal direction.
	if ((nX >= (int32)nSurfaceWidth) || ((nX + (int32)pSprite->width) <= 0))
		return;

	// First work out what proportion of the height of the sprite we have to copy allowing
	// for clipping it where it overlaps the edges of the surface.
	nNumRowsToRender = pSprite->height;

	if (nY < 0) {
		nSurfaceTop = 0;
		nSpriteTop = abs(nY);
		nNumRowsToRender -= nSpriteTop;
	} else {
		nSurfaceTop = nY;
		nSpriteTop = 0;
	}

	if ((nY + pSprite->height) > nSurfaceHeight)
		nNumRowsToRender -= ((nY + pSprite->height) - nSurfaceHeight);

	// Now do the same in the horizontal direction.
	nNumColumnsToRender = pSprite->width;

	if (nX < 0) {
		nSurfaceLeft = 0;
		nSpriteLeft = abs(nX);
		nNumColumnsToRender -= nSpriteLeft;
	} else {
		nSurfaceLeft = nX;
		nSpriteLeft = 0;
	}

	if ((nX + pSprite->width) > nSurfaceWidth)
		nNumColumnsToRender -= ((nX + pSprite->width) - nSurfaceWidth);

	// Get to the sprite data.
	pSpriteData = pSprite->data;

	// Work out the byte in the surface to start drawing at.
	pSurfaceRowStart32 = (uint32 *)(pSurfaceBitmap + (nSurfaceTop * nPitch) + (nBytesPerPixel * nSurfaceLeft));
	nSurfaceSkipToNextRow = (nPitch - (nBytesPerPixel * nNumColumnsToRender)) >> 2;

	// Work out the pixel to start drawing and how much we need to jump when we get to the end of a row.
	nSpriteRowStart = nSpriteTop * pSprite->width + nSpriteLeft;
	nSpriteSkipToNextRow = pSprite->width - nNumColumnsToRender;

	// Check if transparency support is required.
	if (pnTransparentRef) {
		// Check if pixel blending is required.
		if (nOpacity != 255) {
			for (y = 0; y < nNumRowsToRender; ++y) {
				// Now loop for one row of the image.
				for (x = 0; x < nNumColumnsToRender; ++x) {
					// Get the palette index for this pixel of the sprite.
					pPaletteEntry = pPalette + (pSpriteData[nSpriteRowStart++] << 2);

					// Don't print anything if the pixel is transparent.
					if (*((uint32 *)pPaletteEntry) != *pnTransparentRef) {
						// We are doing pixel merging.
						pSurfaceRowStart8 = (uint8 *)pSurfaceRowStart32;

						// Get the existing RGB in the surface.
						nExistingB = *pSurfaceRowStart8;
						nExistingG = *(pSurfaceRowStart8 + 1);
						nExistingR = *(pSurfaceRowStart8 + 2);

						// Get the new RGB.
						nNewB = *pPaletteEntry;
						nNewG = *(pPaletteEntry + 1);
						nNewR = *(pPaletteEntry + 2);

						// Merge the pixels.
						nNewB = (uint8)((((nNewB - nExistingB) * nOpacity) >> 8) + nExistingB);
						nNewG = (uint8)((((nNewG - nExistingG) * nOpacity) >> 8) + nExistingG);
						nNewR = (uint8)((((nNewR - nExistingR) * nOpacity) >> 8) + nExistingR);

						// Write the new colour back to the surface.
						*pSurfaceRowStart8 = (uint8)nNewB;
						*(pSurfaceRowStart8 + 1) = (uint8)nNewG;
						*(pSurfaceRowStart8 + 2) = (uint8)nNewR;
					}

					++pSurfaceRowStart32;
				}

				// We have completed a row; need to jump to the start of the next one.
				pSurfaceRowStart32 += nSurfaceSkipToNextRow;
				nSpriteRowStart += nSpriteSkipToNextRow;
			}
		} else {
			for (y = 0; y < nNumRowsToRender; ++y) {
				// Now loop for one row of the image.
				for (x = 0; x < nNumColumnsToRender; ++x) {
					// Get the palette index for this pixel of the sprite.
					pPaletteEntry = pPalette + (pSpriteData[nSpriteRowStart++] << 2);

					// Don't print anything if the pixel is transparent.
					if (*((uint32 *)pPaletteEntry) != *pnTransparentRef)
						*pSurfaceRowStart32 = *((uint32 *)pPaletteEntry);

					++pSurfaceRowStart32;
				}

				// We have completed a row; need to jump to the start of the next one.
				pSurfaceRowStart32 += nSurfaceSkipToNextRow;
				nSpriteRowStart += nSpriteSkipToNextRow;
			}
		}
	} else {
		// No transparency support required.  Check if pixel blending is required.
		if (nOpacity != 255) {
			// Pixel blending required.
			for (y = 0; y < nNumRowsToRender; ++y) {
				// Now loop for one row of the image.
				for (x = 0; x < nNumColumnsToRender; ++x) {
					// Get the palette index for this pixel of the sprite.
					pPaletteEntry = pPalette + (pSpriteData[nSpriteRowStart++] << 2);

					// We are doing pixel merging.
					pSurfaceRowStart8 = (uint8 *)pSurfaceRowStart32;

					// Get the existing RGB in the surface.
					nExistingB = *pSurfaceRowStart8;
					nExistingG = *(pSurfaceRowStart8 + 1);
					nExistingR = *(pSurfaceRowStart8 + 2);

					// Get the new RGB.
					nNewB = *pPaletteEntry;
					nNewG = *(pPaletteEntry + 1);
					nNewR = *(pPaletteEntry + 2);

					// Merge the pixels.
					nNewB = (uint8)((((nNewB - nExistingB) * nOpacity) >> 8) + nExistingB);
					nNewG = (uint8)((((nNewG - nExistingG) * nOpacity) >> 8) + nExistingG);
					nNewR = (uint8)((((nNewR - nExistingR) * nOpacity) >> 8) + nExistingR);

					// Write the new colour back to the surface.
					*pSurfaceRowStart8 = (uint8)nNewB;
					*(pSurfaceRowStart8 + 1) = (uint8)nNewG;
					*(pSurfaceRowStart8 + 2) = (uint8)nNewR;

					++pSurfaceRowStart32;
				}

				// We have completed a row; need to jump to the start of the next one.
				pSurfaceRowStart32 += nSurfaceSkipToNextRow;
				nSpriteRowStart += nSpriteSkipToNextRow;
			}
		} else {
			// No pixel blending required - just a straight opaque copy.
			for (y = 0; y < nNumRowsToRender; ++y) {
				// Now loop for one row of the image.
				for (x = 0; x < nNumColumnsToRender; ++x) {
					// Get the palette index for this pixel of the sprite.
					pPaletteEntry = pPalette + (pSpriteData[nSpriteRowStart++] << 2);

					// 32-bit opaque copy is a straight assignment.
					*pSurfaceRowStart32++ = *((uint32 *)pPaletteEntry);
				}

				// We have completed a row; need to jump to the start of the next one.
				pSurfaceRowStart32 += nSurfaceSkipToNextRow;
				nSpriteRowStart += nSpriteSkipToNextRow;
			}
		}
	}
}

LRECT ConvertPxBitmapRectToRECT(const _PxBitmapRect &sBitmapRect) {
	LRECT sRect;

	sRect.left = sBitmapRect.nX;
	sRect.right = (sBitmapRect.nX + sBitmapRect.nWidth) - 1;
	sRect.top = sBitmapRect.nY;
	sRect.bottom = (sBitmapRect.nY + sBitmapRect.nHeight) - 1;

	return sRect;
}

void General_poly_draw_24_32(_point *pVerts, int32 nNumVerts, _rgb sColour, bool8 bFill, uint8 *pSurface, int32 nPitch, int32 /*nSurfaceWidth*/, int32 /*nSurfaceHeight*/) {
	int32 i, j;
	int32 x, y;
	int32 nTopVert, nBottomVert, nLeftVert, nRightVert;
	int32 nNextVert;
	int32 nTopY, nBottomY, nSlope, nSpanTopY, nSpanBottomY;
	int32 nX;
	int32 nCount;
	PXreal fTopY, fBottomY, fSlope, fHeight, fWidth, fPrestep;
	Span pSpans[SCREEN_DEPTH];
	Span *pSpan;
	int32 nBytesPerPixel;
	uint8 *pSurfaceAddress;

	nTopVert = 0;
	nBottomVert = 0;
	nX = 0;

	// Some initialisation.
	nBytesPerPixel = 4;
	fTopY = 999999.0f;
	fBottomY = -999999.0f;

	// Find the top and bottom vertices.
	for (i = 0; i < (int32)nNumVerts; ++i) {
		if (pVerts[i].z < fTopY) {
			fTopY = pVerts[i].z;
			nTopVert = i;
		}

		if (pVerts[i].z > fBottomY) {
			fBottomY = pVerts[i].z;
			nBottomVert = i;
		}
	}

	nTopY = (int32)ceil(fTopY);
	nBottomY = (int32)ceil(fBottomY);

	// Polygon has to have a height to be drawn.
	if (nBottomY == nTopY)
		return;

	// Scan out the left edge.
	pSpan = pSpans;
	nLeftVert = nTopVert;

	do {
		nNextVert = nLeftVert - 1;

		if (nNextVert < 0)
			nNextVert = nNumVerts - 1;

		nSpanTopY = (int32)ceil(pVerts[nLeftVert].z);
		nSpanBottomY = (int32)ceil(pVerts[nNextVert].z);

		if (nSpanTopY < nSpanBottomY) {
			fHeight = pVerts[nNextVert].z - pVerts[nLeftVert].z;
			fWidth = pVerts[nNextVert].x - pVerts[nLeftVert].x;
			fSlope = fWidth / fHeight;
			fPrestep = nSpanTopY - pVerts[nLeftVert].z;
			nX = (int32)((pVerts[nLeftVert].x + (fSlope * fPrestep)) * 65536.0f) + ((1 << 16) - 1);
			nSlope = (int32)(fSlope * 65536.0f);

			for (j = nSpanTopY; j < nSpanBottomY; ++j) {
				pSpan->nX = nX >> 16;
				nX += nSlope;
				++pSpan;
			}
		}

		--nLeftVert;
		if (nLeftVert < 0)
			nLeftVert = nNumVerts - 1;

	} while (nLeftVert != nBottomVert);

	// Scan out the right edge
	pSpan = pSpans;
	nRightVert = nTopVert;

	do {
		nNextVert = (nRightVert + 1) % nNumVerts;

		nSpanTopY = (int32)ceil(pVerts[nRightVert].z);
		nSpanBottomY = (int32)ceil(pVerts[nNextVert].z);

		if (nSpanTopY < nSpanBottomY) {
			fHeight = pVerts[nNextVert].z - pVerts[nRightVert].z;
			fWidth = pVerts[nNextVert].x - pVerts[nRightVert].x;
			fSlope = fWidth / fHeight;
			fPrestep = nSpanTopY - pVerts[nRightVert].z;
			nX = (int32)((pVerts[nRightVert].x + (fSlope * fPrestep)) * 65536.0f) + ((1 << 16) - 1);
			nSlope = (int32)(fSlope * 65536.0f);

			for (j = nSpanTopY; j < nSpanBottomY; ++j) {
				pSpan->nY = nX >> 16;
				nX += nSlope;
				++pSpan;
			}
		}

		nRightVert = (nRightVert + 1) % nNumVerts;

	} while (nRightVert != nBottomVert);

	// Draw the spans
	pSpan = pSpans;

	// How we draw depends on the bitmap.
	// Drawing in 32-bit colour depth.  Fill or just outline?
	if (bFill) {
		// Fill the polygon (32-bit colour).
		for (x = nTopY; x < nBottomY; ++x) {
			// Work out the width of the line at this point in the height.
			nCount = pSpan->nY - pSpan->nX;

			if (nCount > 0) {
				// Work out the start address of the row in our target surface.
				pSurfaceAddress = pSurface + nPitch * x;

				// Loop along the row.
				for (y = 0; y < nCount; ++y) {
					// Look up the actual colour.
					*pSurfaceAddress++ = sColour.red;
					*pSurfaceAddress++ = sColour.green;
					*pSurfaceAddress++ = sColour.blue;
					*pSurfaceAddress = 0x00;
				}
			}

			// Move on to the next span we've stored.
			++pSpan;
		}
	} else {
		// Just draw outline (32-bit colour).
		for (x = nTopY; x < nBottomY; ++x) {
			// Work out the width of the line at this point in the height.
			nCount = pSpan->nY - pSpan->nX;

			if (nCount > 0) {
				// Draw left edge.
				pSurfaceAddress = pSurface + nPitch * x;
				*pSurfaceAddress++ = sColour.red;
				*pSurfaceAddress++ = sColour.green;
				*pSurfaceAddress++ = sColour.blue;
				*pSurfaceAddress = 0x00;

				// Draw right edge.
				pSurfaceAddress = (pSurface + nPitch * x) + ((nCount - 1) * nBytesPerPixel);
				*pSurfaceAddress++ = sColour.red;
				*pSurfaceAddress++ = sColour.green;
				*pSurfaceAddress++ = sColour.blue;
				*pSurfaceAddress = 0x00;
			}

			// Move on to the next span we've stored.
			++pSpan;
		}
	}
}

} // End of namespace ICB