qzdoom-gpl/src/r_drawt_rgba.cpp

/*
** r_drawt_rgba.cpp
** Faster column drawers for modern processors, true color edition
**
**---------------------------------------------------------------------------
** Copyright 1998-2006 Randy Heit
** All rights reserved.
**
** Redistribution and use in source and binary forms, with or without
** modification, are permitted provided that the following conditions
** are met:
**
** 1. Redistributions of source code must retain the above copyright
**    notice, this list of conditions and the following disclaimer.
** 2. Redistributions in binary form must reproduce the above copyright
**    notice, this list of conditions and the following disclaimer in the
**    documentation and/or other materials provided with the distribution.
** 3. The name of the author may not be used to endorse or promote products
**    derived from this software without specific prior written permission.
**
** THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
** IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
** OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
** IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
** INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
** NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
** THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
**---------------------------------------------------------------------------
**
** True color versions of the similar functions in r_drawt.cpp
** Please see r_drawt.cpp for a description of the globals used.
*/

#include "templates.h"
#include "doomtype.h"
#include "doomdef.h"
#include "r_defs.h"
#include "r_draw.h"
#include "r_main.h"
#include "r_things.h"
#include "v_video.h"
#include "r_draw_rgba.h"
#ifndef NO_SSE
#include <emmintrin.h>
#endif

extern unsigned int dc_tspans[4][MAXHEIGHT];
extern unsigned int *dc_ctspan[4];
extern unsigned int *horizspan[4];

#ifndef NO_SSE

// Generate SSE drawers:
#define VecCommand(name) name##_SSE_Command
#define VEC_SHADE_SIMPLE_INIT SSE_SHADE_SIMPLE_INIT
#define VEC_SHADE_SIMPLE_INIT4 SSE_SHADE_SIMPLE_INIT4
#define VEC_SHADE_SIMPLE SSE_SHADE_SIMPLE
#define VEC_SHADE_INIT SSE_SHADE_INIT
#define VEC_SHADE_INIT4 SSE_SHADE_INIT4
#define VEC_SHADE SSE_SHADE
#include "r_drawt_rgba_sse.h"
/*
// Generate AVX drawers:
#undef VecCommand
#undef VEC_SHADE_SIMPLE_INIT
#undef VEC_SHADE_SIMPLE_INIT4
#undef VEC_SHADE_SIMPLE
#undef VEC_SHADE_INIT
#undef VEC_SHADE_INIT4
#undef VEC_SHADE
#define VecCommand(name) name##_AVX_Command
#define VEC_SHADE_SIMPLE_INIT AVX_LINEAR_SHADE_SIMPLE_INIT
#define VEC_SHADE_SIMPLE_INIT4 AVX_LINEAR_SHADE_SIMPLE_INIT4
#define VEC_SHADE_SIMPLE AVX_LINEAR_SHADE_SIMPLE
#define VEC_SHADE_INIT AVX_LINEAR_SHADE_INIT
#define VEC_SHADE_INIT4 AVX_LINEAR_SHADE_INIT4
#define VEC_SHADE AVX_LINEAR_SHADE
#include "r_drawt_rgba_sse.h"
*/
#endif

/////////////////////////////////////////////////////////////////////////////

class RtCopy1colRGBACommand : public DrawerCommand
{
	int hx;
	int sx;
	int yl;
	int yh;
	BYTE * RESTRICT _destorg;
	int _pitch;

public:
	RtCopy1colRGBACommand(int hx, int sx, int yl, int yh)
	{
		this->hx = hx;
		this->sx = sx;
		this->yl = yl;
		this->yh = yh;

		_destorg = dc_destorg;
		_pitch = dc_pitch;
	}

	void Execute(DrawerThread *thread) override
	{
		uint32_t *source;
		uint32_t *dest;
		int count;
		int pitch, sincr;

		count = thread->count_for_thread(yl, (yh - yl + 1));
		if (count <= 0)
			return;

		dest = thread->dest_for_thread(yl, _pitch, ylookup[yl] + sx + (uint32_t*)_destorg);
		source = &thread->dc_temp_rgba[yl * 4 + hx] + thread->skipped_by_thread(yl) * 4;
		pitch = _pitch * thread->num_cores;
		sincr = thread->num_cores * 4;

		if (count & 1) {
			*dest = GPalette.BaseColors[*source];
			source += sincr;
			dest += pitch;
		}
		if (count & 2) {
			dest[0] = GPalette.BaseColors[source[0]];
			dest[pitch] = GPalette.BaseColors[source[sincr]];
			source += sincr * 2;
			dest += pitch * 2;
		}
		if (!(count >>= 2))
			return;

		do {
			dest[0] = GPalette.BaseColors[source[0]];
			dest[pitch] = GPalette.BaseColors[source[sincr]];
			dest[pitch * 2] = GPalette.BaseColors[source[sincr * 2]];
			dest[pitch * 3] = GPalette.BaseColors[source[sincr * 3]];
			source += sincr * 4;
			dest += pitch * 4;
		} while (--count);
	}
};

class RtMap1colRGBACommand : public DrawerCommand
{
	int hx;
	int sx;
	int yl;
	int yh;
	fixed_t _light;
	ShadeConstants _shade_constants;
	BYTE * RESTRICT _destorg;
	int _pitch;
	BYTE * RESTRICT _colormap;

public:
	RtMap1colRGBACommand(int hx, int sx, int yl, int yh)
	{
		this->hx = hx;
		this->sx = sx;
		this->yl = yl;
		this->yh = yh;

		_light = dc_light;
		_shade_constants = dc_shade_constants;
		_destorg = dc_destorg;
		_pitch = dc_pitch;
		_colormap = dc_colormap;
	}

	void Execute(DrawerThread *thread) override
	{
		uint32_t *source;
		uint32_t *dest;
		int count;
		int pitch;
		int sincr;

		count = thread->count_for_thread(yl, yh - yl + 1);
		if (count <= 0)
			return;

		uint32_t light = LightBgra::calc_light_multiplier(_light);
		ShadeConstants shade_constants = _shade_constants;

		dest = thread->dest_for_thread(yl, _pitch, ylookup[yl] + sx + (uint32_t*)_destorg);
		source = &thread->dc_temp_rgba[yl * 4 + hx] + thread->skipped_by_thread(yl) * 4;
		pitch = _pitch * thread->num_cores;
		sincr = thread->num_cores * 4;
		
		BYTE *colormap = _colormap;

		if (count & 1) {
			*dest = LightBgra::shade_pal_index(colormap[*source], light, shade_constants);
			source += sincr;
			dest += pitch;
		}
		if (!(count >>= 1))
			return;

		do {
			dest[0] = LightBgra::shade_pal_index(colormap[source[0]], light, shade_constants);
			dest[pitch] = LightBgra::shade_pal_index(colormap[source[sincr]], light, shade_constants);
			source += sincr * 2;
			dest += pitch * 2;
		} while (--count);
	}
};

