diff --git a/src/Shader/SamplerCore.cpp b/src/Shader/SamplerCore.cpp
index a6f0715..1dc78bf 100644
--- a/src/Shader/SamplerCore.cpp
+++ b/src/Shader/SamplerCore.cpp
@@ -89,12 +89,13 @@
 		else
 		{
 			Int face[4];
-			Float4 lodU;
-			Float4 lodV;
+			Float4 lodX;
+			Float4 lodY;
+			Float4 lodZ;
 
 			if(state.textureType == TEXTURE_CUBE)
 			{
-				cubeFace(face, uuuu, vvvv, lodU, lodV, u, v, w);
+				cubeFace(face, uuuu, vvvv, lodX, lodY, lodZ, u, v, w);
 			}
 
 			Float lod;
@@ -110,7 +111,7 @@
 				}
 				else
 				{
-					computeLod(texture, lod, anisotropy, uDelta, vDelta, lodU, lodV, q.x, dsx, dsy, method);
+					computeLodCube(texture, lod, lodX, lodY, lodZ, q.x, dsx, dsy, method);
 				}
 			}
 			else
@@ -118,12 +119,6 @@
 				computeLod3D(texture, lod, uuuu, vvvv, wwww, q.x, dsx, dsy, method);
 			}
 
-			if(state.textureType == TEXTURE_CUBE)
-			{
-				uuuu += Float4(0.5f);
-				vvvv += Float4(0.5f);
-			}
-
 			if(!hasFloatTexture())
 			{
 				sampleFilter(texture, c, uuuu, vvvv, wwww, lod, anisotropy, uDelta, vDelta, face, method);
@@ -320,12 +315,13 @@
 				Float4 wwww = w;
 
 				Int face[4];
-				Float4 lodU;
-				Float4 lodV;
+				Float4 lodX;
+				Float4 lodY;
+				Float4 lodZ;
 
 				if(state.textureType == TEXTURE_CUBE)
 				{
-					cubeFace(face, uuuu, vvvv, lodU, lodV, u, v, w);
+					cubeFace(face, uuuu, vvvv, lodX, lodY, lodZ, u, v, w);
 				}
 
 				Float lod;
@@ -341,7 +337,7 @@
 					}
 					else
 					{
-						computeLod(texture, lod, anisotropy, uDelta, vDelta, lodU, lodV, q.x, dsx, dsy, method);
+						computeLodCube(texture, lod, lodX, lodY, lodZ, q.x, dsx, dsy, method);
 					}
 				}
 				else
@@ -349,12 +345,6 @@
 					computeLod3D(texture, lod, uuuu, vvvv, wwww, q.x, dsx, dsy, method);
 				}
 
-				if(state.textureType == TEXTURE_CUBE)
-				{
-					uuuu += Float4(0.5f);
-					vvvv += Float4(0.5f);
-				}
-
 				sampleFloatFilter(texture, c, uuuu, vvvv, wwww, lod, anisotropy, uDelta, vDelta, face, method);
 			}
 			else
@@ -1451,11 +1441,64 @@
 			{
 				lod += lodBias;
 			}
+		}
+		else
+		{
+			lod = lodBias + *Pointer<Float>(texture + OFFSET(Texture,LOD));
+		}
 
