1

#include "../stdafx.h"

     2

#include "../gfx.h"

     3

#include "8bpp_base.hpp"

     4

     5

void Blitter_8bppBase::DrawColorMappingRect(void *dst, int width, int height, int pal)

     6

{

     7

	const uint8 *ctab = GetNonSprite(pal) + 1;

     8

     9

	do {

    10

		for (int i = 0; i != width; i++) *((uint8 *)dst + i) = ctab[((uint8 *)dst)[i]];

    11

		dst = (uint8 *)dst + _screen.pitch;

    12

	} while (height--);

    13

}

    14

    15

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

    16

{

    17

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

    18

}

    19

    20

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

    21

{

    22

	*((uint8 *)video + x + y * _screen.pitch) = color;

    23

}

    24

    25

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

    26

{

    27

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

    28

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

    29

}

    30

    31

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

    32

{

    33

	do {

    34

		memset(video, color, width);

    35

		video = (uint8 *)video + _screen.pitch;

    36

	} while (--height);

    37

}

    38

    39

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

    40

{

    41

	int dy;

    42

	int dx;

    43

	int stepx;

    44

	int stepy;

    45

	int frac;

    46

    47

	dy = (y2 - y) * 2;

    48

	if (dy < 0) {

    49

		dy = -dy;

    50

		stepy = -1;

    51

	} else {

    52

		stepy = 1;

    53

	}

    54

    55

	dx = (x2 - x) * 2;

    56

	if (dx < 0) {

    57

		dx = -dx;

    58

		stepx = -1;

    59

	} else {

    60

		stepx = 1;

    61

	}

    62

    63

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

    64

	if (dx > dy) {

    65

		frac = dy - (dx / 2);

    66

		while (x != x2) {

    67

			if (frac >= 0) {

    68

				y += stepy;

    69

				frac -= dx;

    70

			}

    71

			x += stepx;

    72

			frac += dy;

    73

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

    74

		}

    75

	} else {

    76

		frac = dx - (dy / 2);

    77

		while (y != y2) {

    78

			if (frac >= 0) {

    79

				x += stepx;

    80

				frac -= dy;

    81

			}

    82

			y += stepy;

    83

			frac += dx;

    84

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

    85

		}

    86

	}

    87

}

    88

    89

void Blitter_8bppBase::CopyFromBuffer(void *video, const void *src, int width, int height, int src_pitch)

    90

{

    91

	int direction = (height < 0) ? -1 : 1;

    92

	uint8 *dst = (uint8 *)video;

    93

	uint8 *usrc = (uint8 *)src;

    94

    95

	height = abs(height);

    96

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

    97

		memcpy(dst, usrc, width);

    98

		usrc += src_pitch * direction;

    99

		dst += _screen.pitch * direction;

   100

	}

   101

}

   102

   103

void Blitter_8bppBase::CopyToBuffer(const void *video, void *dst, int width, int height, int dst_pitch)

   104

{

   105

	int direction = (height < 0) ? -1 : 1;

   106

	uint8 *udst = (uint8 *)dst;

   107

	uint8 *src = (uint8 *)video;

   108

   109

	height = abs(height);

   110

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

   111

		memcpy(udst, src, width);

   112

		src += _screen.pitch * direction;

   113

		udst += dst_pitch * direction;

   114

	}

   115

}

   116

   117

void Blitter_8bppBase::MoveBuffer(void *video_dst, const void *video_src, int width, int height)

   118

{

   119

	uint8 *dst = (uint8 *)video_dst;

   120

	uint8 *src = (uint8 *)video_src;

   121

   122

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

   123

		memmove(dst, src, width);

   124

		src += _screen.pitch;

   125

		dst += _screen.pitch;

   126

	}

   127

}

   128

   181

int Blitter_8bppBase::BufferSize(int width, int height)

   182

{

   183

	return width * height;

   184

}