class RtMap4colsRGBACommand : public DrawerCommand
{
	int sx;
	int yl;
	int yh;
	fixed_t _light;
	ShadeConstants _shade_constants;
	BYTE * RESTRICT _destorg;
	int _pitch;
	BYTE * RESTRICT _colormap;

public:
	RtMap4colsRGBACommand(int sx, int yl, int yh)
	{
		this->sx = sx;
		this->yl = yl;
		this->yh = yh;

		_light = dc_light;
		_shade_constants = dc_shade_constants;
		_destorg = dc_destorg;
		_pitch = dc_pitch;
		_colormap = dc_colormap;
	}

	void Execute(DrawerThread *thread) override
	{
		uint32_t *source;
		uint32_t *dest;
		int count;
		int pitch;
		int sincr;

		count = thread->count_for_thread(yl, yh - yl + 1);
		if (count <= 0)
			return;

		uint32_t light = LightBgra::calc_light_multiplier(_light);
		ShadeConstants shade_constants = _shade_constants;

		dest = thread->dest_for_thread(yl, _pitch, ylookup[yl] + sx + (uint32_t*)_destorg);
		source = &thread->dc_temp_rgba[yl * 4] + thread->skipped_by_thread(yl) * 4;
		pitch = _pitch * thread->num_cores;
		sincr = thread->num_cores * 4;
		
		BYTE *colormap = _colormap;

		if (count & 1) {
			dest[0] = LightBgra::shade_pal_index(colormap[source[0]], light, shade_constants);
			dest[1] = LightBgra::shade_pal_index(colormap[source[1]], light, shade_constants);
			dest[2] = LightBgra::shade_pal_index(colormap[source[2]], light, shade_constants);
			dest[3] = LightBgra::shade_pal_index(colormap[source[3]], light, shade_constants);
			source += sincr;
			dest += pitch;
		}
		if (!(count >>= 1))
			return;

		do {
			dest[0] = LightBgra::shade_pal_index(colormap[source[0]], light, shade_constants);
			dest[1] = LightBgra::shade_pal_index(colormap[source[1]], light, shade_constants);
			dest[2] = LightBgra::shade_pal_index(colormap[source[2]], light, shade_constants);
			dest[3] = LightBgra::shade_pal_index(colormap[source[3]], light, shade_constants);
			dest[pitch] = LightBgra::shade_pal_index(colormap[source[sincr]], light, shade_constants);
			dest[pitch + 1] = LightBgra::shade_pal_index(colormap[source[sincr + 1]], light, shade_constants);
			dest[pitch + 2] = LightBgra::shade_pal_index(colormap[source[sincr + 2]], light, shade_constants);
			dest[pitch + 3] = LightBgra::shade_pal_index(colormap[source[sincr + 3]], light, shade_constants);
			source += sincr * 2;
			dest += pitch * 2;
		} while (--count);
	}
};

class RtTranslate1colRGBACommand : public DrawerCommand
{
	const BYTE * RESTRICT translation;
	int hx;
	int yl;
	int yh;

public:
	RtTranslate1colRGBACommand(const BYTE *translation, int hx, int yl, int yh)
	{
		this->translation = translation;
		this->hx = hx;
		this->yl = yl;
		this->yh = yh;
	}

	void Execute(DrawerThread *thread) override
	{
		int count = yh - yl + 1;
		uint32_t *source = &thread->dc_temp_rgba[yl*4 + hx];

		// Things we do to hit the compiler's optimizer with a clue bat:
		// 1. Parallelism is explicitly spelled out by using a separate
		//    C instruction for each assembly instruction. GCC lets me
		//    have four temporaries, but VC++ spills to the stack with
		//    more than two. Two is probably optimal, anyway.
		// 2. The results of the translation lookups are explicitly
		//    stored in byte-sized variables. This causes the VC++ code
		//    to use byte mov instructions in most cases; for apparently
		//    random reasons, it will use movzx for some places. GCC
		//    ignores this and uses movzx always.

		// Do 8 rows at a time.
		for (int count8 = count >> 3; count8; --count8)
		{
			int c0, c1;
			BYTE b0, b1;

			c0 = source[0];			c1 = source[4];
			b0 = translation[c0];	b1 = translation[c1];
			source[0] = b0;			source[4] = b1;

			c0 = source[8];			c1 = source[12];
			b0 = translation[c0];	b1 = translation[c1];
			source[8] = b0;			source[12] = b1;

			c0 = source[16];		c1 = source[20];
			b0 = translation[c0];	b1 = translation[c1];
			source[16] = b0;		source[20] = b1;

			c0 = source[24];		c1 = source[28];
			b0 = translation[c0];	b1 = translation[c1];
			source[24] = b0;		source[28] = b1;

			source += 32;
		}
		// Finish by doing 1 row at a time.
		for (count &= 7; count; --count, source += 4)
		{
			source[0] = translation[source[0]];
		}
	}
};

class RtTranslate4colsRGBACommand : public DrawerCommand
{
	const BYTE * RESTRICT translation;
	int yl;
	int yh;

public:
	RtTranslate4colsRGBACommand(const BYTE *translation, int yl, int yh)
	{
		this->translation = translation;
		this->yl = yl;
		this->yh = yh;
	}

	void Execute(DrawerThread *thread) override
	{
		int count = yh - yl + 1;
		uint32_t *source = &thread->dc_temp_rgba[yl*4];
		int c0, c1;
		BYTE b0, b1;

		// Do 2 rows at a time.
		for (int count8 = count >> 1; count8; --count8)
		{
			c0 = source[0];			c1 = source[1];
			b0 = translation[c0];	b1 = translation[c1];
			source[0] = b0;			source[1] = b1;

			c0 = source[2];			c1 = source[3];
			b0 = translation[c0];	b1 = translation[c1];
			source[2] = b0;			source[3] = b1;

			c0 = source[4];			c1 = source[5];
			b0 = translation[c0];	b1 = translation[c1];
			source[4] = b0;			source[5] = b1;

			c0 = source[6];			c1 = source[7];
			b0 = translation[c0];	b1 = translation[c1];
			source[6] = b0;			source[7] = b1;

			source += 8;
		}
		// Do the final row if count was odd.
		if (count & 1)
		{
			c0 = source[0];			c1 = source[1];
			b0 = translation[c0];	b1 = translation[c1];
			source[0] = b0;			source[1] = b1;

			c0 = source[2];			c1 = source[3];
			b0 = translation[c0];	b1 = translation[c1];
			source[2] = b0;			source[3] = b1;
		}
	}
};

