/*
 Copyright (c) 2013 yvt

 This file is part of OpenSpades.

 OpenSpades is free software: you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation, either version 3 of the License, or
 (at your option) any later version.

 OpenSpades is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.

 You should have received a copy of the GNU General Public License
 along with OpenSpades.  If not, see <http://www.gnu.org/licenses/>.

 */

#include "SWImageRenderer.h"
#include "SWImage.h"
#include <Core/Bitmap.h>

namespace spades {
	namespace draw {
		SWImageRenderer::SWImageRenderer(SWFeatureLevel lvl)
		    : shader(ShaderType::Image), featureLevel(lvl) {}

		SWImageRenderer::~SWImageRenderer() {}

		void SWImageRenderer::SetFramebuffer(spades::Bitmap *bmp) {
			this->frame = bmp;
			if (bmp) {
				fbSize4 = MakeVector4(static_cast<float>(bmp->GetWidth()) * .5f,
				                      static_cast<float>(bmp->GetHeight()) * -.5f, 1.f, 1.f);
				fbCenter4 = MakeVector4(static_cast<float>(bmp->GetWidth()) * .5f,
				                        static_cast<float>(bmp->GetHeight()) * .5f, 0.f, 0.f);
			}
		}

		void SWImageRenderer::SetDepthBuffer(float *f) { depthBuffer = f; }

		void SWImageRenderer::SetShaderType(ShaderType type) { shader = type; }

		void SWImageRenderer::SetZRange(float zNear, float) {
			// currently zNear is ignored...
			this->zNear = zNear;
		}

		struct Interpolator {
			int mode; // 0:fixed point, 1/-1: bresenham

			// fixed point
			struct {
				int64_t counter;
				int64_t step;
			} fp;

			struct {
				unsigned int divisor;
				unsigned int dividend;
				unsigned int step;
				int largePos;
			} b;

			static int abs(int v) { return v < 0 ? -v : v; }

			Interpolator(int start, int end, int numSteps, bool noBresenham = true) {
				// FIXME: same sub-pixel positioning as OpenGL?
				if (abs(end - start) <= numSteps && !noBresenham) {
					int distance = end - start;
					if (distance >= 0) {
						mode = 1;
					} else {
						mode = -1;
						distance = -distance;
					}
					if (numSteps == 0)
						numSteps = 1;
					b.divisor = static_cast<unsigned int>(numSteps);
					b.dividend = 0;
					b.largePos = start;
					b.step = static_cast<unsigned int>(distance);
				} else {
					mode = 0;
					if (numSteps == 0) {
						fp.step = 0;
					} else {
						fp.step = static_cast<int64_t>(end - start) << 32;
						fp.step /= static_cast<int64_t>(numSteps);
					} /*else if(end > start){
					     unsigned int distance = end - start;
					     unsigned int large = distance / static_cast<unsigned int>(numSteps);
					     fp.step = static_cast<int64_t>(large) << 32;

					     unsigned int distance2 = distance - static_cast<unsigned int>(numSteps) *
					 large;
					     unsigned int medium = (distance2 << 12) / static_cast<unsigned
					 int>(numSteps);
					     fp.step += static_cast<int64_t>(medium) << 20;

					     unsigned int distance3 = (distance2 << 12) - static_cast<unsigned
					 int>(numSteps) * medium;
					     unsigned int small = (distance3 << 12) / static_cast<unsigned
					 int>(numSteps);
					     fp.step += static_cast<int64_t>(small) << 8;


					 }else{
					     unsigned int distance = start - end;
					     unsigned int large = distance / static_cast<unsigned int>(numSteps);
					     fp.step = static_cast<int64_t>(large) << 32;

					     unsigned int distance2 = distance - static_cast<unsigned int>(numSteps) *
					 large;
					     unsigned int medium = (distance2 << 12) / static_cast<unsigned
					 int>(numSteps);
					     fp.step += static_cast<int64_t>(medium) << 20;

					     unsigned int distance3 = (distance2 << 12) - static_cast<unsigned
					 int>(numSteps) * medium;
					     unsigned int small = (distance3 << 12) / static_cast<unsigned
					 int>(numSteps);
					     fp.step += static_cast<int64_t>(small) << 8;

					     fp.step = -fp.step;
					 }*/
					fp.counter = static_cast<int64_t>(start) << 32;
				}
			}
			int GetCurrent() {
				if (mode != 0)
					return b.largePos;
				return static_cast<int>(fp.counter >> 32);
			}
			void MoveNext() {
				if (mode == 0) {
					fp.counter += fp.step;
				} else {
					b.dividend += b.step;
					while (b.dividend >= b.divisor) {
						b.dividend -= b.divisor;
						b.largePos += mode;
					}
				}
			}
			void MoveNext(int numSteps) {
				if (mode == 0) {
					if (numSteps == 1)
						MoveNext();
					else if (numSteps == 0)
						return;
					else
						fp.counter += fp.step * static_cast<int64_t>(numSteps);
				} else {
					if (numSteps < 4) {
						while (numSteps--)
							MoveNext();
					} else {
						unsigned long long d = b.dividend;
						d += static_cast<unsigned long long>(b.step *
						                                     static_cast<unsigned int>(numSteps));
						unsigned long long cnt = d / b.divisor;
						d -= cnt * b.divisor;
						b.dividend = static_cast<unsigned int>(d);
						b.largePos += mode * static_cast<int>(cnt);
					}
				}
			}
		};

		enum { texUVScaleBits = 16, texUVScaleInt = 1 << texUVScaleBits };
		static const float texUVScaleFloat = static_cast<float>(texUVScaleInt);

		struct SWImageVarying {
			union {
				struct {
					int u, v;
				};
#if ENABLE_SSE2
				__m128i uv_m128; // [u32, ?32, v32, ?32]
#endif
			};
#if __cplusplus >= 201103L
			SWImageVarying() = default; // POD
#else
			SWImageVarying() {} // non-POD
#endif
			SWImageVarying(int u, int v) : u(u), v(v) {}

			SWImageVarying(const SWImageRenderer::Vertex &v)
			    : u(static_cast<int>(v.uv.x * texUVScaleFloat + .5f)),
			      v(static_cast<int>(v.uv.y * texUVScaleFloat + .5f)) {}
		};