-			// FIXME: Hack to satisfy WHQL
-			if(state.textureType == TEXTURE_CUBE)
+		lod = Max(lod, 0.0f);
+		lod = Min(lod, Float(MIPMAP_LEVELS - 2));   // Trilinear accesses lod+1
+	}
+
+	void SamplerCore::computeLodCube(Pointer<Byte> &texture, Float &lod, Float4 &u, Float4 &v, Float4 &s, const Float &lodBias, Vector4f &dsx, Vector4f &dsy, SamplerMethod method)
+	{
+		if(method != Lod)
+		{
+			if(method != Grad)
 			{
-				lod += Float(-0.15f);
+				Float4 dudxy = u.ywyw - u;
+				Float4 dvdxy = v.ywyw - v;
+				Float4 dsdxy = s.ywyw - s;
+
+				// Scale by texture dimensions and LOD
+				dudxy *= *Pointer<Float4>(texture + OFFSET(Texture,widthLOD));
+				dvdxy *= *Pointer<Float4>(texture + OFFSET(Texture,widthLOD));
+				dsdxy *= *Pointer<Float4>(texture + OFFSET(Texture,widthLOD));
+
+				dudxy *= dudxy;
+				dvdxy *= dvdxy;
+				dsdxy *= dsdxy;
+
+				dudxy += dvdxy;
+				dudxy += dsdxy;
+
+				lod = Max(Float(dudxy.x), Float(dudxy.y));   // FIXME: Max(dudxy.x, dudxy.y);
+			}
+			else
+			{
+				Float4 dudxy = Float4(dsx.x.xx, dsy.x.xx);
+				Float4 dvdxy = Float4(dsx.y.xx, dsy.y.xx);
+
+				Float4 duvdxy = Float4(dudxy.xz, dvdxy.xz);
+
+				// Scale by texture dimensions and LOD
+				Float4 dUVdxy = duvdxy * *Pointer<Float4>(texture + OFFSET(Texture,widthLOD));
+
+				Float4 dUV2dxy = dUVdxy * dUVdxy;
+				Float4 dUV2 = dUV2dxy.xy + dUV2dxy.zw;
+
+				lod = Max(Float(dUV2.x), Float(dUV2.y));   // Square length of major axis
+			}
+
+			// log2(sqrt(lod))
+			lod = Float(As<Int>(lod));
+			lod -= Float(0x3F800000);
+			lod *= As<Float>(Int(0x33800000));
+
+			if(method == Bias)
+			{
+				lod += lodBias;
 			}
 		}
 		else
@@ -1535,22 +1578,22 @@
 		}
 	}
 
