1

#include "../stdafx.h"

     2

#include "../zoom.hpp"

     3

#include "../gfx.h"

     4

#include "../debug.h"

     5

#include "../table/sprites.h"

     6

#include "../video/video_driver.hpp"

     7

#include "32bpp_anim.hpp"

     8

     9

static FBlitter_32bppAnim iFBlitter_32bppAnim;

    10

    11

void Blitter_32bppAnim::Draw(Blitter::BlitterParams *bp, BlitterMode mode, ZoomLevel zoom)

    12

{

    13

	const SpriteLoader::CommonPixel *src, *src_line;

    14

	uint32 *dst, *dst_line;

    15

	uint8 *anim, *anim_line, *anim_end;

    16

    17

	if (_screen.width != this->anim_buf_width || _screen.height != this->anim_buf_height) {

    18

		/* The size of the screen changed; we can assume we can wipe all data from our buffer */

    19

		free(this->anim_buf);

    20

		this->anim_buf = CallocT<uint8>(_screen.width * _screen.height);

    21

		this->anim_buf_width = _screen.width;

    22

		this->anim_buf_height = _screen.height;

    23

	}

    25

    26

	/* Find where to start reading in the source sprite */

    27

	src_line = (const SpriteLoader::CommonPixel *)bp->sprite + (bp->skip_top * bp->sprite_width + bp->skip_left) * ScaleByZoom(1, zoom);

    28

	dst_line = (uint32 *)bp->dst + bp->top * bp->pitch + bp->left;

    29

	anim_line = this->anim_buf + ((uint32 *)bp->dst - (uint32 *)_screen.dst_ptr) + bp->top * this->anim_buf_width + bp->left;

    30

    31

	for (int y = 0; y < bp->height; y++) {

    32

		dst = dst_line;

    33

		dst_line += bp->pitch;

    34

    35

		src = src_line;

    36

		src_line += bp->sprite_width * ScaleByZoom(1, zoom);

    37

    38

		anim = anim_line;

    39

		anim_line += this->anim_buf_width;

    43

    44

		for (int x = 0; x < bp->width; x++) {

    45

			if (src->a == 0) {

    46

				/* src->r is 'misused' here to indicate how much more pixels are following with an alpha of 0 */

    47

				int skip = UnScaleByZoom(src->r, zoom);

    48

    49

				dst  += skip;

    50

				/* Make sure the anim-buffer is cleared */

    55

				x    += skip - 1;

    56

				src  += ScaleByZoom(1, zoom) * skip;

    57

				continue;

    58

			}

    59

    60

			switch (mode) {

    61

				case BM_COLOUR_REMAP:

    62

					/* In case the m-channel is zero, do not remap this pixel in any way */

    63

					if (src->m == 0) {

    64

						*dst = ComposeColourRGBA(src->r, src->g, src->b, src->a, *dst);

    66

					} else {

    67

						if (bp->remap[src->m] != 0) {

    68

							*dst = ComposeColourPA(this->LookupColourInPalette(bp->remap[src->m]), src->a, *dst);

    70

						}

    71

					}

    72

					break;

    73

    74

				case BM_TRANSPARENT:

    75

					/* TODO -- We make an assumption here that the remap in fact is transparency, not some color.

    76

					 *  This is never a problem with the code we produce, but newgrfs can make it fail... or at least:

    77

					 *  we produce a result the newgrf maker didn't expect ;) */

    78

    79

					/* Make the current color a bit more black, so it looks like this image is transparent */

    80

					*dst = MakeTransparent(*dst, 192);

    82

					break;

    83

    84

				default:

    85

					/* Above 217 is palette animation */

    86

					if (src->m >= 217) *dst = ComposeColourPA(this->LookupColourInPalette(src->m), src->a, *dst);

    87

					else               *dst = ComposeColourRGBA(src->r, src->g, src->b, src->a, *dst);

    89

					break;

    90

			}

    91

			dst++;

    95

			src += ScaleByZoom(1, zoom);

    96

		}

    97

	}

    98

}

    99

   100

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

   101

{

   102

	uint32 *udst = (uint32 *)dst;

   103

	uint8 *anim;

   104

   105

	anim = this->anim_buf + ((uint32 *)dst - (uint32 *)_screen.dst_ptr);

   106

   107

	if (pal == PALETTE_TO_TRANSPARENT) {

   108

		do {

   109

			for (int i = 0; i != width; i++) {

   110

				*udst = MakeTransparent(*udst, 154);

   111

				*anim = 0;

   112

				udst++;

   113

				anim++;

   114

			}

   115

			udst = udst - width + _screen.pitch;

   116

			anim = anim - width + this->anim_buf_width;

   117

		} while (--height);

   118

		return;

   119

	}

   120

	if (pal == PALETTE_TO_STRUCT_GREY) {

   121

		do {

   122

			for (int i = 0; i != width; i++) {

   123

				*udst = MakeGrey(*udst);

   124

				*anim = 0;

   125

				udst++;

   126

				anim++;

   127

			}

   128

			udst = udst - width + _screen.pitch;

   129

			anim = anim - width + this->anim_buf_width;

   130

		} while (--height);

   131

		return;

   132

	}

   133

   134

	DEBUG(misc, 0, "32bpp blitter doesn't know how to draw this color table ('%d')", pal);

   135

}

   136

   137

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

   138

{

   139

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

   140

	/* Set the color in the anim-buffer too */

   141

	this->anim_buf[((uint32 *)video - (uint32 *)_screen.dst_ptr) + x + y * this->anim_buf_width] = color;

   142

}

   143

   144

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

   145