		template <SWFeatureLevel level> struct SWImageGouraudInterpolator {
			Interpolator u, v;
			SWImageGouraudInterpolator(const SWImageVarying &start, const SWImageVarying &end,
			                           int numSteps)
			    : u(start.u, end.u, numSteps), v(start.v, end.v, numSteps) {}

			SWImageVarying GetCurrent() { return SWImageVarying(u.GetCurrent(), v.GetCurrent()); }

			void MoveNext(int s) {
				u.MoveNext(s);
				v.MoveNext(s);
			}

			void MoveNext() {
				u.MoveNext();
				v.MoveNext();
			}
		};

#if ENABLE_SSE2
		template <> struct SWImageGouraudInterpolator<SWFeatureLevel::SSE2> {
			Interpolator u, v;

			union {
				__m128i uv;
				struct {
					int64_t uvU, uvV;
				};
			};
			union {
				__m128i uvStep;
				struct {
					int64_t stepU, stepV;
				};
			};

			inline SWImageGouraudInterpolator(const SWImageVarying &start,
			                                  const SWImageVarying &end, int numSteps)
			    : u(start.u, end.u, numSteps, true), v(start.v, end.v, numSteps, true) {
				uvU = u.fp.counter;
				uvV = v.fp.counter;
				stepU = u.fp.step;
				stepV = v.fp.step;
			}

			inline SWImageVarying GetCurrent() {
				SWImageVarying varying;
				varying.uv_m128 = _mm_shuffle_epi32(uv, 0x3d);
				return varying;
			}

			inline void MoveNext(int s) {
				if (s == 0)
					return;
				else if (s < 4) {
					auto v = uv, st = uvStep;
					while (s--) {
						v = _mm_add_epi64(v, st);
					}
					uv = v;
				} else {
					// no SSE2 support for 64bit multiply, but
					// this isn't a big problem because this case is rare
					uvU += stepU * s;
					uvV += stepV * s;
				}
			}

			inline void MoveNext() { uv = _mm_add_epi64(uv, uvStep); }
		};
#endif

#pragma mark - Polygon Renderer Main

		template <SWFeatureLevel level, bool needTransform,
		          bool ndc, // normalized device coordinate
		          bool depthTest, bool solidFill, bool linearInterpolate>
		struct SWImageRenderer::PolygonRenderer {

			static_assert(!needTransform, "Transform pass was not selected");
			static_assert(!ndc, "Denormalize pass was not selected");

			static void DrawPolygonInternalInner(SWImage *img, const Vertex &v1, const Vertex &v2,
			                                     const Vertex &v3, SWImageRenderer &r) {
				// TODO: support null image

				Bitmap *const fb = r.frame;
				SPAssert(fb != nullptr);

				if (v3.position.y <= 0.f) {
					// viewport cull
					return;
				}

				const int fbW = fb->GetWidth();
				const int fbH = fb->GetHeight();
				uint32_t *const bmp = fb->GetPixels();

				if (v1.position.y >= static_cast<float>(fbH)) {
					// viewport cull
					return;
				}

				float *const depthBuffer = r.depthBuffer;
				if (depthTest) {
					SPAssert(depthBuffer != nullptr);
				}

				uint32_t *const tpixels = img->GetRawBitmap();
				const int tw = img->GetRawWidth();
				const int th = img->GetRawHeight();

				const int x1 = static_cast<int>(v1.position.x);
				const int y1 = static_cast<int>(v1.position.y);
				const int x2 = static_cast<int>(v2.position.x);
				const int y2 = static_cast<int>(v2.position.y);
				const int x3 = static_cast<int>(v3.position.x);
				const int y3 = static_cast<int>(v3.position.y);

				if (x1 == x2 && x2 == x3)
					return; // area cull
				if (y1 == y3)
					return; // area cull
				if (std::min(std::min(x1, x2), x3) >= fbW)
					return; // viewport cull
				if (std::max(std::max(x1, x2), x3) <= 0)
					return; // viewport cull

				auto convertColor = [](float f) {
					int i = static_cast<int>(f * 256.f + .5f);
					return static_cast<unsigned short>(std::max(std::min(i, 256), 0));
				};
				unsigned short mulR = convertColor(v1.color.z);
				unsigned short mulG = convertColor(v1.color.y);
				unsigned short mulB = convertColor(v1.color.x);
				unsigned short mulA = convertColor(v1.color.w);

				if (mulA == 0 && mulR == 0 && mulG == 0 && mulB == 0)
					return;

				// unreal-ish linear interpolation by using dither
				int16_t ditherBaseX =
				  static_cast<int16_t>((1 << (texUVScaleBits - 2)) * img->GetInvWidth());
				int16_t ditherBaseY =
				  static_cast<int16_t>((1 << (texUVScaleBits - 2)) * img->GetInvHeight());
				int16_t ditherMap[] = {
				  static_cast<int16_t>(-ditherBaseX),
				  static_cast<int16_t>(-ditherBaseY << 1),
				  0,
				  static_cast<int16_t>(ditherBaseY),
				  static_cast<int16_t>(ditherBaseX),
				  0,
				  static_cast<int16_t>(-ditherBaseX << 1),
				  static_cast<int16_t>(-ditherBaseY),
				};

				auto drawPixel = [mulR, mulG, mulB, mulA](uint32_t &dest, float &destDepth,
				                                          uint32_t texture, float inDepth) {
					if (depthTest) {
						if (inDepth > destDepth) {
							return;
						}
					}

					if (texture == 0)
						return; // transparent

					unsigned int ta = static_cast<unsigned int>(texture >> 24);
					ta += (ta >> 7); // [0, 255] -> [0, 256]

					if (ta == 256 && mulA == 256) {
						// opaque
						unsigned int tr = static_cast<unsigned int>((texture >> 0) & 0xff);
						unsigned int tg = static_cast<unsigned int>((texture >> 8) & 0xff);
						unsigned int tb = static_cast<unsigned int>((texture >> 16) & 0xff);
						tr = (tr * mulR) >> 8;
						tg = (tg * mulG) >> 8;
						tb = (tb * mulB) >> 8;
						ta = (ta * mulA) >> 8;
						dest = tr | (tg << 8) | (tb << 16);
						return;
					}

					// already premultiplied. see SWImage.cpp
					unsigned int tr = static_cast<unsigned int>((texture >> 0) & 0xff);
					unsigned int tg = static_cast<unsigned int>((texture >> 8) & 0xff);
					unsigned int tb = static_cast<unsigned int>((texture >> 16) & 0xff);
					tr = (tr * mulR) >> 8;
					tg = (tg * mulG) >> 8;
					tb = (tb * mulB) >> 8;
					ta = (ta * mulA) >> 8;

					uint32_t destCol = dest;
					unsigned int dr = static_cast<unsigned int>((destCol >> 0) & 0xff);
					unsigned int dg = static_cast<unsigned int>((destCol >> 8) & 0xff);
					unsigned int db = static_cast<unsigned int>((destCol >> 16) & 0xff);
					unsigned int invA = 256 - ta;
					dr = (dr * invA) >> 8;
					dg = (dg * invA) >> 8;
					db = (db * invA) >> 8;

					unsigned int outR = tr + dr, outG = tg + dg, outB = tb + db;
					outR = std::min(outR, 255U);
					outG = std::min(outG, 255U);
					outB = std::min(outB, 255U);

					dest = outR | (outG << 8) | (outB << 16);
				};

				auto drawScanline = [tw, th, tpixels, bmp, fbW, fbH, depthBuffer, &drawPixel, &r,
				                     &ditherMap](int y, int x1, int x2, const SWImageVarying &vary1,
				                                 const SWImageVarying &vary2, float z1, float z2) {
					uint32_t *out = bmp + (y * fbW);
					float *depthOut = nullptr;
					if (depthTest) {
						depthOut = depthBuffer + (y * fbW);
					}
					SPAssert(x1 < x2);
					int width = x2 - x1;
					SWImageGouraudInterpolator<level> vary(vary1, vary2, width);
					int minX = std::max(x1, 0);
					int maxX = std::min(x2, fbW);
					vary.MoveNext(minX - x1);
					out += minX;
					if (depthTest) {
						depthOut += minX;
					}
					r.pixelsDrawn += maxX - minX;
					auto *ditherMap2 = ditherMap + ((y & 1) << 2);
					for (int x = minX; x < maxX; x++) {
						auto vr = vary.GetCurrent();
						unsigned int u = static_cast<unsigned int>(vr.u);
						unsigned int v = static_cast<unsigned int>(vr.v);
						if (linearInterpolate) {
							uint8_t idx = static_cast<uint8_t>(x & 1);
							u += ditherMap2[idx * 2];
							v += ditherMap2[idx * 2 + 1];
						}
						u &= texUVScaleInt - 1;
						v &= texUVScaleInt - 1;
						u = (u * tw) >> texUVScaleBits;
						v = (v * th) >> texUVScaleBits;
						uint32_t tex = tpixels[u + v * tw];
						// FIXME: Z interpolation
						// FIXME: perspective correction
						drawPixel(*out, *depthOut, tex, z1);
						out++;
						if (depthTest) {
							depthOut++;
						}
						vary.MoveNext();
					}
				};

				// FIXME: interpolated Z

				Interpolator longSpanX(x1, x3, y3 - y1);
				SWImageGouraudInterpolator<level> longSpan(v1, v3, y3 - y1);
				{
					Interpolator shortSpanX(x1, x2, y2 - y1);
					SWImageGouraudInterpolator<level> shortSpan(v1, v2, y2 - y1);
					int minY = std::max(0, y1);
					int maxY = std::min(fbH, y2);
					shortSpanX.MoveNext(minY - y1);
					shortSpan.MoveNext(minY - y1);
					longSpanX.MoveNext(minY - y1);
					longSpan.MoveNext(minY - y1);
					for (int y = minY; y < maxY; y++) {
						int lineX1 = shortSpanX.GetCurrent();
						auto line1 = shortSpan.GetCurrent();
						int lineX2 = longSpanX.GetCurrent();
						auto line2 = longSpan.GetCurrent();
						shortSpanX.MoveNext();
						shortSpan.MoveNext();
						longSpanX.MoveNext();
						longSpan.MoveNext();
						if (lineX1 == lineX2)
							continue;
						if (lineX1 < lineX2) {
							drawScanline(y, lineX1, lineX2, line1, line2, v1.position.z,
							             v1.position.z);
						} else {
							drawScanline(y, lineX2, lineX1, line2, line1, v1.position.z,
							             v1.position.z);
						}
					}
				}
				{
					Interpolator shortSpanX(x2, x3, y3 - y2);
					SWImageGouraudInterpolator<level> shortSpan(v2, v3, y3 - y2);
					int minY = std::max(0, y2);
					int maxY = std::min(fbH, y3);
					shortSpanX.MoveNext(minY - y2);
					shortSpan.MoveNext(minY - y2);
					longSpanX.MoveNext(minY - y2);
					longSpan.MoveNext(minY - y2);
					for (int y = minY; y < maxY; y++) {
						int lineX1 = shortSpanX.GetCurrent();
						auto line1 = shortSpan.GetCurrent();
						int lineX2 = longSpanX.GetCurrent();
						auto line2 = longSpan.GetCurrent();
						shortSpanX.MoveNext();
						shortSpan.MoveNext();
						longSpanX.MoveNext();
						longSpan.MoveNext();
						if (lineX1 == lineX2)
							continue;
						if (lineX1 < lineX2) {
							drawScanline(y, lineX1, lineX2, line1, line2, v1.position.z,
							             v1.position.z);
						} else {
							drawScanline(y, lineX2, lineX1, line2, line1, v1.position.z,
							             v1.position.z);
						}
					}
				}
				// polygon, done!
			}

