1 #include "../stdafx.h"

     2 #include "../gfx.h"

     3 #include "32bpp_base.hpp"

     4 

     5 void *Blitter_32bppBase::MoveTo(const void *video, int x, int y)

     6 {

     7 	return (uint32 *)video + x + y * _screen.pitch;

     8 }

     9 

    10 void Blitter_32bppBase::SetPixel(void *video, int x, int y, uint8 color)

    11 {

    12 	*((uint32 *)video + x + y * _screen.pitch) = LookupColourInPalette(color);

    13 }

    14 

    15 void Blitter_32bppBase::SetPixelIfEmpty(void *video, int x, int y, uint8 color)

    16 {

    17 	uint32 *dst = (uint32 *)video + x + y * _screen.pitch;

    18 	if (*dst == 0) *dst = LookupColourInPalette(color);

    19 }

    20 

    21 void Blitter_32bppBase::DrawRect(void *video, int width, int height, uint8 color)

    22 {

    23 	uint32 color32 = LookupColourInPalette(color);

    24 

    25 	do {

    26 		uint32 *dst = (uint32 *)video;

    27 		for (int i = width; i > 0; i--) {

    28 			*dst = color32;

    29 			dst++;

    30 		}

    31 		video = (uint32 *)video + _screen.pitch;

    32 	} while (--height);

    33 }

    34 

    35 void Blitter_32bppBase::DrawLine(void *video, int x, int y, int x2, int y2, int screen_width, int screen_height, uint8 color)

    36 {

    37 	int dy;

    38 	int dx;

    39 	int stepx;

    40 	int stepy;

    41 	int frac;

    42 

    43 	dy = (y2 - y) * 2;

    44 	if (dy < 0) {

    45 		dy = -dy;

    46 		stepy = -1;

    47 	} else {

    48 		stepy = 1;

    49 	}

    50 

    51 	dx = (x2 - x) * 2;

    52 	if (dx < 0) {

    53 		dx = -dx;

    54 		stepx = -1;

    55 	} else {

    56 		stepx = 1;

    57 	}

    58 

    59 	this->SetPixel(video, x, y, color);

    60 	if (dx > dy) {

    61 		frac = dy - (dx / 2);

    62 		while (x != x2) {

    63 			if (frac >= 0) {

    64 				y += stepy;

    65 				frac -= dx;

    66 			}

    67 			x += stepx;

    68 			frac += dy;

    69 			if (x > 0 && y > 0 && x < screen_width && y < screen_height) this->SetPixel(video, x, y, color);

    70 		}

    71 	} else {

    72 		frac = dx - (dy / 2);

    73 		while (y != y2) {

    74 			if (frac >= 0) {

    75 				x += stepx;

    76 				frac -= dy;

    77 			}

    78 			y += stepy;

    79 			frac += dx;

    80 			if (x > 0 && y > 0 && x < screen_width && y < screen_height) this->SetPixel(video, x, y, color);

    81 		}

    82 	}

    83 }

    84 

    85 void Blitter_32bppBase::CopyFromBuffer(void *video, const void *src, int width, int height)

    86 {

    87 	uint32 *dst = (uint32 *)video;

    88 	uint32 *usrc = (uint32 *)src;

    89 

    90 	for (; height > 0; height--) {

    91 		memcpy(dst, usrc, width * sizeof(uint32));

    92 		usrc += width;

    93 		dst += _screen.pitch;

    94 	}

    95 }

    96 

    97 void Blitter_32bppBase::CopyToBuffer(const void *video, void *dst, int width, int height)

    98 {

    99 	uint32 *udst = (uint32 *)dst;

   100 	uint32 *src = (uint32 *)video;

   101 

   102 	for (; height > 0; height--) {

   103 		memcpy(udst, src, width * sizeof(uint32));

   104 		src += _screen.pitch;

   105 		udst += width;

   106 	}

   107 }

   108 

   109 void Blitter_32bppBase::CopyImageToBuffer(const void *video, void *dst, int width, int height, int dst_pitch)

   110 {

   111 	uint32 *udst = (uint32 *)dst;

   112 	uint32 *src = (uint32 *)video;

   113 

   114 	for (; height > 0; height--) {

   115 		memcpy(udst, src, width * sizeof(uint32));

   116 		src += _screen.pitch;

   117 		udst += dst_pitch;

   118 	}

   119 }

   120 

   121 void Blitter_32bppBase::ScrollBuffer(void *video, int &left, int &top, int &width, int &height, int scroll_x, int scroll_y)

   122 {

   123 	const uint32 *src;

   124 	uint32 *dst;

   125 

   126 	if (scroll_y > 0) {

   127 		/*Calculate pointers */

   128 		dst = (uint32 *)video + left + (top + height - 1) * _screen.pitch;

   129 		src = dst - scroll_y * _screen.pitch;

   130 

   131 		/* Decrease height and increase top */

   132 		top += scroll_y;

   133 		height -= scroll_y;

   134 		assert(height > 0);

   135 

   136 		/* Adjust left & width */

   137 		if (scroll_x >= 0) {

   138 			dst += scroll_x;

   139 			left += scroll_x;

   140 			width -= scroll_x;

   141 		} else {

   142 			src -= scroll_x;

   143 			width += scroll_x;

   144 		}

   145 

   146 		for (int h = height; h > 0; h--) {

   147 			memcpy(dst, src, width * sizeof(uint32));

   148 			src -= _screen.pitch;

   149 			dst -= _screen.pitch;

   150 		}

   151 	} else {

   152 		/* Calculate pointers */

   153 		dst = (uint32 *)video + left + top * _screen.pitch;

   154 		src = dst - scroll_y * _screen.pitch;

   155 

   156 		/* Decrese height. (scroll_y is <=0). */

   157 		height += scroll_y;

   158 		assert(height > 0);

   159 

   160 		/* Adjust left & width */

   161 		if (scroll_x >= 0) {

   162 			dst += scroll_x;

   163 			left += scroll_x;

   164 			width -= scroll_x;

   165 		} else {

   166 			src -= scroll_x;

   167 			width += scroll_x;

   168 		}

   169 

   170 		/* the y-displacement may be 0 therefore we have to use memmove,

   171 		 * because source and destination may overlap */

   172 		for (int h = height; h > 0; h--) {

   173 			memmove(dst, src, width * sizeof(uint32));

   174 			src += _screen.pitch;

   175 			dst += _screen.pitch;

   176 		}

   177 	}

   178 }

   179 

   180 int Blitter_32bppBase::BufferSize(int width, int height)

   181 {

   182 	return width * height * sizeof(uint32);

   183 }

   184 

   185 void Blitter_32bppBase::PaletteAnimate(uint start, uint count)

   186 {

   187 	/* By default, 32bpp doesn't have palette animation */

   188 }

   189 

   190 Blitter::PaletteAnimation Blitter_32bppBase::UsePaletteAnimation()

   191 {

   192 	return Blitter::PALETTE_ANIMATION_NONE;

   193 }