class RtAdd1colRGBACommand : public DrawerCommand
{
	int hx;
	int sx;
	int yl;
	int yh;
	BYTE * RESTRICT _destorg;
	int _pitch;
	fixed_t _light;
	ShadeConstants _shade_constants;
	fixed_t _srcalpha;
	fixed_t _destalpha;
	BYTE * RESTRICT _colormap;

public:
	RtAdd1colRGBACommand(int hx, int sx, int yl, int yh)
	{
		this->hx = hx;
		this->sx = sx;
		this->yl = yl;
		this->yh = yh;

		_destorg = dc_destorg;
		_pitch = dc_pitch;
		_light = dc_light;
		_shade_constants = dc_shade_constants;
		_srcalpha = dc_srcalpha;
		_destalpha = dc_destalpha;
		_colormap = dc_colormap;
	}

	void Execute(DrawerThread *thread) override
	{
		uint32_t *source;
		uint32_t *dest;
		int count;
		int pitch;
		int sincr;

		count = thread->count_for_thread(yl, yh - yl + 1);
		if (count <= 0)
			return;

		dest = thread->dest_for_thread(yl, _pitch, ylookup[yl] + sx + (uint32_t*)_destorg);
		source = &thread->dc_temp_rgba[yl * 4 + hx] + thread->skipped_by_thread(yl) * 4;
		pitch = _pitch * thread->num_cores;
		sincr = 4 * thread->num_cores;

		uint32_t light = LightBgra::calc_light_multiplier(_light);
		ShadeConstants shade_constants = _shade_constants;
		BYTE *colormap = _colormap;

		uint32_t fg_alpha = _srcalpha >> (FRACBITS - 8);
		uint32_t bg_alpha = _destalpha >> (FRACBITS - 8);

		do {
			uint32_t fg = LightBgra::shade_pal_index(colormap[*source], light, shade_constants);
			uint32_t fg_red = (fg >> 16) & 0xff;
			uint32_t fg_green = (fg >> 8) & 0xff;
			uint32_t fg_blue = fg & 0xff;

			uint32_t bg_red = (*dest >> 16) & 0xff;
			uint32_t bg_green = (*dest >> 8) & 0xff;
			uint32_t bg_blue = (*dest) & 0xff;

			uint32_t red = clamp<uint32_t>((fg_red * fg_alpha + bg_red * bg_alpha) / 256, 0, 255);
			uint32_t green = clamp<uint32_t>((fg_green * fg_alpha + bg_green * bg_alpha) / 256, 0, 255);
			uint32_t blue = clamp<uint32_t>((fg_blue * fg_alpha + bg_blue * bg_alpha) / 256, 0, 255);

			*dest = 0xff000000 | (red << 16) | (green << 8) | blue;

			source += sincr;
			dest += pitch;
		} while (--count);
	}
};

class RtAdd4colsRGBACommand : public DrawerCommand
{
	int sx;
	int yl;
	int yh;
	BYTE * RESTRICT _destorg;
	int _pitch;
	fixed_t _light;
	ShadeConstants _shade_constants;
	BYTE * RESTRICT _colormap;
	fixed_t _srcalpha;
	fixed_t _destalpha;

public:
	RtAdd4colsRGBACommand(int sx, int yl, int yh)
	{
		this->sx = sx;
		this->yl = yl;
		this->yh = yh;

		_destorg = dc_destorg;
		_pitch = dc_pitch;
		_light = dc_light;
		_shade_constants = dc_shade_constants;
		_colormap = dc_colormap;
		_srcalpha = dc_srcalpha;
		_destalpha = dc_destalpha;
	}

	void Execute(DrawerThread *thread) override
	{
		uint32_t *source;
		uint32_t *dest;
		int count;
		int pitch;
		int sincr;

		count = thread->count_for_thread(yl, yh - yl + 1);
		if (count <= 0)
			return;

		dest = thread->dest_for_thread(yl, _pitch, ylookup[yl] + sx + (uint32_t*)_destorg);
		source = &thread->dc_temp_rgba[yl * 4] + thread->skipped_by_thread(yl) * 4;
		pitch = _pitch * thread->num_cores;
		sincr = 4 * thread->num_cores;

		uint32_t light = LightBgra::calc_light_multiplier(_light);
		ShadeConstants shade_constants = _shade_constants;
		BYTE *colormap = _colormap;

		uint32_t fg_alpha = _srcalpha >> (FRACBITS - 8);
		uint32_t bg_alpha = _destalpha >> (FRACBITS - 8);

		do {
			for (int i = 0; i < 4; i++)
			{
				uint32_t fg = LightBgra::shade_pal_index(colormap[source[i]], light, shade_constants);
				uint32_t fg_red = (fg >> 16) & 0xff;
				uint32_t fg_green = (fg >> 8) & 0xff;
				uint32_t fg_blue = fg & 0xff;

				uint32_t bg_red = (dest[i] >> 16) & 0xff;
				uint32_t bg_green = (dest[i] >> 8) & 0xff;
				uint32_t bg_blue = (dest[i]) & 0xff;

				uint32_t red = clamp<uint32_t>((fg_red * fg_alpha + bg_red * bg_alpha) / 256, 0, 255);
				uint32_t green = clamp<uint32_t>((fg_green * fg_alpha + bg_green * bg_alpha) / 256, 0, 255);
				uint32_t blue = clamp<uint32_t>((fg_blue * fg_alpha + bg_blue * bg_alpha) / 256, 0, 255);

				dest[i] = 0xff000000 | (red << 16) | (green << 8) | blue;
			}

			source += sincr;
			dest += pitch;
		} while (--count);
	}
};

class RtShaded1colRGBACommand : public DrawerCommand
{
	int hx;
	int sx;
	int yl;
	int yh;
	lighttable_t * RESTRICT _colormap;
	BYTE * RESTRICT _destorg;
	int _pitch;
	int _color;
	fixed_t _light;

public:
	RtShaded1colRGBACommand(int hx, int sx, int yl, int yh)
	{
		this->hx = hx;
		this->sx = sx;
		this->yl = yl;
		this->yh = yh;

		_colormap = dc_colormap;
		_destorg = dc_destorg;
		_pitch = dc_pitch;
		_color = dc_color;
		_light = dc_light;
	}