{

   146

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

   147

	if (*dst == 0) {

   148

		*dst = LookupColourInPalette(color);

   149

		/* Set the color in the anim-buffer too */

   150

		this->anim_buf[((uint32 *)video - (uint32 *)_screen.dst_ptr) + x + y * this->anim_buf_width] = color;

   151

	}

   152

}

   153

   154

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

   155

{

   156

	uint32 color32 = LookupColourInPalette(color);

   157

	uint8 *anim_line;

   158

   159

	anim_line = ((uint32 *)video - (uint32 *)_screen.dst_ptr) + this->anim_buf;

   160

   161

	do {

   162

		uint32 *dst = (uint32 *)video;

   163

		uint8 *anim = anim_line;

   164

   165

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

   166

			*dst = color32;

   167

			/* Set the color in the anim-buffer too */

   168

			*anim = color;

   169

			dst++;

   170

			anim++;

   171

		}

   172

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

   173

		anim_line += this->anim_buf_width;

   174

	} while (--height);

   175

}

   176

   177

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

   178

{

   179

	assert(video >= _screen.dst_ptr && video <= (uint32 *)_screen.dst_ptr + _screen.width + _screen.height * _screen.pitch);

   180

	uint32 *dst = (uint32 *)video;

   181

	uint32 *usrc = (uint32 *)src;

   182

	uint8 *anim_line;

   183

   184

	anim_line = ((uint32 *)video - (uint32 *)_screen.dst_ptr) + this->anim_buf;

   185

   186

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

   187

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

   188

		usrc += width;

   189

		dst += _screen.pitch;

   190

		/* Copy back the anim-buffer */

   191

		memcpy(anim_line, usrc, width * sizeof(uint8));

   192

		usrc = (uint32 *)((uint8 *)usrc + width);

   193

		anim_line += this->anim_buf_width;

   194

	}

   195

   196

	/* We update the palette (or the pixels that do animation) immediatly, to avoid graphical glitches */

   197

	this->PaletteAnimate(217, _use_dos_palette ? 38 : 28);

   198

}

   199

   200

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

   201

{

   202

	assert(video >= _screen.dst_ptr && video <= (uint32 *)_screen.dst_ptr + _screen.width + _screen.height * _screen.pitch);

   203

	uint32 *udst = (uint32 *)dst;

   204

	uint32 *src = (uint32 *)video;

   205

	uint8 *anim_line;

   206

   207

	if (this->anim_buf == NULL) return;

   208

   209

	anim_line = ((uint32 *)video - (uint32 *)_screen.dst_ptr) + this->anim_buf;

   210

   211

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

   212

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

   213

		src += _screen.pitch;

   214

		udst += width;

   215

		/* Copy the anim-buffer */

   216

		memcpy(udst, anim_line, width * sizeof(uint8));

   217

		udst = (uint32 *)((uint8 *)udst + width);

   218

		anim_line += this->anim_buf_width;

   219

	}

   220

}

   221

   222

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

   223

{

   224

	uint8 *dst, *src;

   225

   226

	/* We need to scroll the anim-buffer too */

   227

	if (scroll_y > 0) {

   228

		dst = this->anim_buf + left + (top + height - 1) * this->anim_buf_width;

   229

		src = dst - scroll_y * this->anim_buf_width;

   230

   231

		/* Adjust left & width */

   232

		if (scroll_x >= 0) dst += scroll_x;

   233

		else               src -= scroll_x;

   234

   235

		uint tw = width + (scroll_x >= 0 ? -scroll_x : scroll_x);

   236

		uint th = height - scroll_y;

   237

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

   238

			memcpy(dst, src, tw * sizeof(uint8));

   239

			src -= this->anim_buf_width;

   240

			dst -= this->anim_buf_width;

   241

		}

   242

	} else {

   243

		/* Calculate pointers */

   244

		dst = this->anim_buf + left + top * this->anim_buf_width;

   245

		src = dst - scroll_y * this->anim_buf_width;

   246

   247

		/* Adjust left & width */

   248

		if (scroll_x >= 0) dst += scroll_x;

   249

		else               src -= scroll_x;

   250

   251

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

   252

		 * because source and destination may overlap */

   253

		uint tw = width + (scroll_x >= 0 ? -scroll_x : scroll_x);

   254

		uint th = height + scroll_y;

   255

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

   256

			memmove(dst, src, tw * sizeof(uint8));

   257

			src += this->anim_buf_width;

   258

			dst += this->anim_buf_width;

   259

		}

   260

	}

   261

   262

	Blitter_32bppBase::ScrollBuffer(video, left, top, width, height, scroll_x, scroll_y);

   263

}

   264

   265

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

   266

{

   267

	return width * height * (sizeof(uint32) + sizeof(uint8));

   268

}

   269

   270

void Blitter_32bppAnim::PaletteAnimate(uint start, uint count)

   271

{

   272

	uint8 *anim = this->anim_buf;

   273

   274

	/* Never repaint the transparency pixel */

   275

	if (start == 0) start++;

   276

   277

	/* Let's walk the anim buffer and try to find the pixels */

   278

	for (int y = 0; y < this->anim_buf_height; y++) {

   279

		for (int x = 0; x < this->anim_buf_width; x++) {

   280

			if (*anim >= start && *anim <= start + count) {

   281

				/* Update this pixel */

   282

				this->SetPixel(_screen.dst_ptr, x, y, *anim);

   283

			}

   284

			anim++;

   285

		}

   286

	}

   287

   288

	/* Make sure the backend redraws the whole screen */

   289

	_video_driver->MakeDirty(0, 0, _screen.width, _screen.height);

   290

}

   291

   292

Blitter::PaletteAnimation Blitter_32bppAnim::UsePaletteAnimation()

   293

{

   294

	return Blitter::PALETTE_ANIMATION_BLITTER;

   295

}