-	void SamplerCore::cubeFace(Int face[4], Float4 &U, Float4 &V, Float4 &lodU, Float4 &lodV, Float4 &x, Float4 &y, Float4 &z)
+	void SamplerCore::cubeFace(Int face[4], Float4 &U, Float4 &V, Float4 &lodX, Float4 &lodY, Float4 &lodZ, Float4 &x, Float4 &y, Float4 &z)
 	{
-		Int4 xp = CmpNLE(x, Float4(0.0f));   // x > 0
-		Int4 yp = CmpNLE(y, Float4(0.0f));   // y > 0
-		Int4 zp = CmpNLE(z, Float4(0.0f));   // z > 0
+		Int4 xn = CmpLT(x, Float4(0.0f));   // x < 0
+		Int4 yn = CmpLT(y, Float4(0.0f));   // y < 0
+		Int4 zn = CmpLT(z, Float4(0.0f));   // z < 0
 
 		Float4 absX = Abs(x);
 		Float4 absY = Abs(y);
 		Float4 absZ = Abs(z);
+
 		Int4 xy = CmpNLE(absX, absY);   // abs(x) > abs(y)
 		Int4 yz = CmpNLE(absY, absZ);   // abs(y) > abs(z)
 		Int4 zx = CmpNLE(absZ, absX);   // abs(z) > abs(x)
-
-		Int4 xyz = ~zx & xy;   // abs(x) > abs(y) && abs(x) > abs(z)
-		Int4 yzx = ~xy & yz;   // abs(y) > abs(z) && abs(y) > abs(x)
-		Int4 zxy = ~yz & zx;   // abs(z) > abs(x) && abs(z) > abs(y)
+		Int4 xMajor = xy & ~zx;   // abs(x) > abs(y) && abs(x) > abs(z)
+		Int4 yMajor = yz & ~xy;   // abs(y) > abs(z) && abs(y) > abs(x)
+		Int4 zMajor = zx & ~yz;   // abs(z) > abs(x) && abs(z) > abs(y)
 
 		// FACE_POSITIVE_X = 000b
 		// FACE_NEGATIVE_X = 001b
@@ -1559,10 +1602,10 @@
 		// FACE_POSITIVE_Z = 100b
 		// FACE_NEGATIVE_Z = 101b
 
-		Int yAxis = SignMask(yzx);
-		Int zAxis = SignMask(zxy);
+		Int yAxis = SignMask(yMajor);
+		Int zAxis = SignMask(zMajor);
 
-		Int4 n = (~xp & xyz) | (~yp & yzx) | (~zp & zxy);
+		Int4 n = ((xn & xMajor) | (yn & yMajor) | (zn & zMajor)) & Int4(0x80000000);
 		Int negative = SignMask(n);
 
 		face[0] = *Pointer<Int>(constants + OFFSET(Constants,transposeBit0) + negative * 4);
@@ -1573,40 +1616,21 @@
 		face[3] = (face[0] >> 12) & 0x7;
 		face[0] &= 0x7;
 
-		// U = xyz * -z + ~xyz * (yzx * ~yp * -x + (yzx * ~yp) * x)
-		U = As<Float4>((xyz & As<Int4>(-z)) | (~xyz & (((yzx & ~yp) & Int4(0x80000000, 0x80000000, 0x80000000, 0x80000000)) ^ As<Int4>(x))));
+		Float4 M = Max(Max(absX, absY), absZ);
 
-		// V = yzx * z + ~yzx * (~neg * -y + neg * y)
-		V = As<Float4>((~yzx & ((~n & Int4(0x80000000, 0x80000000, 0x80000000, 0x80000000)) ^ As<Int4>(y))) | (yzx & As<Int4>(z)));
+		// U = xMajor ? (neg ^ -z) : (zMajor & neg) ^ x)
+		U = As<Float4>((xMajor & (n ^ As<Int4>(-z))) | (~xMajor & ((zMajor & n) ^ As<Int4>(x))));
 
-		// M = xyz * x + yzx * y + zxy * z
-		Float4 M = As<Float4>((xyz & As<Int4>(x)) | (yzx & As<Int4>(y)) | (zxy & As<Int4>(z)));
+		// V = !yMajor ? -y : (n ^ z)
+		V = As<Float4>((~yMajor & As<Int4>(-y)) | (yMajor & (n ^ As<Int4>(z))));
 
-		M = reciprocal(M);
-		U *= M * Float4(0.5f);
-		V *= M * Float4(0.5f);
+		M = reciprocal(M) * Float4(0.5f);
+		U = U * M + Float4(0.5f);
+		V = V * M + Float4(0.5f);
 
-		// Project coordinates onto one face for consistent LOD calculation
-		{
-			yp = Swizzle(yp, 0);
-			n = Swizzle(n, 0);
-			xyz = Swizzle(xyz, 0);
-			yzx = Swizzle(yzx, 0);
-			zxy = Swizzle(zxy, 0);
-
-			// U = xyz * -z + ~xyz * (yzx * ~yp * -x + (yzx * ~yp) * x)
-			lodU = As<Float4>((xyz & As<Int4>(-z)) | (~xyz & (((yzx & ~yp) & Int4(0x80000000, 0x80000000, 0x80000000, 0x80000000)) ^ As<Int4>(x))));
-
-			// V = yzx * z + ~yzx * (~neg * -y + neg * y)
-			lodV = As<Float4>((~yzx & ((~n & Int4(0x80000000, 0x80000000, 0x80000000, 0x80000000)) ^ As<Int4>(y))) | (yzx & As<Int4>(z)));
-
-			// M = xyz * x + yzx * y + zxy * z
-			Float4 M = As<Float4>((xyz & As<Int4>(x)) | (yzx & As<Int4>(y)) | (zxy & As<Int4>(z)));
-
-			M = Rcp_pp(M);
-			lodU *= M * Float4(0.5f);
-			lodV *= M * Float4(0.5f);
-		}
+		lodX = x * M;
+		lodY = y * M;
+		lodZ = z * M;
 	}
 
 	void SamplerCore::computeIndices(Int index[4], Short4 uuuu, Short4 vvvv, Short4 wwww, const Pointer<Byte> &mipmap)