	void Execute(DrawerThread *thread) override
	{
		BYTE *colormap;
		uint32_t *source;
		uint32_t *dest;
		int count;
		int pitch;
		int sincr;

		count = thread->count_for_thread(yl, yh - yl + 1);
		if (count <= 0)
			return;

		colormap = _colormap;
		dest = thread->dest_for_thread(yl, _pitch, ylookup[yl] + sx + (uint32_t*)_destorg);
		source = &thread->dc_temp_rgba[yl * 4 + hx] + thread->skipped_by_thread(yl) * 4;
		pitch = _pitch * thread->num_cores;
		sincr = 4 * thread->num_cores;

		uint32_t fg = LightBgra::shade_pal_index_simple(_color, LightBgra::calc_light_multiplier(_light));
		uint32_t fg_red = (fg >> 16) & 0xff;
		uint32_t fg_green = (fg >> 8) & 0xff;
		uint32_t fg_blue = fg & 0xff;

		do {
			uint32_t alpha = colormap[*source];
			uint32_t inv_alpha = 64 - alpha;

			uint32_t bg_red = (*dest >> 16) & 0xff;
			uint32_t bg_green = (*dest >> 8) & 0xff;
			uint32_t bg_blue = (*dest) & 0xff;

			uint32_t red = (fg_red * alpha + bg_red * inv_alpha) / 64;
			uint32_t green = (fg_green * alpha + bg_green * inv_alpha) / 64;
			uint32_t blue = (fg_blue * alpha + bg_blue * inv_alpha) / 64;

			*dest = 0xff000000 | (red << 16) | (green << 8) | blue;
			source += sincr;
			dest += pitch;
		} while (--count);
	}
};

class RtShaded4colsRGBACommand : public DrawerCommand
{
	int sx;
	int yl;
	int yh;
	lighttable_t * RESTRICT _colormap;
	int _color;
	BYTE * RESTRICT _destorg;
	int _pitch;
	fixed_t _light;

public:
	RtShaded4colsRGBACommand(int sx, int yl, int yh)
	{
		this->sx = sx;
		this->yl = yl;
		this->yh = yh;

		_colormap = dc_colormap;
		_color = dc_color;
		_destorg = dc_destorg;
		_pitch = dc_pitch;
		_light = dc_light;
	}

	void Execute(DrawerThread *thread) override
	{
		BYTE *colormap;
		uint32_t *source;
		uint32_t *dest;
		int count;
		int pitch;
		int sincr;

		count = thread->count_for_thread(yl, yh - yl + 1);
		if (count <= 0)
			return;

		colormap = _colormap;
		dest = thread->dest_for_thread(yl, _pitch, ylookup[yl] + sx + (uint32_t*)_destorg);
		source = &thread->dc_temp_rgba[yl * 4] + thread->skipped_by_thread(yl) * 4;
		pitch = _pitch * thread->num_cores;
		sincr = 4 * thread->num_cores;

		uint32_t fg = LightBgra::shade_pal_index_simple(_color, LightBgra::calc_light_multiplier(_light));
		uint32_t fg_red = (fg >> 16) & 0xff;
		uint32_t fg_green = (fg >> 8) & 0xff;
		uint32_t fg_blue = fg & 0xff;

		do {
			for (int i = 0; i < 4; i++)
			{
				uint32_t alpha = colormap[source[i]];
				uint32_t inv_alpha = 64 - alpha;

				uint32_t bg_red = (dest[i] >> 16) & 0xff;
				uint32_t bg_green = (dest[i] >> 8) & 0xff;
				uint32_t bg_blue = (dest[i]) & 0xff;

				uint32_t red = (fg_red * alpha + bg_red * inv_alpha) / 64;
				uint32_t green = (fg_green * alpha + bg_green * inv_alpha) / 64;
				uint32_t blue = (fg_blue * alpha + bg_blue * inv_alpha) / 64;

				dest[i] = 0xff000000 | (red << 16) | (green << 8) | blue;
			}
			source += sincr;
			dest += pitch;
		} while (--count);
	}
};

class RtAddClamp1colRGBACommand : public DrawerCommand
{
	int hx;
	int sx;
	int yl;
	int yh;
	BYTE * RESTRICT _destorg;
	int _pitch;
	fixed_t _light;
	ShadeConstants _shade_constants;
	fixed_t _srcalpha;
	fixed_t _destalpha;

public:
	RtAddClamp1colRGBACommand(int hx, int sx, int yl, int yh)
	{
		this->hx = hx;
		this->sx = sx;
		this->yl = yl;
		this->yh = yh;

		_destorg = dc_destorg;
		_pitch = dc_pitch;
		_light = dc_light;
		_shade_constants = dc_shade_constants;
		_srcalpha = dc_srcalpha;
		_destalpha = dc_destalpha;
	}

	void Execute(DrawerThread *thread) override
	{
		uint32_t *source;
		uint32_t *dest;
		int count;
		int pitch;
		int sincr;

		count = thread->count_for_thread(yl, yh - yl + 1);
		if (count <= 0)
			return;

		dest = thread->dest_for_thread(yl, _pitch, ylookup[yl] + sx + (uint32_t*)_destorg);
		source = &thread->dc_temp_rgba[yl * 4 + hx] + thread->skipped_by_thread(yl) * 4;
		pitch = _pitch * thread->num_cores;
		sincr = 4 * thread->num_cores;

		uint32_t light = LightBgra::calc_light_multiplier(_light);
		ShadeConstants shade_constants = _shade_constants;

		uint32_t fg_alpha = _srcalpha >> (FRACBITS - 8);
		uint32_t bg_alpha = _destalpha >> (FRACBITS - 8);

		do {
			uint32_t fg = LightBgra::shade_pal_index(*source, light, shade_constants);
			uint32_t fg_red = (fg >> 16) & 0xff;
			uint32_t fg_green = (fg >> 8) & 0xff;
			uint32_t fg_blue = fg & 0xff;

			uint32_t bg_red = (*dest >> 16) & 0xff;
			uint32_t bg_green = (*dest >> 8) & 0xff;
			uint32_t bg_blue = (*dest) & 0xff;

			uint32_t red = clamp<uint32_t>((fg_red * fg_alpha + bg_red * bg_alpha) / 256, 0, 255);
			uint32_t green = clamp<uint32_t>((fg_green * fg_alpha + bg_green * bg_alpha) / 256, 0, 255);
			uint32_t blue = clamp<uint32_t>((fg_blue * fg_alpha + bg_blue * bg_alpha) / 256, 0, 255);

			*dest = 0xff000000 | (red << 16) | (green << 8) | blue;
			source += sincr;
			dest += pitch;
		} while (--count);
	}
};