			static void DrawPolygonInternal(SWImage *img, const Vertex &v1, const Vertex &v2,
			                                const Vertex &v3, SWImageRenderer &r) {
				if (v2.position.y < v1.position.y) {
					if (v3.position.y < v2.position.y) {
						DrawPolygonInternalInner(img, v3, v2, v1, r);
					} else if (v3.position.y < v1.position.y) {
						DrawPolygonInternalInner(img, v2, v3, v1, r);
					} else {
						DrawPolygonInternalInner(img, v2, v1, v3, r);
					}
				} else if (v3.position.y < v1.position.y) {
					DrawPolygonInternalInner(img, v3, v1, v2, r);
				} else if (v3.position.y < v2.position.y) {
					DrawPolygonInternalInner(img, v1, v3, v2, r);
				} else {
					DrawPolygonInternalInner(img, v1, v2, v3, r);
				}
			}
		};

// TODO: Non-SSE2 renderer for solid polygons

#pragma mark - SSE2
#if ENABLE_SSE2

#pragma mark General
		template <bool depthTest, bool linearInterpolate>
		struct SWImageRenderer::PolygonRenderer<SWFeatureLevel::SSE2, false, false, depthTest,
		                                        false, linearInterpolate> {

			static void DrawPolygonInternalInner(SWImage *img, const Vertex &v1, const Vertex &v2,
			                                     const Vertex &v3, SWImageRenderer &r) {

				Bitmap *const fb = r.frame;
				SPAssert(fb != nullptr);

				if (v3.position.y <= 0.f) {
					// viewport cull
					return;
				}

				const int fbW = fb->GetWidth();
				const int fbH = fb->GetHeight();
				uint32_t *const bmp = fb->GetPixels();

				if (v1.position.y >= static_cast<float>(fbH)) {
					// viewport cull
					return;
				}

				float *const depthBuffer = r.depthBuffer;
				if (depthTest) {
					SPAssert(depthBuffer != nullptr);
				}

				uint32_t *const tpixels = img->GetRawBitmap();
				const int tw = img->GetRawWidth();
				const int th = img->GetRawHeight();

				const int x1 = static_cast<int>(v1.position.x);
				const int y1 = static_cast<int>(v1.position.y);
				const int x2 = static_cast<int>(v2.position.x);
				const int y2 = static_cast<int>(v2.position.y);
				const int x3 = static_cast<int>(v3.position.x);
				const int y3 = static_cast<int>(v3.position.y);

				if (x1 == x2 && x2 == x3)
					return; // area cull
				if (y1 == y3)
					return; // area cull
				if (std::min(std::min(x1, x2), x3) >= fbW)
					return; // viewport cull
				if (std::max(std::max(x1, x2), x3) <= 0)
					return; // viewport cull

				auto convertColor = [](float f) {
					int i = static_cast<int>(f * 256.f + .5f);
					return static_cast<unsigned short>(std::max(std::min(i, 256), 0));
				};
				unsigned short mulR = convertColor(v1.color.x);
				unsigned short mulG = convertColor(v1.color.y);
				unsigned short mulB = convertColor(v1.color.z);
				unsigned short mulA = convertColor(v1.color.w);

				if (mulA == 0 && mulR == 0 && mulG == 0 && mulB == 0)
					return;

				// unreal-ish linear interpolation by using dither
				int16_t ditherBaseX =
				  static_cast<int16_t>((1 << (texUVScaleBits - 2)) * img->GetInvWidth());
				int16_t ditherBaseY =
				  static_cast<int16_t>((1 << (texUVScaleBits - 2)) * img->GetInvHeight());
				int16_t ditherMap[] = {
				  static_cast<int16_t>(-ditherBaseX),
				  static_cast<int16_t>(-ditherBaseY << 1),
				  0,
				  static_cast<int16_t>(ditherBaseY),
				  static_cast<int16_t>(ditherBaseX),
				  0,
				  static_cast<int16_t>(-ditherBaseX << 1),
				  static_cast<int16_t>(-ditherBaseY),
				};

				__m128i ditherMap2[] = {
				  _mm_setr_epi32(ditherMap[0], ditherMap[1], ditherMap[2], ditherMap[3]),
				  _mm_setr_epi32(ditherMap[4], ditherMap[5], ditherMap[6], ditherMap[7])};

				__m128i mulCol = _mm_setr_epi16(mulB, mulG, mulR, mulA, mulB, mulG, mulR, mulA);

				auto drawPixel = [mulCol, mulA](uint32_t &dest, float &destDepth, uint32_t texture,
				                                float inDepth) {
					if (depthTest) {
						if (inDepth > destDepth) {
							return;
						}
					}

					if (texture == 0)
						return; // transparent

					unsigned int ta = static_cast<unsigned int>(texture >> 24);
					ta += (ta >> 7); // [0, 255] -> [0, 256]

					// load [u8.0x4]
					__m128i tcol = _mm_setr_epi32(texture, 0, 0, 0);

					// convert to [u16.0x4], 8bit width
					tcol = _mm_unpacklo_epi8(tcol, _mm_setzero_si128());
					// tcol = _mm_shufflelo_epi16(tcol, 0b11000110); // swap BGR/RGB

					if (ta == 256 && mulA == 256) {
						// opaque
						tcol = _mm_mullo_epi16(tcol, mulCol);

						// pack.
						tcol = _mm_srli_epi16(tcol, 8);
						tcol = _mm_packus_epi16(tcol, tcol);

						// store.
						_mm_store_ss(reinterpret_cast<float *>(&dest), _mm_castsi128_ps(tcol));

						return;
					}

					// tcol is already premultiplied. see SWImage.cpp

					// modulate by the constant color. now [u8.8x4], 8bit width
					tcol = _mm_mullo_epi16(tcol, mulCol);

					// broadcast the alpha of the tcol.
					__m128i tcolAlphaVec = _mm_shufflelo_epi16(tcol, 0xff);

					// make tcol [u8.8x4]
					// tcol = _mm_slli_epi16(tcol, 1);
					tcolAlphaVec = _mm_srli_epi16(tcolAlphaVec, 8); // make [u16x4]8bw
					tcolAlphaVec = _mm_add_epi16(
					  tcolAlphaVec, _mm_srli_epi16(tcolAlphaVec, 7)); // [0,255] -> [0,256]

					// inverse the alpha
					tcolAlphaVec = _mm_sub_epi16(_mm_set1_epi16(0x100), tcolAlphaVec);

					// load [u8.0x4]
					__m128i dcol = _mm_setr_epi32(dest, 0, 0, 0);

					// convert to [u16.0x4], 8bit width
					dcol = _mm_unpacklo_epi8(dcol, _mm_setzero_si128());

					// modulate by inversed src alpha.
					// now [u8.8 x 4]
					dcol = _mm_mullo_epi16(dcol, tcolAlphaVec);

					// additive blending with saturation.
					dcol = _mm_adds_epu16(dcol, tcol);

					// pack.
					dcol = _mm_srli_epi16(dcol, 8);
					dcol = _mm_packus_epi16(dcol, dcol);

					// store.
					_mm_store_ss(reinterpret_cast<float *>(&dest), _mm_castsi128_ps(dcol));
				};

				auto drawPixel2 = [mulCol, mulA, &drawPixel](uint32_t *dest, float *destDepth,
				                                             uint32_t texture1, float inDepth1,
				                                             uint32_t texture2, float inDepth2) {
					if (depthTest) {
						if (inDepth1 > destDepth[0]) {
							drawPixel(dest[1], destDepth[1], texture2, inDepth2);
							return;
						}
						if (inDepth2 > destDepth[1]) {
							drawPixel(dest[0], destDepth[0], texture2, inDepth2);
							return;
						}
					}

					if (texture1 == 0 && texture2 == 0)
						return; // transparent

					// load [u8.0x4]
					__m128i tcol = _mm_setr_epi32(texture1, texture2, 0, 0);

					// convert to [u16.0x4, u16.0x4], 8bit width
					tcol = _mm_unpacklo_epi8(tcol, _mm_setzero_si128());
					// tcol = _mm_shufflelo_epi16(tcol, 0b11000110); // swap BGR/RGB
					// tcol = _mm_shufflehi_epi16(tcol, 0b11000110); // swap BGR/RGB

					/* FIXME
					if(ta == 256 && mulA == 256) {
					    // opaque
					    tcol = _mm_mullo_epi16(tcol, mulCol);

					    // pack.
					    tcol = _mm_srli_epi16(tcol, 8);
					    tcol = _mm_packus_epi16(tcol, tcol);

					    // store.
					    _mm_store_ss(reinterpret_cast<float *>(&dest),
					                 tcol);

					    return;
					}*/

					// tcol is already premultiplied. see SWImage.cpp

					// modulate by the constant color. now [u8.8x4, u8.8x4], 8bit width
					tcol = _mm_mullo_epi16(tcol, mulCol);

					// broadcast the alpha of the tcol.
					__m128i tcolAlphaVec = _mm_shufflelo_epi16(tcol, 0xff);
					tcolAlphaVec = _mm_shufflehi_epi16(tcolAlphaVec, 0xff);

					// make tcol [u8.8x4]
					// tcol = _mm_slli_epi16(tcol, 1);
					tcolAlphaVec = _mm_srli_epi16(tcolAlphaVec, 8); // make [u16x4,u16x4]8bw
					tcolAlphaVec = _mm_add_epi16(
					  tcolAlphaVec, _mm_srli_epi16(tcolAlphaVec, 7)); // [0,255] -> [0,256]

					// inverse the alpha
					tcolAlphaVec = _mm_sub_epi16(_mm_set1_epi16(0x100), tcolAlphaVec);

					// load [u8.0 x 4 x 2]
					__m128i dcol = _mm_setr_epi32(dest[0], dest[1], 0, 0);

					// convert to [u16.0 x 4 x 2], 8bit width
					dcol = _mm_unpacklo_epi8(dcol, _mm_setzero_si128());

					// modulate by inversed src alpha.
					// now [u8.8 x 4 x 2]
					dcol = _mm_mullo_epi16(dcol, tcolAlphaVec);

					// additive blending with saturation.
					dcol = _mm_adds_epu16(dcol, tcol);

					// pack.
					dcol = _mm_srli_epi16(dcol, 8);
					dcol = _mm_packus_epi16(dcol, dcol);

					// store.
					_mm_store_sd(reinterpret_cast<double *>(dest), _mm_castsi128_pd(dcol));
				};

				auto drawScanline =
				  [tw, th, tpixels, bmp, fbW, fbH, depthBuffer, &drawPixel, &drawPixel2, &r,
				   &ditherMap, &ditherMap2](int y, int x1, int x2, const SWImageVarying &vary1,
				                            const SWImageVarying &vary2, float z1, float z2) {
					  uint32_t *out = bmp + (y * fbW);
					  float *depthOut = nullptr;
					  if (depthTest) {
						  depthOut = depthBuffer + (y * fbW);
					  }
					  SPAssert(x1 < x2);
					  int width = x2 - x1;
					  SWImageGouraudInterpolator<SWFeatureLevel::SSE2> vary(vary1, vary2, width);
					  int minX = std::max(x1, 0);
					  int maxX = std::min(x2, fbW);
					  r.pixelsDrawn += maxX - minX;
					  vary.MoveNext(minX - x1);
					  out += minX;
					  if (depthTest) {
						  depthOut += minX;
					  }
					  auto uvMask = _mm_set1_epi32(texUVScaleInt - 1);
					  auto uvScale = _mm_setr_epi32(tw, tw, th, th);

					  uint8_t ditherIndex = static_cast<uint8_t>(y & 1) << 1;

					  auto unalignedPixel = [&]() {
						  auto vr = vary.GetCurrent();
						  union {
							  __m128i uv;
							  struct {
								  unsigned int ui, dummy1, vi, dummy2;
							  } iuv;
						  };
						  uv = vr.uv_m128;

						  if (linearInterpolate) {
							  uint8_t idx = static_cast<uint8_t>(minX & 1) | ditherIndex;
							  auto m =
							    _mm_setr_epi32(ditherMap[idx * 2], 0, ditherMap[idx * 2 + 1], 0);
							  uv = _mm_add_epi32(uv, m);
						  }

						  uv = _mm_and_si128(uv, uvMask);  // repeat
						  uv = _mm_mul_epu32(uv, uvScale); // now [u*tw, v*th]
						  uv = _mm_srli_epi64(uv, texUVScaleBits);

						  uint32_t tex = tpixels[iuv.ui + iuv.vi * tw];
						  // FIXME: Z interpolation
						  // FIXME: perspective correction
						  drawPixel(*out, *depthOut, tex, z1);
						  out++;
						  if (depthTest) {
							  depthOut++;
						  }
						  vary.MoveNext();
					  };
					  while ((minX & 1) && (minX < maxX)) {
						  // non-aligned.
						  unalignedPixel();
						  minX++;
					  }
					  int reminders = maxX & 1;
					  maxX -= reminders;
					  auto dither = ditherMap2[y & 1];
					  for (int x = minX; x < maxX; x += 2) {
						  auto vr1 = vary.GetCurrent();
						  vary.MoveNext();
						  auto vr2 = vary.GetCurrent();
						  union {
							  __m128i uv;
							  struct {
								  unsigned int ui, dummy1, vi, dummy2;
							  } iuv;
						  };
						  // static_assert(texUVScaleBits == 16, "texUVScaleBits must be 16");
						  uv = _mm_castps_si128(_mm_shuffle_ps(_mm_castsi128_ps(vr1.uv_m128),
						                                       _mm_castsi128_ps(vr2.uv_m128),
						                                       0x88)); // [u1,v1,u2,v2]

						  if (linearInterpolate) {
							  uv = _mm_add_epi32(uv, dither);
						  }

						  uv = _mm_shuffle_epi32(uv, 0xd8); // [u1,u2,v1,v2]
						  uv = _mm_and_si128(uv, uvMask);   // repeat

						  auto tm = uv;
						  uv = _mm_mul_epu32(uv, uvScale);
						  uv = _mm_srli_epi64(uv, texUVScaleBits);
						  uint32_t tex1 = tpixels[iuv.ui + iuv.vi * tw];

						  uv = _mm_shuffle_epi32(tm, 0xb1); // [u2,u1,v2,v1]
						  uv = _mm_mul_epu32(uv, uvScale);
						  uv = _mm_srli_epi64(uv, texUVScaleBits);
						  uint32_t tex2 = tpixels[iuv.ui + iuv.vi * tw];
						  // FIXME: Z interpolation
						  // FIXME: perspective correction
						  // drawPixel(out[0], depthOut[0], tex1, z1);
						  // drawPixel(out[1], depthOut[1], tex2, z1);

						  drawPixel2(out, depthOut, tex1, z1, tex2, z1);
						  out += 2;
						  if (depthTest) {
							  depthOut += 2;
						  }
						  vary.MoveNext();
					  }
					  while (reminders--) {
						  unalignedPixel();
					  }
				  };

				// FIXME: interpolated Z

				Interpolator longSpanX(x1, x3, y3 - y1);
				SWImageGouraudInterpolator<SWFeatureLevel::SSE2> longSpan(v1, v3, y3 - y1);
				{
					Interpolator shortSpanX(x1, x2, y2 - y1);
					SWImageGouraudInterpolator<SWFeatureLevel::SSE2> shortSpan(v1, v2, y2 - y1);
					int minY = std::max(0, y1);
					int maxY = std::min(fbH, y2);
					shortSpanX.MoveNext(minY - y1);
					shortSpan.MoveNext(minY - y1);
					longSpanX.MoveNext(minY - y1);
					longSpan.MoveNext(minY - y1);
					for (int y = minY; y < maxY; y++) {
						int lineX1 = shortSpanX.GetCurrent();
						auto line1 = shortSpan.GetCurrent();
						int lineX2 = longSpanX.GetCurrent();
						auto line2 = longSpan.GetCurrent();
						shortSpanX.MoveNext();
						shortSpan.MoveNext();
						longSpanX.MoveNext();
						longSpan.MoveNext();
						if (lineX1 == lineX2)
							continue;
						if (lineX1 < lineX2) {
							drawScanline(y, lineX1, lineX2, line1, line2, v1.position.z,
							             v1.position.z);
						} else {
							drawScanline(y, lineX2, lineX1, line2, line1, v1.position.z,
							             v1.position.z);
						}
					}
				}
				{
					Interpolator shortSpanX(x2, x3, y3 - y2);
					SWImageGouraudInterpolator<SWFeatureLevel::SSE2> shortSpan(v2, v3, y3 - y2);
					int minY = std::max(0, y2);
					int maxY = std::min(fbH, y3);
					shortSpanX.MoveNext(minY - y2);
					shortSpan.MoveNext(minY - y2);
					longSpanX.MoveNext(minY - y2);
					longSpan.MoveNext(minY - y2);
					for (int y = minY; y < maxY; y++) {
						int lineX1 = shortSpanX.GetCurrent();
						auto line1 = shortSpan.GetCurrent();
						int lineX2 = longSpanX.GetCurrent();
						auto line2 = longSpan.GetCurrent();
						shortSpanX.MoveNext();
						shortSpan.MoveNext();
						longSpanX.MoveNext();
						longSpan.MoveNext();
						if (lineX1 == lineX2)
							continue;
						if (lineX1 < lineX2) {
							drawScanline(y, lineX1, lineX2, line1, line2, v1.position.z,
							             v1.position.z);
						} else {
							drawScanline(y, lineX2, lineX1, line2, line1, v1.position.z,
							             v1.position.z);
						}
					}
				}
				// polygon, done!
			}

			static void DrawPolygonInternal(SWImage *img, const Vertex &v1, const Vertex &v2,
			                                const Vertex &v3, SWImageRenderer &r) {
				if (v2.position.y < v1.position.y) {
					if (v3.position.y < v2.position.y) {
						DrawPolygonInternalInner(img, v3, v2, v1, r);
					} else if (v3.position.y < v1.position.y) {
						DrawPolygonInternalInner(img, v2, v3, v1, r);
					} else {
						DrawPolygonInternalInner(img, v2, v1, v3, r);
					}
				} else if (v3.position.y < v1.position.y) {
					DrawPolygonInternalInner(img, v3, v1, v2, r);
				} else if (v3.position.y < v2.position.y) {
					DrawPolygonInternalInner(img, v1, v3, v2, r);
				} else {
					DrawPolygonInternalInner(img, v1, v2, v3, r);
				}
			}
		};

#pragma mark Solid
		template <bool depthTest, bool lerp>
		struct SWImageRenderer::PolygonRenderer<SWFeatureLevel::SSE2, false, false, depthTest, true,
		                                        lerp> {

			static void DrawPolygonInternalInner(SWImage *img, const Vertex &v1, const Vertex &v2,
			                                     const Vertex &v3, SWImageRenderer &r) {

				Bitmap *const fb = r.frame;
				SPAssert(fb != nullptr);

				if (v3.position.y <= 0.f) {
					// viewport cull
					return;
				}

				const int fbW = fb->GetWidth();
				const int fbH = fb->GetHeight();
				uint32_t *const bmp = fb->GetPixels();

				if (v1.position.y >= static_cast<float>(fbH)) {
					// viewport cull
					return;
				}

				float *const depthBuffer = r.depthBuffer;
				if (depthTest) {
					SPAssert(depthBuffer != nullptr);
				}

				const int x1 = static_cast<int>(v1.position.x);
				const int y1 = static_cast<int>(v1.position.y);
				const int x2 = static_cast<int>(v2.position.x);
				const int y2 = static_cast<int>(v2.position.y);
				const int x3 = static_cast<int>(v3.position.x);
				const int y3 = static_cast<int>(v3.position.y);

				if (x1 == x2 && x2 == x3)
					return; // area cull
				if (y1 == y3)
					return; // area cull
				if (std::min(std::min(x1, x2), x3) >= fbW)
					return; // viewport cull
				if (std::max(std::max(x1, x2), x3) <= 0)
					return; // viewport cull

				auto convertColor = [](float f) {
					// 255.f, not 256.f here because for solid rendering
					// this color is directly used
					int i = static_cast<int>(f * 255.f + .5f);
					return static_cast<unsigned short>(std::max(std::min(i, 255), 0));
				};
				unsigned short mulR = convertColor(v1.color.x);
				unsigned short mulG = convertColor(v1.color.y);
				unsigned short mulB = convertColor(v1.color.z);
				unsigned short mulA = convertColor(v1.color.w);

				if (mulA == 0 && mulR == 0 && mulG == 0 && mulB == 0)
					return;

				__m128i mulCol = _mm_setr_epi16(mulB, mulG, mulR, mulA, mulB, mulG, mulR, mulA);
				__m128i mulInv = _mm_set1_epi16(256 - (mulA + (mulA >> 7)));
				mulCol = _mm_slli_epi16(mulCol, 8);

				auto drawPixel = [mulCol, mulInv](uint32_t &dest, float &destDepth, float inDepth) {
					if (depthTest) {
						if (inDepth > destDepth) {
							return;
						}
					}

					// load [u8.8x4]8bw
					__m128i tcol = mulCol;

					// load [u8.0x4]
					__m128i dcol = _mm_setr_epi32(dest, 0, 0, 0);

					// convert to [u16.0x4], 8bit width
					dcol = _mm_unpacklo_epi8(dcol, _mm_setzero_si128());

					// modulate by inversed src alpha.
					// now [u8.8 x 4]
					dcol = _mm_mullo_epi16(dcol, mulInv);

					// additive blending with saturation.
					dcol = _mm_adds_epu16(dcol, tcol);

					// pack.
					dcol = _mm_srli_epi16(dcol, 8);
					dcol = _mm_packus_epi16(dcol, dcol);

					// store.
					_mm_store_ss(reinterpret_cast<float *>(&dest), _mm_castsi128_ps(dcol));
				};

				auto drawPixel2 = [mulCol, mulInv, &drawPixel](uint32_t *dest, float *destDepth,
				                                               float inDepth1, float inDepth2) {
					if (depthTest) {
						if (inDepth1 > destDepth[0]) {
							drawPixel(dest[1], destDepth[1], inDepth2);
							return;
						}
						if (inDepth2 > destDepth[1]) {
							drawPixel(dest[0], destDepth[0], inDepth2);
							return;
						}
					}

					// load [u8.8 x 4 x 2]
					__m128i tcol = mulCol;

					// load [u8.0 x 4 x 2]
					__m128i dcol = _mm_setr_epi32(dest[0], dest[1], 0, 0);

					// convert to [u16.0 x 4 x 2], 8bit width
					dcol = _mm_unpacklo_epi8(dcol, _mm_setzero_si128());

					// modulate by inversed src alpha.
					// now [u8.8 x 4 x 2]
					dcol = _mm_mullo_epi16(dcol, mulInv);

					// additive blending with saturation.
					dcol = _mm_adds_epu16(dcol, tcol);

					// pack.
					dcol = _mm_srli_epi16(dcol, 8);
					dcol = _mm_packus_epi16(dcol, dcol);

					// store.
					_mm_store_sd(reinterpret_cast<double *>(dest), _mm_castsi128_pd(dcol));
				};

				auto drawScanline = [bmp, fbW, fbH, depthBuffer, &drawPixel, &drawPixel2,
				                     &r](int y, int x1, int x2, const SWImageVarying &vary1,
				                         const SWImageVarying &vary2, float z1, float z2) {
					uint32_t *out = bmp + (y * fbW);
					float *depthOut = nullptr;
					if (depthTest) {
						depthOut = depthBuffer + (y * fbW);
					}
					SPAssert(x1 < x2);
					// int width = x2 - x1;
					int minX = std::max(x1, 0);
					int maxX = std::min(x2, fbW);
					r.pixelsDrawn += maxX - minX;
					out += minX;
					if (depthTest) {
						depthOut += minX;
					}

					auto unalignedPixel = [&]() {
						// FIXME: Z interpolation
						drawPixel(*out, *depthOut, z1);
						out++;
						if (depthTest) {
							depthOut++;
						}
					};
					while ((minX & 1) && (minX < maxX)) {
						// non-aligned.
						unalignedPixel();
						minX++;
					}
					int reminders = maxX & 1;
					maxX -= reminders;
					/* for(int x = minX; x < maxX; x+=2) */
					if (maxX > minX)
						for (auto *endPtr = out + (maxX - minX); out != endPtr;) {
							// FIXME: Z interpolation

							drawPixel2(out, depthOut, z1, z1);
							out += 2;
							if (depthTest) {
								depthOut += 2;
							}
						}
					while (reminders--) {
						unalignedPixel();
					}
				};

				// FIXME: interpolated Z

				Interpolator longSpanX(x1, x3, y3 - y1);
				SWImageGouraudInterpolator<SWFeatureLevel::SSE2> longSpan(v1, v3, y3 - y1);
				{
					Interpolator shortSpanX(x1, x2, y2 - y1);
					SWImageGouraudInterpolator<SWFeatureLevel::SSE2> shortSpan(v1, v2, y2 - y1);
					int minY = std::max(0, y1);
					int maxY = std::min(fbH, y2);
					shortSpanX.MoveNext(minY - y1);
					shortSpan.MoveNext(minY - y1);
					longSpanX.MoveNext(minY - y1);
					longSpan.MoveNext(minY - y1);
					for (int y = minY; y < maxY; y++) {
						int lineX1 = shortSpanX.GetCurrent();
						auto line1 = shortSpan.GetCurrent();
						int lineX2 = longSpanX.GetCurrent();
						auto line2 = longSpan.GetCurrent();
						shortSpanX.MoveNext();
						shortSpan.MoveNext();
						longSpanX.MoveNext();
						longSpan.MoveNext();
						if (lineX1 == lineX2)
							continue;
						if (lineX1 < lineX2) {
							drawScanline(y, lineX1, lineX2, line1, line2, v1.position.z,
							             v1.position.z);
						} else {
							drawScanline(y, lineX2, lineX1, line2, line1, v1.position.z,
							             v1.position.z);
						}
					}
				}
				{
					Interpolator shortSpanX(x2, x3, y3 - y2);
					SWImageGouraudInterpolator<SWFeatureLevel::SSE2> shortSpan(v2, v3, y3 - y2);
					int minY = std::max(0, y2);
					int maxY = std::min(fbH, y3);
					shortSpanX.MoveNext(minY - y2);
					shortSpan.MoveNext(minY - y2);
					longSpanX.MoveNext(minY - y2);
					longSpan.MoveNext(minY - y2);
					for (int y = minY; y < maxY; y++) {
						int lineX1 = shortSpanX.GetCurrent();
						auto line1 = shortSpan.GetCurrent();
						int lineX2 = longSpanX.GetCurrent();
						auto line2 = longSpan.GetCurrent();
						shortSpanX.MoveNext();
						shortSpan.MoveNext();
						longSpanX.MoveNext();
						longSpan.MoveNext();
						if (lineX1 == lineX2)
							continue;
						if (lineX1 < lineX2) {
							drawScanline(y, lineX1, lineX2, line1, line2, v1.position.z,
							             v1.position.z);
						} else {
							drawScanline(y, lineX2, lineX1, line2, line1, v1.position.z,
							             v1.position.z);
						}
					}
				}
				// polygon, done!
			}

			static void DrawPolygonInternal(SWImage *img, const Vertex &v1, const Vertex &v2,
			                                const Vertex &v3, SWImageRenderer &r) {
				if (v2.position.y < v1.position.y) {
					if (v3.position.y < v2.position.y) {
						DrawPolygonInternalInner(img, v3, v2, v1, r);
					} else if (v3.position.y < v1.position.y) {
						DrawPolygonInternalInner(img, v2, v3, v1, r);
					} else {
						DrawPolygonInternalInner(img, v2, v1, v3, r);
					}
				} else if (v3.position.y < v1.position.y) {
					DrawPolygonInternalInner(img, v3, v1, v2, r);
				} else if (v3.position.y < v2.position.y) {
					DrawPolygonInternalInner(img, v1, v3, v2, r);
				} else {
					DrawPolygonInternalInner(img, v1, v2, v3, r);
				}
			}
		};

#endif

#pragma mark - Intermediates

