src/Reactor/Shell.cpp - SwiftShader - Git at Google

 // SwiftShader Software Renderer
 //
 // Copyright(c) 2005-2011 TransGaming Inc.
 //
 // All rights reserved. No part of this software may be copied, distributed, transmitted,
 // transcribed, stored in a retrieval system, translated into any human or computer
 // language by any means, or disclosed to third parties without the explicit written
 // agreement of TransGaming Inc. Without such an agreement, no rights or licenses, express
 // or implied, including but not limited to any patent rights, are granted to you.
 //

 #include "Shell.hpp"

 namespace sw
 {
 	TranscendentalPrecision logPrecision = ACCURATE;
 	TranscendentalPrecision expPrecision = ACCURATE;
 	TranscendentalPrecision rcpPrecision = ACCURATE;
 	TranscendentalPrecision rsqPrecision = ACCURATE;
 	bool perspectiveCorrection = true;

 	Color4i::Color4i() : x(r), y(g), z(b), w(a)
 	{
 	}

 	Color4i::Color4i(unsigned short red, unsigned short green, unsigned short blue, unsigned short alpha) : x(r), y(g), z(b), w(a)
 	{
 		r = Short4(red);
 		g = Short4(green);
 		b = Short4(blue);
 		a = Short4(alpha);
 	}

 	Color4i::Color4i(const Color4i &rhs) : x(r), y(g), z(b), w(a)
 	{
 		r = rhs.r;
 		g = rhs.g;
 		b = rhs.b;
 		a = rhs.a;
 	}

 	Color4i &Color4i::operator=(const Color4i &rhs)
 	{
 		r = rhs.r;
 		g = rhs.g;
 		b = rhs.b;
 		a = rhs.a;

 		return *this;
 	}

 	Short4 &Color4i::operator[](int i)
 	{
 		switch(i)
 		{
 		case 0: return x;
 		case 1: return y;
 		case 2: return z;
 		case 3: return w;
 		}

 		return x;
 	}

 	Color4f::Color4f() : x(r), y(g), z(b), w(a), u(r), v(g), s(b), t(a)
 	{
 	}

 	Color4f::Color4f(float red, float green, float blue, float alpha) : x(r), y(g), z(b), w(a), u(r), v(g), s(b), t(a)
 	{
 		r = Float4(red);
 		g = Float4(green);
 		b = Float4(blue);
 		a = Float4(alpha);
 	}

 	Color4f::Color4f(const Color4f &rhs) : x(r), y(g), z(b), w(a), u(r), v(g), s(b), t(a)
 	{
 		r = rhs.r;
 		g = rhs.g;
 		b = rhs.b;
 		a = rhs.a;
 	}

 	Color4f &Color4f::operator=(const Color4f &rhs)
 	{
 		r = rhs.r;
 		g = rhs.g;
 		b = rhs.b;
 		a = rhs.a;

 		return *this;
 	}

 	Float4 &Color4f::operator[](int i)
 	{
 		switch(i)
 		{
 		case 0: return x;
 		case 1: return y;
 		case 2: return z;
 		case 3: return w;
 		}

 		return x;
 	}

 	Float4 exponential(Float4 &src, bool pp)
 	{
 		Float4 x0;
 		Float4 x1;
 		Int4 x2;

 		x0 = src;

 		x0 = Min(x0, As<Float4>(Int4(0x43010000, 0x43010000, 0x43010000, 0x43010000)));   // 129.00000e+0f
 		x0 = Max(x0, As<Float4>(Int4(0xC2FDFFFF, 0xC2FDFFFF, 0xC2FDFFFF, 0xC2FDFFFF)));   // -126.99999e+0f
 		x1 = x0;
 		x1 -= Float4(0.5f, 0.5f, 0.5f, 0.5f);
 		x2 = RoundInt(x1);
 		x1 = Float4(x2);
 		x2 += Int4(0x0000007F, 0x0000007F, 0x0000007F, 0x0000007F);   // 127
 		x2 = x2 << 23;
 		x0 -= x1;
 		x1 = As<Float4>(Int4(0x3AF61905, 0x3AF61905, 0x3AF61905, 0x3AF61905));   // 1.8775767e-3f
 		x1 *= x0;
 		x1 += As<Float4>(Int4(0x3C134806, 0x3C134806, 0x3C134806, 0x3C134806));   // 8.9893397e-3f
 		x1 *= x0;
 		x1 += As<Float4>(Int4(0x3D64AA23, 0x3D64AA23, 0x3D64AA23, 0x3D64AA23));   // 5.5826318e-2f
 		x1 *= x0;
 		x1 += As<Float4>(Int4(0x3E75EAD4, 0x3E75EAD4, 0x3E75EAD4, 0x3E75EAD4));   // 2.4015361e-1f
 		x1 *= x0;
 		x1 += As<Float4>(Int4(0x3F31727B, 0x3F31727B, 0x3F31727B, 0x3F31727B));   // 6.9315308e-1f
 		x1 *= x0;
 		x1 += As<Float4>(Int4(0x3F7FFFFF, 0x3F7FFFFF, 0x3F7FFFFF, 0x3F7FFFFF));   // 9.9999994e-1f
 		x1 *= As<Float4>(x2);

 		return x1;
 	}

 	Float4 logarithm(Float4 &src, bool absolute, bool pp)
 	{
 		Float4 x0;
 		Float4 x1;
 		Float4 x2;
 		Float4 x3;

 		x0 = src;

 		x1 = As<Float4>(As<Int4>(x0) & Int4(0x7F800000));
 		x1 = As<Float4>(As<UInt4>(x1) >> 8);
 		x1 = As<Float4>(As<Int4>(x1) | As<Int4>(Float4(1.0f)));
 		x1 = (x1 - Float4(1.4960938f)) * Float4(256.0f);   // FIXME: (x1 - 1.4960938f) * 256.0f;
 		x0 = As<Float4>((As<Int4>(x0) & Int4(0x007FFFFF)) | As<Int4>(Float4(1.0f)));

 		x2 = (Float4(9.5428179e-2f) * x0 + Float4(4.7779095e-1f)) * x0 + Float4(1.9782813e-1f);
 		x3 = ((Float4(1.6618466e-2f) * x0 + Float4(2.0350508e-1f)) * x0 + Float4(2.7382900e-1f)) * x0 + Float4(4.0496687e-2f);
 		x2 /= x3;

 		x1 += (x0 - Float4(1.0f)) * x2;

 		return x1;
 	}

 	Float4 power(Float4 &src0, Float4 &src1, bool pp)
 	{
 		Float4 log = logarithm(src0, true, pp);
 		log *= src1;
 		return exponential(log, pp);
 	}

 	Float4 reciprocal(Float4 &src, bool pp, bool finite)
 	{
 		Float4 dst;

 		if(!pp && rcpPrecision >= WHQL)
 		{
 			dst = Float4(1, 1, 1, 1) / src;
 		}
 		else
 		{
 			dst = Rcp_pp(src);

 			if(!pp)
 			{
 				dst = (dst + dst) - (src * dst * dst);
 			}
 		}

 		if(finite)
 		{
 			int x = 0x7F7FFFFF;
 			dst = Min(dst, Float4((float&)x, (float&)x, (float&)x, (float&)x));
 		}

 		return dst;
 	}

 	Float4 reciprocalSquareRoot(Float4 &src, bool absolute, bool pp)
 	{
 		Float4 abs = src;

 		if(absolute)
 		{
 			abs = Abs(abs);
 		}

 		Float4 rsq;

 		if(!pp && rsqPrecision >= IEEE)
 		{
 			rsq = Float4(1.0f, 1.0f, 1.0f, 1.0f) / Sqrt(abs);
 		}
 		else
 		{
 			rsq = RcpSqrt_pp(abs);

 			if(!pp)
 			{
 				rsq = rsq * (Float4(3.0f) - rsq * rsq * abs) * Float4(0.5f);
 			}
 		}

 		int x = 0x7F7FFFFF;
 		rsq = Min(rsq, Float4((float&)x, (float&)x, (float&)x, (float&)x));

 		return rsq;
 	}

 	Float4 sine(Float4 &src, bool pp)
 	{
 		const Float4 A = Float4(-4.05284734e-1f);   // -4/pi^2
 		const Float4 B = Float4(1.27323954e+0f);    // 4/pi
 		const Float4 C = Float4(7.75160950e-1f);
 		const Float4 D = Float4(2.24839049e-1f);

 		// Parabola approximating sine
 		Float4 sin = src * (Abs(src) * A + B);

 		// Improve precision from 0.06 to 0.001
 		if(true)
 		{
 			sin = sin * (Abs(sin) * D + C);
 		}

 		return sin;
 	}

 	Float4 dot3(Color4f &src0, Color4f &src1)
 	{
 		return src0.x * src1.x + src0.y * src1.y + src0.z * src1.z;
 	}

 	Float4 dot4(Color4f &src0, Color4f &src1)
 	{
 		return src0.x * src1.x + src0.y * src1.y + src0.z * src1.z + src0.w * src1.w;
 	}

 	void transpose4x4(Short4 &row0, Short4 &row1, Short4 &row2, Short4 &row3)
 	{
 		Int2 tmp0 = UnpackHigh(row0, row1);
 		Int2 tmp1 = UnpackHigh(row2, row3);
 		Int2 tmp2 = UnpackLow(row0, row1);
 		Int2 tmp3 = UnpackLow(row2, row3);

 		row0 = As<Short4>(UnpackLow(tmp2, tmp3));
 		row1 = As<Short4>(UnpackHigh(tmp2, tmp3));
 		row2 = As<Short4>(UnpackLow(tmp0, tmp1));
 		row3 = As<Short4>(UnpackHigh(tmp0, tmp1));
 	}

 	void transpose4x4(Float4 &row0, Float4 &row1, Float4 &row2, Float4 &row3)
 	{
 		Float4 tmp0 = UnpackLow(row0, row1);
 		Float4 tmp1 = UnpackLow(row2, row3);
 		Float4 tmp2 = UnpackHigh(row0, row1);
 		Float4 tmp3 = UnpackHigh(row2, row3);

 		row0 = Float4(tmp0.xy, tmp1.xy);
 		row1 = Float4(tmp0.zw, tmp1.zw);
 		row2 = Float4(tmp2.xy, tmp3.xy);
 		row3 = Float4(tmp2.zw, tmp3.zw);
 	}

 	void transpose4x3(Float4 &row0, Float4 &row1, Float4 &row2, Float4 &row3)
 	{
 		Float4 tmp0 = UnpackLow(row0, row1);
 		Float4 tmp1 = UnpackLow(row2, row3);
 		Float4 tmp2 = UnpackHigh(row0, row1);
 		Float4 tmp3 = UnpackHigh(row2, row3);

 		row0 = Float4(tmp0.xy, tmp1.xy);
 		row1 = Float4(tmp0.zw, tmp1.zw);
 		row2 = Float4(tmp2.xy, tmp3.xy);
 	}

 	void transpose4x2(Float4 &row0, Float4 &row1, Float4 &row2, Float4 &row3)
 	{
 		Float4 tmp0 = UnpackLow(row0, row1);
 		Float4 tmp1 = UnpackLow(row2, row3);

 		row0 = Float4(tmp0.xy, tmp1.xy);
 		row1 = Float4(tmp0.zw, tmp1.zw);
 	}

 	void transpose4x1(Float4 &row0, Float4 &row1, Float4 &row2, Float4 &row3)
 	{
 		Float4 tmp0 = UnpackLow(row0, row1);
 		Float4 tmp1 = UnpackLow(row2, row3);

 		row0 = Float4(tmp0.xy, tmp1.xy);
 	}

 	void transpose2x4(Float4 &row0, Float4 &row1, Float4 &row2, Float4 &row3)
 	{
 		row0 = UnpackLow(row0, row1);
 		row1 = Float4(row0.zw, row1.zw);
 		row2 = UnpackHigh(row0, row1);
 		row3 = Float4(row2.zw, row3.zw);
 	}

 	void transpose2x4h(Float4 &row0, Float4 &row1, Float4 &row2, Float4 &row3)
 	{
 		row0 = UnpackLow(row2, row3);
 		row1 = Float4(row0.zw, row1.zw);
 		row2 = UnpackHigh(row2, row3);
 		row3 = Float4(row2.zw, row3.zw);
 	}

 	void transpose4xN(Float4 &row0, Float4 &row1, Float4 &row2, Float4 &row3, int N)
 	{
 		switch(N)
 		{
 		case 1: transpose4x1(row0, row1, row2, row3); break;
 		case 2: transpose4x2(row0, row1, row2, row3); break;
 		case 3: transpose4x3(row0, row1, row2, row3); break;
 		case 4: transpose4x4(row0, row1, row2, row3); break;
 		}
 	}
 }
	// SwiftShader Software Renderer
	//
	// Copyright(c) 2005-2011 TransGaming Inc.
	//
	// All rights reserved. No part of this software may be copied, distributed, transmitted,
	// transcribed, stored in a retrieval system, translated into any human or computer
	// language by any means, or disclosed to third parties without the explicit written
	// agreement of TransGaming Inc. Without such an agreement, no rights or licenses, express
	// or implied, including but not limited to any patent rights, are granted to you.
	//

	#include "Shell.hpp"

	namespace sw
	{
	TranscendentalPrecision logPrecision = ACCURATE;
	TranscendentalPrecision expPrecision = ACCURATE;
	TranscendentalPrecision rcpPrecision = ACCURATE;
	TranscendentalPrecision rsqPrecision = ACCURATE;
	bool perspectiveCorrection = true;

	Color4i::Color4i() : x(r), y(g), z(b), w(a)
	{
	}

	Color4i::Color4i(unsigned short red, unsigned short green, unsigned short blue, unsigned short alpha) : x(r), y(g), z(b), w(a)
	{
	r = Short4(red);
	g = Short4(green);
	b = Short4(blue);
	a = Short4(alpha);
	}

	Color4i::Color4i(const Color4i &rhs) : x(r), y(g), z(b), w(a)
	{
	r = rhs.r;
	g = rhs.g;
	b = rhs.b;
	a = rhs.a;
	}

	Color4i &Color4i::operator=(const Color4i &rhs)
	{
	r = rhs.r;
	g = rhs.g;
	b = rhs.b;
	a = rhs.a;

	return *this;
	}

	Short4 &Color4i::operator[](int i)
	{
	switch(i)
	{
	case 0: return x;
	case 1: return y;
	case 2: return z;
	case 3: return w;
	}

	return x;
	}

	Color4f::Color4f() : x(r), y(g), z(b), w(a), u(r), v(g), s(b), t(a)
	{
	}

	Color4f::Color4f(float red, float green, float blue, float alpha) : x(r), y(g), z(b), w(a), u(r), v(g), s(b), t(a)
	{
	r = Float4(red);
	g = Float4(green);
	b = Float4(blue);
	a = Float4(alpha);
	}

	Color4f::Color4f(const Color4f &rhs) : x(r), y(g), z(b), w(a), u(r), v(g), s(b), t(a)
	{
	r = rhs.r;
	g = rhs.g;
	b = rhs.b;
	a = rhs.a;
	}

	Color4f &Color4f::operator=(const Color4f &rhs)
	{
	r = rhs.r;
	g = rhs.g;
	b = rhs.b;
	a = rhs.a;

	return *this;
	}

	Float4 &Color4f::operator[](int i)
	{
	switch(i)
	{
	case 0: return x;
	case 1: return y;
	case 2: return z;
	case 3: return w;
	}

	return x;
	}

	Float4 exponential(Float4 &src, bool pp)
	{
	Float4 x0;
	Float4 x1;
	Int4 x2;

	x0 = src;

	x0 = Min(x0, As<Float4>(Int4(0x43010000, 0x43010000, 0x43010000, 0x43010000))); // 129.00000e+0f
	x0 = Max(x0, As<Float4>(Int4(0xC2FDFFFF, 0xC2FDFFFF, 0xC2FDFFFF, 0xC2FDFFFF))); // -126.99999e+0f
	x1 = x0;
	x1 -= Float4(0.5f, 0.5f, 0.5f, 0.5f);
	x2 = RoundInt(x1);
	x1 = Float4(x2);
	x2 += Int4(0x0000007F, 0x0000007F, 0x0000007F, 0x0000007F); // 127
	x2 = x2 << 23;
	x0 -= x1;
	x1 = As<Float4>(Int4(0x3AF61905, 0x3AF61905, 0x3AF61905, 0x3AF61905)); // 1.8775767e-3f
	x1 *= x0;
	x1 += As<Float4>(Int4(0x3C134806, 0x3C134806, 0x3C134806, 0x3C134806)); // 8.9893397e-3f
	x1 *= x0;
	x1 += As<Float4>(Int4(0x3D64AA23, 0x3D64AA23, 0x3D64AA23, 0x3D64AA23)); // 5.5826318e-2f
	x1 *= x0;
	x1 += As<Float4>(Int4(0x3E75EAD4, 0x3E75EAD4, 0x3E75EAD4, 0x3E75EAD4)); // 2.4015361e-1f
	x1 *= x0;
	x1 += As<Float4>(Int4(0x3F31727B, 0x3F31727B, 0x3F31727B, 0x3F31727B)); // 6.9315308e-1f
	x1 *= x0;
	x1 += As<Float4>(Int4(0x3F7FFFFF, 0x3F7FFFFF, 0x3F7FFFFF, 0x3F7FFFFF)); // 9.9999994e-1f
	x1 *= As<Float4>(x2);

	return x1;
	}

	Float4 logarithm(Float4 &src, bool absolute, bool pp)
	{
	Float4 x0;
	Float4 x1;
	Float4 x2;
	Float4 x3;

	x0 = src;

	x1 = As<Float4>(As<Int4>(x0) & Int4(0x7F800000));
	x1 = As<Float4>(As<UInt4>(x1) >> 8);
	x1 = As<Float4>(As<Int4>(x1) \| As<Int4>(Float4(1.0f)));
	x1 = (x1 - Float4(1.4960938f)) * Float4(256.0f); // FIXME: (x1 - 1.4960938f) * 256.0f;
	x0 = As<Float4>((As<Int4>(x0) & Int4(0x007FFFFF)) \| As<Int4>(Float4(1.0f)));

	x2 = (Float4(9.5428179e-2f) * x0 + Float4(4.7779095e-1f)) * x0 + Float4(1.9782813e-1f);
	x3 = ((Float4(1.6618466e-2f) * x0 + Float4(2.0350508e-1f)) * x0 + Float4(2.7382900e-1f)) * x0 + Float4(4.0496687e-2f);
	x2 /= x3;

	x1 += (x0 - Float4(1.0f)) * x2;

	return x1;
	}

	Float4 power(Float4 &src0, Float4 &src1, bool pp)
	{
	Float4 log = logarithm(src0, true, pp);
	log *= src1;
	return exponential(log, pp);
	}

	Float4 reciprocal(Float4 &src, bool pp, bool finite)
	{
	Float4 dst;

	if(!pp && rcpPrecision >= WHQL)
	{
	dst = Float4(1, 1, 1, 1) / src;
	}
	else
	{
	dst = Rcp_pp(src);

	if(!pp)
	{
	dst = (dst + dst) - (src * dst * dst);
	}
	}

	if(finite)
	{
	int x = 0x7F7FFFFF;
	dst = Min(dst, Float4((float&)x, (float&)x, (float&)x, (float&)x));
	}

	return dst;
	}

	Float4 reciprocalSquareRoot(Float4 &src, bool absolute, bool pp)
	{
	Float4 abs = src;

	if(absolute)
	{
	abs = Abs(abs);
	}

	Float4 rsq;

	if(!pp && rsqPrecision >= IEEE)
	{
	rsq = Float4(1.0f, 1.0f, 1.0f, 1.0f) / Sqrt(abs);
	}
	else
	{
	rsq = RcpSqrt_pp(abs);

	if(!pp)
	{
	rsq = rsq * (Float4(3.0f) - rsq * rsq * abs) * Float4(0.5f);
	}
	}

	int x = 0x7F7FFFFF;
	rsq = Min(rsq, Float4((float&)x, (float&)x, (float&)x, (float&)x));

	return rsq;
	}

	Float4 sine(Float4 &src, bool pp)
	{
	const Float4 A = Float4(-4.05284734e-1f); // -4/pi^2
	const Float4 B = Float4(1.27323954e+0f); // 4/pi
	const Float4 C = Float4(7.75160950e-1f);
	const Float4 D = Float4(2.24839049e-1f);

	// Parabola approximating sine
	Float4 sin = src * (Abs(src) * A + B);

	// Improve precision from 0.06 to 0.001
	if(true)
	{
	sin = sin * (Abs(sin) * D + C);
	}

	return sin;
	}

	Float4 dot3(Color4f &src0, Color4f &src1)
	{
	return src0.x * src1.x + src0.y * src1.y + src0.z * src1.z;
	}

	Float4 dot4(Color4f &src0, Color4f &src1)
	{
	return src0.x * src1.x + src0.y * src1.y + src0.z * src1.z + src0.w * src1.w;
	}

	void transpose4x4(Short4 &row0, Short4 &row1, Short4 &row2, Short4 &row3)
	{
	Int2 tmp0 = UnpackHigh(row0, row1);
	Int2 tmp1 = UnpackHigh(row2, row3);
	Int2 tmp2 = UnpackLow(row0, row1);
	Int2 tmp3 = UnpackLow(row2, row3);

	row0 = As<Short4>(UnpackLow(tmp2, tmp3));
	row1 = As<Short4>(UnpackHigh(tmp2, tmp3));
	row2 = As<Short4>(UnpackLow(tmp0, tmp1));
	row3 = As<Short4>(UnpackHigh(tmp0, tmp1));
	}

	void transpose4x4(Float4 &row0, Float4 &row1, Float4 &row2, Float4 &row3)
	{
	Float4 tmp0 = UnpackLow(row0, row1);
	Float4 tmp1 = UnpackLow(row2, row3);
	Float4 tmp2 = UnpackHigh(row0, row1);
	Float4 tmp3 = UnpackHigh(row2, row3);

	row0 = Float4(tmp0.xy, tmp1.xy);
	row1 = Float4(tmp0.zw, tmp1.zw);
	row2 = Float4(tmp2.xy, tmp3.xy);
	row3 = Float4(tmp2.zw, tmp3.zw);
	}

	void transpose4x3(Float4 &row0, Float4 &row1, Float4 &row2, Float4 &row3)
	{
	Float4 tmp0 = UnpackLow(row0, row1);
	Float4 tmp1 = UnpackLow(row2, row3);
	Float4 tmp2 = UnpackHigh(row0, row1);
	Float4 tmp3 = UnpackHigh(row2, row3);

	row0 = Float4(tmp0.xy, tmp1.xy);
	row1 = Float4(tmp0.zw, tmp1.zw);
	row2 = Float4(tmp2.xy, tmp3.xy);
	}

	void transpose4x2(Float4 &row0, Float4 &row1, Float4 &row2, Float4 &row3)
	{
	Float4 tmp0 = UnpackLow(row0, row1);
	Float4 tmp1 = UnpackLow(row2, row3);

	row0 = Float4(tmp0.xy, tmp1.xy);
	row1 = Float4(tmp0.zw, tmp1.zw);
	}

	void transpose4x1(Float4 &row0, Float4 &row1, Float4 &row2, Float4 &row3)
	{
	Float4 tmp0 = UnpackLow(row0, row1);
	Float4 tmp1 = UnpackLow(row2, row3);

	row0 = Float4(tmp0.xy, tmp1.xy);
	}

	void transpose2x4(Float4 &row0, Float4 &row1, Float4 &row2, Float4 &row3)
	{
	row0 = UnpackLow(row0, row1);
	row1 = Float4(row0.zw, row1.zw);
	row2 = UnpackHigh(row0, row1);
	row3 = Float4(row2.zw, row3.zw);
	}

	void transpose2x4h(Float4 &row0, Float4 &row1, Float4 &row2, Float4 &row3)
	{
	row0 = UnpackLow(row2, row3);
	row1 = Float4(row0.zw, row1.zw);
	row2 = UnpackHigh(row2, row3);
	row3 = Float4(row2.zw, row3.zw);
	}

	void transpose4xN(Float4 &row0, Float4 &row1, Float4 &row2, Float4 &row3, int N)
	{
	switch(N)
	{
	case 1: transpose4x1(row0, row1, row2, row3); break;
	case 2: transpose4x2(row0, row1, row2, row3); break;
	case 3: transpose4x3(row0, row1, row2, row3); break;
	case 4: transpose4x4(row0, row1, row2, row3); break;
	}
	}
	}