class RtAddClamp4colsRGBACommand : public DrawerCommand
{
	int sx;
	int yl;
	int yh;
	BYTE * RESTRICT _destorg;
	int _pitch;
	fixed_t _light;
	fixed_t _srcalpha;
	fixed_t _destalpha;
	ShadeConstants _shade_constants;

public:
	RtAddClamp4colsRGBACommand(int sx, int yl, int yh)
	{
		this->sx = sx;
		this->yl = yl;
		this->yh = yh;

		_destorg = dc_destorg;
		_pitch = dc_pitch;
		_light = dc_light;
		_srcalpha = dc_srcalpha;
		_destalpha = dc_destalpha;
		_shade_constants = dc_shade_constants;
	}

	void Execute(DrawerThread *thread) override
	{
		uint32_t *source;
		uint32_t *dest;
		int count;
		int pitch;
		int sincr;

		count = thread->count_for_thread(yl, yh - yl + 1);
		if (count <= 0)
			return;

		dest = thread->dest_for_thread(yl, _pitch, ylookup[yl] + sx + (uint32_t*)_destorg);
		source = &thread->dc_temp_rgba[yl * 4] + thread->skipped_by_thread(yl) * 4;
		pitch = _pitch * thread->num_cores;
		sincr = 4 * thread->num_cores;

		uint32_t light = LightBgra::calc_light_multiplier(_light);
		ShadeConstants shade_constants = _shade_constants;

		uint32_t fg_alpha = _srcalpha >> (FRACBITS - 8);
		uint32_t bg_alpha = _destalpha >> (FRACBITS - 8);

		do {
			for (int i = 0; i < 4; i++)
			{
				uint32_t fg = LightBgra::shade_pal_index(source[i], light, shade_constants);
				uint32_t fg_red = (fg >> 16) & 0xff;
				uint32_t fg_green = (fg >> 8) & 0xff;
				uint32_t fg_blue = fg & 0xff;

				uint32_t bg_red = (dest[i] >> 16) & 0xff;
				uint32_t bg_green = (dest[i] >> 8) & 0xff;
				uint32_t bg_blue = (dest[i]) & 0xff;

				uint32_t red = clamp<uint32_t>((fg_red * fg_alpha + bg_red * bg_alpha) / 256, 0, 255);
				uint32_t green = clamp<uint32_t>((fg_green * fg_alpha + bg_green * bg_alpha) / 256, 0, 255);
				uint32_t blue = clamp<uint32_t>((fg_blue * fg_alpha + bg_blue * bg_alpha) / 256, 0, 255);

				dest[i] = 0xff000000 | (red << 16) | (green << 8) | blue;
			}
			source += sincr;
			dest += pitch;
		} while (--count);
	}
};

class RtSubClamp1colRGBACommand : public DrawerCommand
{
	int hx;
	int sx;
	int yl;
	int yh;
	BYTE * RESTRICT _destorg;
	int _pitch;
	fixed_t _light;
	fixed_t _srcalpha;
	fixed_t _destalpha;
	ShadeConstants _shade_constants;

public:
	RtSubClamp1colRGBACommand(int hx, int sx, int yl, int yh)
	{
		this->hx = hx;
		this->sx = sx;
		this->yl = yl;
		this->yh = yh;

		_destorg = dc_destorg;
		_pitch = dc_pitch;
		_light = dc_light;
		_srcalpha = dc_srcalpha;
		_destalpha = dc_destalpha;
		_shade_constants = dc_shade_constants;
	}

	void Execute(DrawerThread *thread) override
	{
		uint32_t *source;
		uint32_t *dest;
		int count;
		int pitch;
		int sincr;

		count = thread->count_for_thread(yl, yh - yl + 1);
		if (count <= 0)
			return;

		dest = thread->dest_for_thread(yl, _pitch, ylookup[yl] + sx + (uint32_t*)_destorg);
		source = &thread->dc_temp_rgba[yl * 4 + hx] + thread->skipped_by_thread(yl) * 4;
		pitch = _pitch * thread->num_cores;
		sincr = 4 * thread->num_cores;

		uint32_t light = LightBgra::calc_light_multiplier(_light);
		ShadeConstants shade_constants = _shade_constants;

		uint32_t fg_alpha = _srcalpha >> (FRACBITS - 8);
		uint32_t bg_alpha = _destalpha >> (FRACBITS - 8);

		do {
			uint32_t fg = LightBgra::shade_pal_index(*source, light, shade_constants);
			uint32_t fg_red = (fg >> 16) & 0xff;
			uint32_t fg_green = (fg >> 8) & 0xff;
			uint32_t fg_blue = fg & 0xff;

			uint32_t bg_red = (*dest >> 16) & 0xff;
			uint32_t bg_green = (*dest >> 8) & 0xff;
			uint32_t bg_blue = (*dest) & 0xff;

			uint32_t red = clamp<uint32_t>((0x10000 - fg_red * fg_alpha + bg_red * bg_alpha) / 256, 256, 256 + 255) - 256;
			uint32_t green = clamp<uint32_t>((0x10000 - fg_green * fg_alpha + bg_green * bg_alpha) / 256, 256, 256 + 255) - 256;
			uint32_t blue = clamp<uint32_t>((0x10000 - fg_blue * fg_alpha + bg_blue * bg_alpha) / 256, 256, 256 + 255) - 256;

			*dest = 0xff000000 | (red << 16) | (green << 8) | blue;
			source += sincr;
			dest += pitch;
		} while (--count);
	}
};

class RtSubClamp4colsRGBACommand : public DrawerCommand
{
	int sx;
	int yl;
	int yh;
	BYTE * RESTRICT _destorg;
	int _pitch;
	fixed_t _light;
	fixed_t _srcalpha;
	fixed_t _destalpha;
	ShadeConstants _shade_constants;

public:
	RtSubClamp4colsRGBACommand(int sx, int yl, int yh)
	{
		this->sx = sx;
		this->yl = yl;
		this->yh = yh;

		_destorg = dc_destorg;
		_pitch = dc_pitch;
		_light = dc_light;
		_srcalpha = dc_srcalpha;
		_destalpha = dc_destalpha;
		_shade_constants = dc_shade_constants;
	}