		template <SWFeatureLevel featureLvl, bool depthTest, bool solidFill, bool lerp>
		struct SWImageRenderer::PolygonRenderer<featureLvl, false, true, depthTest, solidFill,
		                                        lerp> {
			static void DrawPolygonInternal(SWImage *img, const Vertex &v1, const Vertex &v2,
			                                const Vertex &v3, SWImageRenderer &r) {

				// denormalize
				auto vv1 = v1, vv2 = v2, vv3 = v3;
				vv1.position = (vv1.position * r.fbSize4) + r.fbCenter4;
				vv2.position = (vv2.position * r.fbSize4) + r.fbCenter4;
				vv3.position = (vv3.position * r.fbSize4) + r.fbCenter4;
				PolygonRenderer<featureLvl, false, false, depthTest, solidFill,
				                lerp>::DrawPolygonInternal(img, vv1, vv2, vv3, r);
			}
		};

		template <SWFeatureLevel featureLvl,
		          bool ndc, // normalized device coordinate
		          bool depthTest, bool solidFill, bool lerp>
		struct SWImageRenderer::PolygonRenderer<featureLvl, true, ndc, depthTest, solidFill, lerp> {
			template <class F>
			static void Clip(Vertex &v1, Vertex &v2, Vertex &v3, Vector4 plane, F continuation) {
				auto distance = [](const Vector4 &v, const Vector4 &plane) {
					return v.x * plane.x + v.y * plane.y + v.z * plane.z + plane.w;
				};
				auto lerpVertex = [](const Vertex &v1, const Vertex &v2, Vertex &out, float per) {
					out.position = v1.position + (v2.position - v1.position) * per;
					out.color = v1.color + (v2.color - v1.color) * per;
					out.uv = v1.uv + (v2.uv - v1.uv) * per;
				};
				float d1 = distance(v1.position, plane);
				float d2 = distance(v2.position, plane);
				float d3 = distance(v3.position, plane);
				bool nc1 = d1 >= 0.f;
				bool nc2 = d2 >= 0.f;
				bool nc3 = d3 >= 0.f;
				int bits = (nc1 ? 1 : 0) | (nc2 ? 2 : 0) | (nc3 ? 4 : 0);
				float per1, per2;
				Vertex vv1, vv2, vv3;
				Vertex t1, t2;
				switch (bits) {
					case 0:
						// culled
						return;
					case 7:
						// not clipped
						continuation(v1, v2, v3);
						return;
					case 1:
						per1 = d2 / (d2 - d1); // == (0.f - d2) / (d1 - d2);
						per2 = d3 / (d3 - d1);
						lerpVertex(v2, v1, v2, per1);
						lerpVertex(v3, v1, v3, per2);
						continuation(v1, v2, v3);
						return;
					case 2:
						per1 = d1 / (d1 - d2);
						per2 = d3 / (d3 - d2);
						lerpVertex(v1, v2, v1, per1);
						lerpVertex(v3, v2, v3, per2);
						continuation(v1, v2, v3);
						return;
					case 4:
						per1 = d2 / (d2 - d3);
						per2 = d1 / (d1 - d3);
						lerpVertex(v2, v3, v2, per1);
						lerpVertex(v1, v3, v1, per2);
						continuation(v1, v2, v3);
						return;
					case 3:
						per1 = d2 / (d2 - d3);
						per2 = d1 / (d1 - d3);
						lerpVertex(v2, v3, t2, per1);
						lerpVertex(v1, v3, t1, per2);
						vv1 = v1;
						vv2 = v2;
						vv3 = t2;
						continuation(vv1, vv2, vv3);
						vv1 = v1;
						vv2 = t2;
						vv3 = t1;
						continuation(vv1, vv2, vv3);
						break;
					case 5:
						per1 = d3 / (d3 - d2);
						per2 = d1 / (d1 - d2);
						lerpVertex(v3, v2, t2, per1);
						lerpVertex(v1, v2, t1, per2);
						vv1 = v1;
						vv2 = v3;
						vv3 = t2;
						continuation(vv1, vv2, vv3);
						vv1 = v1;
						vv2 = t2;
						vv3 = t1;
						continuation(vv1, vv2, vv3);
						break;
					case 6:
						per1 = d3 / (d3 - d1);
						per2 = d2 / (d2 - d1);
						lerpVertex(v3, v1, t2, per1);
						lerpVertex(v2, v1, t1, per2);
						vv1 = v2;
						vv2 = v3;
						vv3 = t2;
						continuation(vv1, vv2, vv3);
						vv1 = v2;
						vv2 = t2;
						vv3 = t1;
						continuation(vv1, vv2, vv3);
						break;
				}
			}

