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::SetHorizontalLine(void *video, int width, uint8 color)

    22

{

    23

	uint32 *dst = (uint32 *)video;

    24

	uint32 color32 = LookupColourInPalette(color);

    25

    26

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

    27

		*dst = color32;

    28

		dst++;

    29

	}

    30

}

    31

    32

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

    33

{

    34

	int dy;

    35

	int dx;

    36

	int stepx;

    37

	int stepy;

    38

	int frac;

    39

    40

	dy = (y2 - y) * 2;

    41

	if (dy < 0) {

    42

		dy = -dy;

    43

		stepy = -1;

    44

	} else {

    45

		stepy = 1;

    46

	}

    47

    48

	dx = (x2 - x) * 2;

    49

	if (dx < 0) {

    50

		dx = -dx;

    51

		stepx = -1;

    52

	} else {

    53

		stepx = 1;

    54

	}

    55

    56

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

    57

	if (dx > dy) {

    58

		frac = dy - (dx >> 1);

    59

		while (x != x2) {

    60

			if (frac >= 0) {

    61

				y += stepy;

    62

				frac -= dx;

    63

			}

    64

			x += stepx;

    65

			frac += dy;

    66

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

    67

		}

    68

	} else {

    69

		frac = dx - (dy >> 1);

    70

		while (y != y2) {

    71

			if (frac >= 0) {

    72

				x += stepx;

    73

				frac -= dy;

    74

			}

    75

			y += stepy;

    76

			frac += dx;

    77

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

    78

		}

    79

	}

    80

}

    81

    82

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

    83

{

    84

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

    85

	uint32 *dst = (uint32 *)video;

    86

	uint32 *usrc = (uint32 *)src;

    87

    88

	height = abs(height);

    89

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

    90

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

    91

		usrc += src_pitch * direction;

    92

		dst += _screen.pitch * direction;

    93

	}

    94

}

    95

    96

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

    97

{

    98

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

    99

	uint32 *udst = (uint32 *)dst;

   100

	uint32 *src = (uint32 *)video;

   101

   102

	height = abs(height);

   103

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

   104

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

   105

		src += _screen.pitch * direction;

   106

		udst += dst_pitch * direction;

   107

	}

   108

}

   109

   110

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

   111

{

   112

	uint32 *dst = (uint32 *)video_dst;

   113

	uint32 *src = (uint32 *)video_src;

   114

   115

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

   116

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

   117

		src += _screen.pitch;

   118

		dst += _screen.pitch;

   119

	}

   120

}

   121

   122

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

   123

{

   124

	return width * height * sizeof(uint32);

   125

}