	void Execute(DrawerThread *thread) override
	{
		uint32_t *source;
		uint32_t *dest;
		int count;
		int pitch;
		int sincr;

		count = thread->count_for_thread(yl, yh - yl + 1);
		if (count <= 0)
			return;

		dest = thread->dest_for_thread(yl, _pitch, ylookup[yl] + sx + (uint32_t*)_destorg);
		source = &thread->dc_temp_rgba[yl * 4] + thread->skipped_by_thread(yl) * 4;
		pitch = _pitch * thread->num_cores;
		sincr = 4 * thread->num_cores;

		uint32_t light = LightBgra::calc_light_multiplier(_light);
		ShadeConstants shade_constants = _shade_constants;

		uint32_t fg_alpha = _srcalpha >> (FRACBITS - 8);
		uint32_t bg_alpha = _destalpha >> (FRACBITS - 8);

		do {
			for (int i = 0; i < 4; i++)
			{
				uint32_t fg = LightBgra::shade_pal_index(source[i], light, shade_constants);
				uint32_t fg_red = (fg >> 16) & 0xff;
				uint32_t fg_green = (fg >> 8) & 0xff;
				uint32_t fg_blue = fg & 0xff;

				uint32_t bg_red = (dest[i] >> 16) & 0xff;
				uint32_t bg_green = (dest[i] >> 8) & 0xff;
				uint32_t bg_blue = (dest[i]) & 0xff;

				uint32_t red = clamp<uint32_t>((0x10000 - fg_red * fg_alpha + bg_red * bg_alpha) / 256, 256, 256 + 255) - 256;
				uint32_t green = clamp<uint32_t>((0x10000 - fg_green * fg_alpha + bg_green * bg_alpha) / 256, 256, 256 + 255) - 256;
				uint32_t blue = clamp<uint32_t>((0x10000 - fg_blue * fg_alpha + bg_blue * bg_alpha) / 256, 256, 256 + 255) - 256;

				dest[i] = 0xff000000 | (red << 16) | (green << 8) | blue;
			}

			source += sincr;
			dest += pitch;
		} while (--count);
	}
};

class RtRevSubClamp1colRGBACommand : public DrawerCommand
{
	int hx;
	int sx;
	int yl;
	int yh;
	BYTE * RESTRICT _destorg;
	int _pitch;
	fixed_t _light;
	fixed_t _srcalpha;
	fixed_t _destalpha;
	ShadeConstants _shade_constants;

public:
	RtRevSubClamp1colRGBACommand(int hx, int sx, int yl, int yh)
	{
		this->hx = hx;
		this->sx = sx;
		this->yl = yl;
		this->yh = yh;

		_destorg = dc_destorg;
		_pitch = dc_pitch;
		_light = dc_light;
		_srcalpha = dc_srcalpha;
		_destalpha = dc_destalpha;
		_shade_constants = dc_shade_constants;
	}

	void Execute(DrawerThread *thread) override
	{
		uint32_t *source;
		uint32_t *dest;
		int count;
		int pitch;
		int sincr;

		count = thread->count_for_thread(yl, yh - yl + 1);
		if (count <= 0)
			return;

		dest = thread->dest_for_thread(yl, _pitch, ylookup[yl] + sx + (uint32_t*)_destorg);
		source = &thread->dc_temp_rgba[yl * 4 + hx] + thread->skipped_by_thread(yl) * 4;
		pitch = _pitch * thread->num_cores;
		sincr = 4 * thread->num_cores;

		uint32_t light = LightBgra::calc_light_multiplier(_light);
		ShadeConstants shade_constants = _shade_constants;

		uint32_t fg_alpha = _srcalpha >> (FRACBITS - 8);
		uint32_t bg_alpha = _destalpha >> (FRACBITS - 8);

		do {
			uint32_t fg = LightBgra::shade_pal_index(*source, light, shade_constants);
			uint32_t fg_red = (fg >> 16) & 0xff;
			uint32_t fg_green = (fg >> 8) & 0xff;
			uint32_t fg_blue = fg & 0xff;

			uint32_t bg_red = (*dest >> 16) & 0xff;
			uint32_t bg_green = (*dest >> 8) & 0xff;
			uint32_t bg_blue = (*dest) & 0xff;

			uint32_t red = clamp<uint32_t>((0x10000 + fg_red * fg_alpha - bg_red * bg_alpha) / 256, 256, 256 + 255) - 256;
			uint32_t green = clamp<uint32_t>((0x10000 + fg_green * fg_alpha - bg_green * bg_alpha) / 256, 256, 256 + 255) - 256;
			uint32_t blue = clamp<uint32_t>((0x10000 + fg_blue * fg_alpha - bg_blue * bg_alpha) / 256, 256, 256 + 255) - 256;

			*dest = 0xff000000 | (red << 16) | (green << 8) | blue;
			source += sincr;
			dest += pitch;
		} while (--count);
	}
};

class RtRevSubClamp4colsRGBACommand : public DrawerCommand
{
	int sx;
	int yl;
	int yh;
	BYTE * RESTRICT _destorg;
	int _pitch;
	fixed_t _light;
	fixed_t _srcalpha;
	fixed_t _destalpha;
	ShadeConstants _shade_constants;

public:
	RtRevSubClamp4colsRGBACommand(int sx, int yl, int yh)
	{
		this->sx = sx;
		this->yl = yl;
		this->yh = yh;

		_destorg = dc_destorg;
		_pitch = dc_pitch;
		_light = dc_light;
		_srcalpha = dc_srcalpha;
		_destalpha = dc_destalpha;
		_shade_constants = dc_shade_constants;
	}

	void Execute(DrawerThread *thread) override
	{
		uint32_t *source;
		uint32_t *dest;
		int count;
		int pitch;
		int sincr;

		count = thread->count_for_thread(yl, yh - yl + 1);
		if (count <= 0)
			return;

		dest = thread->dest_for_thread(yl, _pitch, ylookup[yl] + sx + (uint32_t*)_destorg);
		source = &thread->dc_temp_rgba[yl * 4] + thread->skipped_by_thread(yl) * 4;
		pitch = _pitch * thread->num_cores;
		sincr = 4 * thread->num_cores;

		uint32_t light = LightBgra::calc_light_multiplier(_light);
		ShadeConstants shade_constants = _shade_constants;

		uint32_t fg_alpha = _srcalpha >> (FRACBITS - 8);
		uint32_t bg_alpha = _destalpha >> (FRACBITS - 8);

		do {
			for (int i = 0; i < 4; i++)
			{
				uint32_t fg = LightBgra::shade_pal_index(source[i], light, shade_constants);
				uint32_t fg_red = (fg >> 16) & 0xff;
				uint32_t fg_green = (fg >> 8) & 0xff;
				uint32_t fg_blue = fg & 0xff;

				uint32_t bg_red = (dest[i] >> 16) & 0xff;
				uint32_t bg_green = (dest[i] >> 8) & 0xff;
				uint32_t bg_blue = (dest[i]) & 0xff;

				uint32_t red = clamp<uint32_t>((0x10000 + fg_red * fg_alpha - bg_red * bg_alpha) / 256, 256, 256 + 255) - 256;
				uint32_t green = clamp<uint32_t>((0x10000 + fg_green * fg_alpha - bg_green * bg_alpha) / 256, 256, 256 + 255) - 256;
				uint32_t blue = clamp<uint32_t>((0x10000 + fg_blue * fg_alpha - bg_blue * bg_alpha) / 256, 256, 256 + 255) - 256;

				dest[i] = 0xff000000 | (red << 16) | (green << 8) | blue;
			}

			source += sincr;
			dest += pitch;
		} while (--count);
	}
};