			static void DrawPolygonInternal(SWImage *img, const Vertex &v1, const Vertex &v2,
			                                const Vertex &v3, SWImageRenderer &r) {
				// needs transform.
				auto vv1 = v1, vv2 = v2, vv3 = v3;
				const auto &mat = r.matrix;
				vv1.position = mat * vv1.position;
				vv2.position = mat * vv2.position;
				vv3.position = mat * vv3.position;

				Clip(vv1, vv2, vv3, MakeVector4(0.f, 0.f, 1.f, -r.zNear),
				     [img, &r](Vertex &v1, Vertex &v2, Vertex &v3) {
					     Vertex vv1 = v1;
					     Vertex vv2 = v2;
					     Vertex vv3 = v3;
					     // want to save Z
					     float orig1 = vv1.position.z;
					     float orig2 = vv2.position.z;
					     float orig3 = vv3.position.z;
#if ENABLE_SSE
					     union {
						     __m128 m;
						     Vector4 v;
					     };
					     m = _mm_setr_ps(vv1.position.w, vv2.position.w, vv3.position.w, 1.f);
					     m = _mm_rcp_ps(m);
					     vv1.position *= v.x;
					     vv2.position *= v.y;
					     vv3.position *= v.z;
#else
					     vv1.position /= vv1.position.w;
					     vv2.position /= vv2.position.w;
					     vv3.position /= vv3.position.w;
#endif
					     vv1.position.z = orig1;
					     vv2.position.z = orig2;
					     vv3.position.z = orig3;

					     PolygonRenderer<featureLvl, false, true, depthTest, solidFill,
					                     lerp>::DrawPolygonInternal(img, vv1, vv2, vv3, r);
					     return;
					     Clip(v1, v2, v3, MakeVector4(0.f, 0.f, -1.f, 1.f),
					          [img, &r](Vertex &v1, Vertex &v2, Vertex &v3) {
						          PolygonRenderer<featureLvl, false, true, depthTest, solidFill,
						                          lerp>::DrawPolygonInternal(img, v1, v2, v3, r);
						      });
					 });
			}
		};

