ketmar new stuff

color.d

@@ -144,11 +144,7 @@ struct Color {
 	+/
 	nothrow pure
 	static Color fromIntegers(int red, int green, int blue, int alpha = 255) {
-		if(red < 0) red = 0; if(red > 255) red = 255;
-		if(green < 0) green = 0; if(green > 255) green = 255;
-		if(blue < 0) blue = 0; if(blue > 255) blue = 255;
-		if(alpha < 0) alpha = 0; if(alpha > 255) alpha = 255;
-		return Color(red, green, blue, alpha);
+		return Color(clampToByte(red), clampToByte(green), clampToByte(blue), clampToByte(alpha));
 	}
 
 	/// Construct a color with the given values. They should be in range 0 <= x <= 255, where 255 is maximum intensity and 0 is minimum intensity.
@@ -202,8 +198,7 @@ struct Color {
 
 	/// Return black-and-white color
 	Color toBW() () {
-		int intens = cast(int)(0.2126*r+0.7152*g+0.0722*b);
-		if (intens < 0) intens = 0; else if (intens > 255) intens = 255;
+		int intens = clampToByte(cast(int)(0.2126*r+0.7152*g+0.0722*b));
 		return Color(intens, intens, intens, a);
 	}
 
@@ -271,7 +266,7 @@ struct Color {
 				if(i < 3)
 					hsl[i] = toInternal!real(part.stripInternal);
 				else
-					a = cast(ubyte) (toInternal!real(part.stripInternal) * 255);
+					a = clampToByte(cast(int) (toInternal!real(part.stripInternal) * 255));
 			}
 
 			c = .fromHsl(hsl);
@@ -291,16 +286,16 @@ struct Color {
 				auto v = toInternal!real(part.stripInternal);
 				switch(i) {
 					case 0: // red
-						c.r = cast(ubyte) v;
+						c.r = clampToByte(cast(int) v);
 					break;
 					case 1:
-						c.g = cast(ubyte) v;
+						c.g = clampToByte(cast(int) v);
 					break;
 					case 2:
-						c.b = cast(ubyte) v;
+						c.b = clampToByte(cast(int) v);
 					break;
 					case 3:
-						c.a = cast(ubyte) (v * 255);
+						c.a = clampToByte(cast(int) (v * 255));
 					break;
 					default: // ignore
 				}
@@ -342,6 +337,62 @@ struct Color {
 	static Color fromHsl(real h, real s, real l) {
 		return .fromHsl(h, s, l);
 	}
+
+	// this is actually branch-less for ints on x86, and even for longs on x86_64
+	static ubyte clampToByte(T) (T n) pure nothrow @safe @nogc if (__traits(isIntegral, T)) {
+		static if (__VERSION__ > 2067) pragma(inline, true);
+		static if (T.sizeof == 2 || T.sizeof == 4) {
+			static if (__traits(isUnsigned, T)) {
+				return cast(ubyte)(n&0xff|(255-((-cast(int)(n < 256))>>24)));
+			} else {
+				n &= -cast(int)(n >= 0);
+				return cast(ubyte)(n|((255-cast(int)n)>>31));
+			}
+		} else static if (T.sizeof == 1) {
+			static assert(__traits(isUnsigned, T), "clampToByte: signed byte? no, really?");
+			return cast(ubyte)n;
+		} else static if (T.sizeof == 8) {
+			static if (__traits(isUnsigned, T)) {
+				return cast(ubyte)(n&0xff|(255-((-cast(long)(n < 256))>>56)));
+			} else {
+				n &= -cast(long)(n >= 0);
+				return cast(ubyte)(n|((255-cast(long)n)>>63));
+			}
+		} else {
+			static assert(false, "clampToByte: integer too big");
+		}
+	}
+
+	/** this mixin can be used to alphablend two `uint` colors;
+	 * `colu32name` is variable that holds color to blend,
+	 * `destu32name` is variable that holds "current" color (from surface, for example).
+	 * alpha value of `destu32name` doesn't matter.
+	 * alpha value of `colu32name` means: 255 for replace color, 0 for keep `destu32name`.
+	 *
+	 * WARNING! This function does blending in RGB space, and RGB space is not linear!
+	 */
+	public enum ColorBlendMixinStr(string colu32name, string destu32name) = "{
+		immutable uint a_tmp_ = (256-(255-(("~colu32name~")>>24)))&(-(1-(((255-(("~colu32name~")>>24))+1)>>8))); // to not loose bits, but 255 should become 0
+		immutable uint dc_tmp_ = ("~destu32name~")&0xffffff;
+		immutable uint srb_tmp_ = (("~colu32name~")&0xff00ff);
+		immutable uint sg_tmp_ = (("~colu32name~")&0x00ff00);
+		immutable uint drb_tmp_ = (dc_tmp_&0xff00ff);
+		immutable uint dg_tmp_ = (dc_tmp_&0x00ff00);
+		immutable uint orb_tmp_ = (drb_tmp_+(((srb_tmp_-drb_tmp_)*a_tmp_+0x800080)>>8))&0xff00ff;
+		immutable uint og_tmp_ = (dg_tmp_+(((sg_tmp_-dg_tmp_)*a_tmp_+0x008000)>>8))&0x00ff00;
+		("~destu32name~") = (orb_tmp_|og_tmp_)|0xff000000; /*&0xffffff;*/
+	}";
+
+
+	/// Perform alpha-blending of `fore` to this color, return new color.
+	/// WARNING! This function does blending in RGB space, and RGB space is not linear!
+	Color alphaBlend (Color fore) const pure nothrow @trusted @nogc {
+		static if (__VERSION__ > 2067) pragma(inline, true);
+		Color res;
+		res.asUint = asUint;
+		mixin(ColorBlendMixinStr!("fore.asUint", "res.asUint"));
+		return res;
+	}
 }
 
 nothrow @safe
@@ -440,10 +491,10 @@ Color fromHsl(real h, real s, real l, real a = 255) {
 	b += m;
 
 	return Color(
-		cast(ubyte)(r * 255),
-		cast(ubyte)(g * 255),
-		cast(ubyte)(b * 255),
-		cast(ubyte)(a));
+		cast(int)(r * 255),
+		cast(int)(g * 255),
+		cast(int)(b * 255),
+		cast(int)(a));
 }
 
 /// Converts an RGB color into an HSL triplet. useWeightedLightness will try to get a better value for luminosity for the human eye, which is more sensitive to green than red and more to red than blue. If it is false, it just does average of the rgb.
@@ -648,11 +699,7 @@ ubyte unalpha(ubyte colorYouHave, float alpha, ubyte backgroundColor) {
 	auto backgroundColorf = cast(float) backgroundColor;
 
 	auto answer = (resultingColorf - backgroundColorf + alpha * backgroundColorf) / alpha;
-	if(answer > 255)
-		return 255;
-	if(answer < 0)
-		return 0;
-	return cast(ubyte) answer;
+	return Color.clampToByte(cast(int) answer);
 }
 
 ///
@@ -666,11 +713,7 @@ ubyte makeAlpha(ubyte colorYouHave, ubyte backgroundColor/*, ubyte foreground =
 	auto alphaf = 1 - colorYouHave / backgroundColorf;
 	alphaf *= 255;
 
-	if(alphaf < 0)
-		return 0;
-	if(alphaf > 255)
-		return 255;
-	return cast(ubyte) alphaf;
+	return Color.clampToByte(cast(int) alphaf);
 }
 
 
@@ -1189,14 +1232,11 @@ img = imageFromPng(readPng(range.range)).getAsTrueColorImage;
 void removeTransparency(IndexedImage img, Color background)
 +/
 
-Color alphaBlend(Color foreground, Color background) {
-	if(foreground.a != 255)
-	foreach(idx, ref part; foreground.components) {
-		part = cast(ubyte) (part * foreground.a / 255 +
-			background.components[idx] * (255 - foreground.a) / 255);
-	}
-
-	return foreground;
+/// Perform alpha-blending of `fore` to this color, return new color.
+/// WARNING! This function does blending in RGB space, and RGB space is not linear!
+Color alphaBlend(Color foreground, Color background) pure nothrow @safe @nogc {
+	static if (__VERSION__ > 2067) pragma(inline, true);
+	return background.alphaBlend(foreground);
 }
 
 /*