class RtInitColsRGBACommand : public DrawerCommand
{
	BYTE * RESTRICT buff;

public:
	RtInitColsRGBACommand(BYTE *buff)
	{
		this->buff = buff;
	}

	void Execute(DrawerThread *thread) override
	{
		thread->dc_temp_rgba = buff == NULL ? thread->dc_temp_rgbabuff_rgba : (uint32_t*)buff;
	}
};

class DrawColumnHorizRGBACommand : public DrawerCommand
{
	int _count;
	fixed_t _iscale;
	fixed_t _texturefrac;
	const BYTE * RESTRICT _source;
	int _x;
	int _yl;
	int _yh;

public:
	DrawColumnHorizRGBACommand()
	{
		_count = dc_count;
		_iscale = dc_iscale;
		_texturefrac = dc_texturefrac;
		_source = dc_source;
		_x = dc_x;
		_yl = dc_yl;
		_yh = dc_yh;
	}

	void Execute(DrawerThread *thread) override
	{
		int count = _count;
		uint32_t *dest;
		fixed_t fracstep;
		fixed_t frac;

		if (count <= 0)
			return;

		{
			int x = _x & 3;
			dest = &thread->dc_temp_rgba[x + 4 * _yl];
		}
		fracstep = _iscale;
		frac = _texturefrac;

		const BYTE *source = _source;

		if (count & 1) {
			*dest = source[frac >> FRACBITS]; dest += 4; frac += fracstep;
		}
		if (count & 2) {
			dest[0] = source[frac >> FRACBITS]; frac += fracstep;
			dest[4] = source[frac >> FRACBITS]; frac += fracstep;
			dest += 8;
		}
		if (count & 4) {
			dest[0] = source[frac >> FRACBITS]; frac += fracstep;
			dest[4] = source[frac >> FRACBITS]; frac += fracstep;
			dest[8] = source[frac >> FRACBITS]; frac += fracstep;
			dest[12] = source[frac >> FRACBITS]; frac += fracstep;
			dest += 16;
		}
		count >>= 3;
		if (!count) return;

		do
		{
			dest[0] = source[frac >> FRACBITS]; frac += fracstep;
			dest[4] = source[frac >> FRACBITS]; frac += fracstep;
			dest[8] = source[frac >> FRACBITS]; frac += fracstep;
			dest[12] = source[frac >> FRACBITS]; frac += fracstep;
			dest[16] = source[frac >> FRACBITS]; frac += fracstep;
			dest[20] = source[frac >> FRACBITS]; frac += fracstep;
			dest[24] = source[frac >> FRACBITS]; frac += fracstep;
			dest[28] = source[frac >> FRACBITS]; frac += fracstep;
			dest += 32;
		} while (--count);
	}
};

class FillColumnHorizRGBACommand : public DrawerCommand
{
	int _x;
	int _yl;
	int _yh;
	int _count;
	int _color;

public:
	FillColumnHorizRGBACommand()
	{
		_x = dc_x;
		_count = dc_count;
		_color = dc_color;
		_yl = dc_yl;
		_yh = dc_yh;
	}

	void Execute(DrawerThread *thread) override
	{
		int count = _count;
		int color = _color;
		uint32_t *dest;

		if (count <= 0)
			return;

		{
			int x = _x & 3;
			dest = &thread->dc_temp_rgba[x + 4 * _yl];
		}

		if (count & 1) {
			*dest = color;
			dest += 4;
		}
		if (!(count >>= 1))
			return;
		do {
			dest[0] = color; dest[4] = color;
			dest += 8;
		} while (--count);
	}
};

/////////////////////////////////////////////////////////////////////////////

// Copies one span at hx to the screen at sx.
void rt_copy1col_rgba (int hx, int sx, int yl, int yh)
{
	DrawerCommandQueue::QueueCommand<RtCopy1colRGBACommand>(hx, sx, yl, yh);
}

// Copies all four spans to the screen starting at sx.
void rt_copy4cols_rgba (int sx, int yl, int yh)
{
	// To do: we could do this with SSE using __m128i
	rt_copy1col_rgba(0, sx, yl, yh);
	rt_copy1col_rgba(1, sx + 1, yl, yh);
	rt_copy1col_rgba(2, sx + 2, yl, yh);
	rt_copy1col_rgba(3, sx + 3, yl, yh);
}

// Maps one span at hx to the screen at sx.
void rt_map1col_rgba (int hx, int sx, int yl, int yh)
{
	DrawerCommandQueue::QueueCommand<RtMap1colRGBACommand>(hx, sx, yl, yh);
}

// Maps all four spans to the screen starting at sx.
void rt_map4cols_rgba (int sx, int yl, int yh)
{
#ifdef NO_SSE
	DrawerCommandQueue::QueueCommand<RtMap4colsRGBACommand>(sx, yl, yh);
#else
	DrawerCommandQueue::QueueCommand<RtMap4colsRGBA_SSE_Command>(sx, yl, yh);
#endif
}

void rt_Translate1col_rgba(const BYTE *translation, int hx, int yl, int yh)
{
	DrawerCommandQueue::QueueCommand<RtTranslate1colRGBACommand>(translation, hx, yl, yh);
}

void rt_Translate4cols_rgba(const BYTE *translation, int yl, int yh)
{
	DrawerCommandQueue::QueueCommand<RtTranslate4colsRGBACommand>(translation, yl, yh);
}

// Translates one span at hx to the screen at sx.
void rt_tlate1col_rgba (int hx, int sx, int yl, int yh)
{
	rt_Translate1col_rgba(dc_translation, hx, yl, yh);
	rt_map1col(hx, sx, yl, yh);
}

// Translates all four spans to the screen starting at sx.
void rt_tlate4cols_rgba (int sx, int yl, int yh)
{
	rt_Translate4cols_rgba(dc_translation, yl, yh);
	rt_map4cols(sx, yl, yh);
}

// Adds one span at hx to the screen at sx without clamping.
void rt_add1col_rgba (int hx, int sx, int yl, int yh)
{
	DrawerCommandQueue::QueueCommand<RtAdd1colRGBACommand>(hx, sx, yl, yh);
}

// Adds all four spans to the screen starting at sx without clamping.
void rt_add4cols_rgba (int sx, int yl, int yh)
{
#ifdef NO_SSE
	DrawerCommandQueue::QueueCommand<RtAdd4colsRGBACommand>(sx, yl, yh);
#else
	DrawerCommandQueue::QueueCommand<RtAdd4colsRGBA_SSE_Command>(sx, yl, yh);
#endif
}