		template <SWFeatureLevel level, bool needTransform,
		          bool ndc, // normalized device coordinate
		          bool depthTest, bool lerp>
		struct SWImageRenderer::PolygonRenderer3 {
			static void DrawPolygonInternal(SWImage *img, const Vertex &v1, const Vertex &v2,
			                                const Vertex &v3, SWImageRenderer &r) {
				if (img == nullptr || img->IsWhiteImage()) {
					PolygonRenderer<level, needTransform, ndc, depthTest, true,
					                lerp>::DrawPolygonInternal(img, v1, v2, v3, r);
					return;
				}
				PolygonRenderer<level, needTransform, ndc, depthTest, false,
				                lerp>::DrawPolygonInternal(img, v1, v2, v3, r);
			}
		};

		template <bool needTransform,
		          bool ndc, // normalized device coordinate
		          bool depthTest, bool lerp>
		struct SWImageRenderer::PolygonRenderer2 {
			static void DrawPolygonInternal(SWImage *img, const Vertex &v1, const Vertex &v2,
			                                const Vertex &v3, SWImageRenderer &r,
			                                SWFeatureLevel lvl) {
#if ENABLE_SSE2
				if (static_cast<int>(lvl) >= static_cast<int>(SWFeatureLevel::SSE2)) {
					PolygonRenderer3<SWFeatureLevel::SSE2, needTransform, ndc, depthTest,
					                 lerp>::DrawPolygonInternal(img, v1, v2, v3, r);
					return;
				}
#endif
				PolygonRenderer3<SWFeatureLevel::None, needTransform, ndc, depthTest,
				                 lerp>::DrawPolygonInternal(img, v1, v2, v3, r);
			}
		};

		void SWImageRenderer::DrawPolygon(SWImage *img, const Vertex &v1, const Vertex &v2,
		                                  const Vertex &v3) {
			SPAssert(frame != nullptr);
			switch (shader) {
				case ShaderType::Sprite:
					PolygonRenderer2<true, // needs transform
					                 true, // in NDC
					                 true, // depth tested
					                 true  // linear interpolation
					                 >::DrawPolygonInternal(img, v1, v2, v3, *this, featureLevel);
					break;
				case ShaderType::Image:
					PolygonRenderer2<false, // don't need transform
					                 false, // not NDC
					                 false, // no depth test
					                 false  // point sampling
					                 >::DrawPolygonInternal(img, v1, v2, v3, *this, featureLevel);
					break;
			}
		}
	}
}