// Translates and adds one span at hx to the screen at sx without clamping.
void rt_tlateadd1col_rgba (int hx, int sx, int yl, int yh)
{
	rt_Translate1col_rgba(dc_translation, hx, yl, yh);
	rt_add1col(hx, sx, yl, yh);
}

// Translates and adds all four spans to the screen starting at sx without clamping.
void rt_tlateadd4cols_rgba(int sx, int yl, int yh)
{
	rt_Translate4cols_rgba(dc_translation, yl, yh);
	rt_add4cols(sx, yl, yh);
}

// Shades one span at hx to the screen at sx.
void rt_shaded1col_rgba (int hx, int sx, int yl, int yh)
{
	DrawerCommandQueue::QueueCommand<RtShaded1colRGBACommand>(hx, sx, yl, yh);
}

// Shades all four spans to the screen starting at sx.
void rt_shaded4cols_rgba (int sx, int yl, int yh)
{
#ifdef NO_SSE
	DrawerCommandQueue::QueueCommand<RtShaded4colsRGBACommand>(sx, yl, yh);
#else
	DrawerCommandQueue::QueueCommand<RtShaded4colsRGBA_SSE_Command>(sx, yl, yh);
#endif
}

// Adds one span at hx to the screen at sx with clamping.
void rt_addclamp1col_rgba (int hx, int sx, int yl, int yh)
{
	DrawerCommandQueue::QueueCommand<RtAddClamp1colRGBACommand>(hx, sx, yl, yh);
}

// Adds all four spans to the screen starting at sx with clamping.
void rt_addclamp4cols_rgba (int sx, int yl, int yh)
{
#ifdef NO_SSE
	DrawerCommandQueue::QueueCommand<RtAddClamp4colsRGBACommand>(sx, yl, yh);
#else
	DrawerCommandQueue::QueueCommand<RtAddClamp4colsRGBA_SSE_Command>(sx, yl, yh);
#endif
}

// Translates and adds one span at hx to the screen at sx with clamping.
void rt_tlateaddclamp1col_rgba (int hx, int sx, int yl, int yh)
{
	rt_Translate1col_rgba(dc_translation, hx, yl, yh);
	rt_addclamp1col_rgba(hx, sx, yl, yh);
}

// Translates and adds all four spans to the screen starting at sx with clamping.
void rt_tlateaddclamp4cols_rgba (int sx, int yl, int yh)
{
	rt_Translate4cols_rgba(dc_translation, yl, yh);
	rt_addclamp4cols(sx, yl, yh);
}

// Subtracts one span at hx to the screen at sx with clamping.
void rt_subclamp1col_rgba (int hx, int sx, int yl, int yh)
{
	DrawerCommandQueue::QueueCommand<RtSubClamp1colRGBACommand>(hx, sx, yl, yh);
}

// Subtracts all four spans to the screen starting at sx with clamping.
void rt_subclamp4cols_rgba (int sx, int yl, int yh)
{
#ifdef NO_SSE
	DrawerCommandQueue::QueueCommand<RtSubClamp4colsRGBACommand>(sx, yl, yh);
#else
	DrawerCommandQueue::QueueCommand<RtSubClamp4colsRGBA_SSE_Command>(sx, yl, yh);
#endif
}

// Translates and subtracts one span at hx to the screen at sx with clamping.
void rt_tlatesubclamp1col_rgba (int hx, int sx, int yl, int yh)
{
	rt_Translate1col_rgba(dc_translation, hx, yl, yh);
	rt_subclamp1col_rgba(hx, sx, yl, yh);
}

// Translates and subtracts all four spans to the screen starting at sx with clamping.
void rt_tlatesubclamp4cols_rgba (int sx, int yl, int yh)
{
	rt_Translate4cols_rgba(dc_translation, yl, yh);
	rt_subclamp4cols_rgba(sx, yl, yh);
}

// Subtracts one span at hx from the screen at sx with clamping.
void rt_revsubclamp1col_rgba (int hx, int sx, int yl, int yh)
{
	DrawerCommandQueue::QueueCommand<RtRevSubClamp1colRGBACommand>(hx, sx, yl, yh);
}

// Subtracts all four spans from the screen starting at sx with clamping.
void rt_revsubclamp4cols_rgba (int sx, int yl, int yh)
{
#ifdef NO_SSE
	DrawerCommandQueue::QueueCommand<RtRevSubClamp4colsRGBACommand>(sx, yl, yh);
#else
	DrawerCommandQueue::QueueCommand<RtRevSubClamp4colsRGBA_SSE_Command>(sx, yl, yh);
#endif
}

// Translates and subtracts one span at hx from the screen at sx with clamping.
void rt_tlaterevsubclamp1col_rgba (int hx, int sx, int yl, int yh)
{
	rt_Translate1col_rgba(dc_translation, hx, yl, yh);
	rt_revsubclamp1col_rgba(hx, sx, yl, yh);
}

// Translates and subtracts all four spans from the screen starting at sx with clamping.
void rt_tlaterevsubclamp4cols_rgba (int sx, int yl, int yh)
{
	rt_Translate4cols_rgba(dc_translation, yl, yh);
	rt_revsubclamp4cols_rgba(sx, yl, yh);
}

// Before each pass through a rendering loop that uses these routines,
// call this function to set up the span pointers.
void rt_initcols_rgba (BYTE *buff)
{
	for (int y = 3; y >= 0; y--)
		horizspan[y] = dc_ctspan[y] = &dc_tspans[y][0];

	DrawerCommandQueue::QueueCommand<RtInitColsRGBACommand>(buff);
}

void rt_span_coverage_rgba(int x, int start, int stop)
{
	unsigned int **tspan = &dc_ctspan[x & 3];
	(*tspan)[0] = start;
	(*tspan)[1] = stop;
	*tspan += 2;
}

// Stretches a column into a temporary buffer which is later
// drawn to the screen along with up to three other columns.
void R_DrawColumnHoriz_rgba (void)
{
	if (dc_count <= 0)
		return;

	int x = dc_x & 3;
	unsigned int **span = &dc_ctspan[x];
	(*span)[0] = dc_yl;
	(*span)[1] = dc_yh;
	*span += 2;

	DrawerCommandQueue::QueueCommand<DrawColumnHorizRGBACommand>();
}

// [RH] Just fills a column with a given color
void R_FillColumnHoriz_rgba (void)
{
	if (dc_count <= 0)
		return;

	int x = dc_x & 3;
	unsigned int **span = &dc_ctspan[x];
	(*span)[0] = dc_yl;
	(*span)[1] = dc_yh;
	*span += 2;

	DrawerCommandQueue::QueueCommand<FillColumnHorizRGBACommand>();
}