Preserving original AGX Punchy from old PR

DanielSnd · DanielSnd · commit f78975e6b773 · 2025-03-26T17:42:24.000-03:00
Add AGX and AGX Punchy tonemapper options to Environment

removed duplicated tonemap_agx method in tonemap_incl.glsl and readded alternative agx_punchy methods

tonemap agx punchy
diff --git a/drivers/gles3/shaders/tonemap_inc.glsl b/drivers/gles3/shaders/tonemap_inc.glsl
@@ -27,13 +27,6 @@ vec3 srgb_to_linear(vec3 color) {
 
 #ifdef APPLY_TONEMAPPING
 
-// Based on Reinhard's extended formula, see equation 4 in https://doi.org/cjbgrt
-vec3 tonemap_reinhard(vec3 color, float p_white) {
-	float white_squared = p_white * p_white;
-	vec3 white_squared_color = white_squared * color;
-	// Equivalent to color * (1 + color / white_squared) / (1 + color)
-	return (white_squared_color + color * color) / (white_squared_color + white_squared);
-}
 
 vec3 tonemap_filmic(vec3 color, float p_white) {
 	// exposure bias: input scale (color *= bias, white *= bias) to make the brightness consistent with other tonemappers
@@ -84,76 +77,82 @@ vec3 tonemap_aces(vec3 color, float p_white) {
 	return color_tonemapped / p_white_tonemapped;
 }
 
-// Polynomial approximation of EaryChow's AgX sigmoid curve.
-// x must be within the range [0.0, 1.0]
-vec3 agx_contrast_approx(vec3 x) {
-	// Generated with Excel trendline
-	// Input data: Generated using python sigmoid with EaryChow's configuration and 57 steps
-	// Additional padding values were added to give correct intersections at 0.0 and 1.0
-	// 6th order, intercept of 0.0 to remove an operation and ensure intersection at 0.0
+// Based on Reinhard's extended formula, see equation 4 in https://doi.org/cjbgrt
+vec3 tonemap_reinhard(vec3 color, float p_white) {
+	float white_squared = p_white * p_white;
+	vec3 white_squared_color = white_squared * color;
+	// Equivalent to color * (1 + color / white_squared) / (1 + color)
+	return (white_squared_color + color * color) / (white_squared_color + white_squared);
+}
+
+// Mean error^2: 3.6705141e-06
+vec3 agx_default_contrast_approx(vec3 x) {
 	vec3 x2 = x * x;
 	vec3 x4 = x2 * x2;
-	return 0.021 * x + 4.0111 * x2 - 25.682 * x2 * x + 70.359 * x4 - 74.778 * x4 * x + 27.069 * x4 * x2;
+
+	return +15.5 * x4 * x2 - 40.14 * x4 * x + 31.96 * x4 - 6.868 * x2 * x + 0.4298 * x2 + 0.1191 * x - 0.00232;
 }
 
-// This is an approximation and simplification of EaryChow's AgX implementation that is used by Blender.
-// This code is based off of the script that generates the AgX_Base_sRGB.cube LUT that Blender uses.
-// Source: https://github.com/EaryChow/AgX_LUT_Gen/blob/main/AgXBasesRGB.py
-vec3 tonemap_agx(vec3 color) {
-	// Combined linear sRGB to linear Rec 2020 and Blender AgX inset matrices:
-	const mat3 srgb_to_rec2020_agx_inset_matrix = mat3(
-			0.54490813676363087053, 0.14044005884001287035, 0.088827411851915368603,
-			0.37377945959812267119, 0.75410959864013760045, 0.17887712465043811023,
-			0.081384976686407536266, 0.10543358536857773485, 0.73224999956948382528);
-
-	// Combined inverse AgX outset matrix and linear Rec 2020 to linear sRGB matrices.
-	const mat3 agx_outset_rec2020_to_srgb_matrix = mat3(
-			1.9645509602733325934, -0.29932243390911083839, -0.16436833806080403409,
-			-0.85585845117807513559, 1.3264510741502356555, -0.23822464068860595117,
-			-0.10886710826831608324, -0.027084020983874825605, 1.402665347143271889);
-
-	// LOG2_MIN      = -10.0
-	// LOG2_MAX      =  +6.5
-	// MIDDLE_GRAY   =  0.18
-	const float min_ev = -12.4739311883324; // log2(pow(2, LOG2_MIN) * MIDDLE_GRAY)
-	const float max_ev = 4.02606881166759; // log2(pow(2, LOG2_MAX) * MIDDLE_GRAY)
-
-	// Large negative values in one channel and large positive values in other
-	// channels can result in a colour that appears darker and more saturated than
-	// desired after passing it through the inset matrix. For this reason, it is
-	// best to prevent negative input values.
-	// This is done before the Rec. 2020 transform to allow the Rec. 2020
-	// transform to be combined with the AgX inset matrix. This results in a loss
-	// of color information that could be correctly interpreted within the
-	// Rec. 2020 color space as positive RGB values, but it is less common for Godot
-	// to provide this function with negative sRGB values and therefore not worth
-	// the performance cost of an additional matrix multiplication.
-	// A value of 2e-10 intentionally introduces insignificant error to prevent
-	// log2(0.0) after the inset matrix is applied; color will be >= 1e-10 after
-	// the matrix transform.
-	color = max(color, 2e-10);
-
-	// Do AGX in rec2020 to match Blender and then apply inset matrix.
-	color = srgb_to_rec2020_agx_inset_matrix * color;
+vec3 agx(vec3 val, float white) {
+	const mat3 agx_mat = mat3(
+			0.842479062253094, 0.0423282422610123, 0.0423756549057051,
+			0.0784335999999992, 0.878468636469772, 0.0784336,
+			0.0792237451477643, 0.0791661274605434, 0.879142973793104);
+
+	const float min_ev = -12.47393f;
+	float max_ev = log2(white);
+
+	// Input transform (inset).
+	val = agx_mat * val;
 
 	// Log2 space encoding.
-	// Must be clamped because agx_contrast_approx may not work
-	// well with values outside of the range [0.0, 1.0]
-	color = clamp(log2(color), min_ev, max_ev);
-	color = (color - min_ev) / (max_ev - min_ev);
+	val = clamp(log2(val), min_ev, max_ev);
+	val = (val - min_ev) / (max_ev - min_ev);
 
 	// Apply sigmoid function approximation.
-	color = agx_contrast_approx(color);
+	val = agx_default_contrast_approx(val);
+
+	return val;
+}
+
+vec3 agx_eotf(vec3 val) {
+	const mat3 agx_mat_inv = mat3(
+			1.19687900512017, -0.0528968517574562, -0.0529716355144438,
+			-0.0980208811401368, 1.15190312990417, -0.0980434501171241,
+			-0.0990297440797205, -0.0989611768448433, 1.15107367264116);
 
-	// Convert back to linear before applying outset matrix.
-	color = pow(color, vec3(2.4));
+	// Inverse input transform (outset).
+	val = agx_mat_inv * val;
 
-	// Apply outset to make the result more chroma-laden and then go back to linear sRGB.
-	color = agx_outset_rec2020_to_srgb_matrix * color;
+	// sRGB IEC 61966-2-1 2.2 Exponent Reference EOTF Display
+	// NOTE: We're linearizing the output here. Comment/adjust when
+	// *not* using a sRGB render target.
+	val = pow(val, vec3(2.2));
 
-	// Blender's lusRGB.compensate_low_side is too complex for this shader, so
-	// simply return the color, even if it has negative components. These negative
-	// components may be useful for subsequent color adjustments.
+	return val;
+}
+
+vec3 agx_look_punchy(vec3 val) {
+	const vec3 lw = vec3(0.2126, 0.7152, 0.0722);
+	float luma = dot(val, lw);
+
+	vec3 offset = vec3(0.0);
+	vec3 slope = vec3(1.0);
+	vec3 power = vec3(1.35, 1.35, 1.35);
+	float sat = 1.4;
+
+	// ASC CDL.
+	val = pow(val * slope + offset, power);
+	return luma + sat * (val - luma);
+}
+
+// Adapted from https://iolite-engine.com/blog_posts/minimal_agx_implementation
+vec3 tonemap_agx(vec3 color, float white, bool punchy) {
+	color = agx(color, white);
+	if (punchy) {
+		color = agx_look_punchy(color);
+	}
+	color = agx_eotf(color);
 	return color;
 }
 
@@ -162,6 +161,7 @@ vec3 tonemap_agx(vec3 color) {
 #define TONEMAPPER_FILMIC 2
 #define TONEMAPPER_ACES 3
 #define TONEMAPPER_AGX 4
+#define TONEMAPPER_AGX_PUNCHY 5
 
 vec3 apply_tonemapping(vec3 color, float p_white) { // inputs are LINEAR
 	// Ensure color values passed to tonemappers are positive.
@@ -174,8 +174,10 @@ vec3 apply_tonemapping(vec3 color, float p_white) { // inputs are LINEAR
 		return tonemap_filmic(max(vec3(0.0f), color), p_white);
 	} else if (tonemapper == TONEMAPPER_ACES) {
 		return tonemap_aces(max(vec3(0.0f), color), p_white);
-	} else { // TONEMAPPER_AGX
-		return tonemap_agx(color);
+	} else if (tonemapper == TONEMAPPER_AGX) {
+		return tonemap_agx(max(vec3(0.0f), color), p_white, false);
+	} else { // TONEMAPPER_AGX_PUNCHY
+		return tonemap_agx(max(vec3(0.0f), color), p_white, true);
 	}
 }
 
diff --git a/scene/resources/environment.cpp b/scene/resources/environment.cpp
@@ -1276,7 +1276,7 @@ void Environment::_bind_methods() {
 	ClassDB::bind_method(D_METHOD("get_tonemap_white"), &Environment::get_tonemap_white);
 
 	ADD_GROUP("Tonemap", "tonemap_");
-	ADD_PROPERTY(PropertyInfo(Variant::INT, "tonemap_mode", PROPERTY_HINT_ENUM, "Linear,Reinhard,Filmic,ACES,AgX"), "set_tonemapper", "get_tonemapper");
+	ADD_PROPERTY(PropertyInfo(Variant::INT, "tonemap_mode", PROPERTY_HINT_ENUM, "Linear,Reinhard,Filmic,ACES,AgX,AgX Punchy"), "set_tonemapper", "get_tonemapper");
 	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "tonemap_exposure", PROPERTY_HINT_RANGE, "0,16,0.01"), "set_tonemap_exposure", "get_tonemap_exposure");
 	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "tonemap_white", PROPERTY_HINT_RANGE, "0,16,0.01"), "set_tonemap_white", "get_tonemap_white");
 
@@ -1582,6 +1582,7 @@ void Environment::_bind_methods() {
 	BIND_ENUM_CONSTANT(TONE_MAPPER_FILMIC);
 	BIND_ENUM_CONSTANT(TONE_MAPPER_ACES);
 	BIND_ENUM_CONSTANT(TONE_MAPPER_AGX);
+	BIND_ENUM_CONSTANT(TONE_MAPPER_AGX_PUNCHY);
 
 	BIND_ENUM_CONSTANT(GLOW_BLEND_MODE_ADDITIVE);
 	BIND_ENUM_CONSTANT(GLOW_BLEND_MODE_SCREEN);
diff --git a/scene/resources/environment.h b/scene/resources/environment.h
@@ -68,6 +68,7 @@ class Environment : public Resource {
 		TONE_MAPPER_FILMIC,
 		TONE_MAPPER_ACES,
 		TONE_MAPPER_AGX,
+		TONE_MAPPER_AGX_PUNCHY,
 	};
 
 	enum SDFGIYScale {
diff --git a/servers/rendering/renderer_rd/shaders/effects/tonemap.glsl b/servers/rendering/renderer_rd/shaders/effects/tonemap.glsl
@@ -276,6 +276,82 @@ vec3 agx_contrast_approx(vec3 x) {
 	return 0.021 * x + 4.0111 * x2 - 25.682 * x2 * x + 70.359 * x4 - 74.778 * x4 * x + 27.069 * x4 * x2;
 }
 
+// Mean error^2: 3.6705141e-06
+vec3 agx_punchy_default_contrast_approx(vec3 x) {
+	vec3 x2 = x * x;
+	vec3 x4 = x2 * x2;
+
+	return +15.5 * x4 * x2 - 40.14 * x4 * x + 31.96 * x4 - 6.868 * x2 * x + 0.4298 * x2 + 0.1191 * x - 0.00232;
+}
+
+vec3 agx(vec3 val, float white) {
+	const mat3 agx_mat = mat3(
+			0.842479062253094, 0.0423282422610123, 0.0423756549057051,
+			0.0784335999999992, 0.878468636469772, 0.0784336,
+			0.0792237451477643, 0.0791661274605434, 0.879142973793104);
+
+	const float min_ev = -12.47393f;
+	float max_ev = log2(white);
+
+	// Input transform (inset).
+	val = agx_mat * val;
+
+	// Log2 space encoding.
+	val = clamp(log2(val), min_ev, max_ev);
+	val = (val - min_ev) / (max_ev - min_ev);
+
+	// Apply sigmoid function approximation.
+	val = agx_punchy_default_contrast_approx(val);
+
+	return val;
+}
+
+vec3 agx_eotf(vec3 val) {
+	const mat3 agx_mat_inv = mat3(
+			1.19687900512017, -0.0528968517574562, -0.0529716355144438,
+			-0.0980208811401368, 1.15190312990417, -0.0980434501171241,
+			-0.0990297440797205, -0.0989611768448433, 1.15107367264116);
+
+	// Inverse input transform (outset).
+	val = agx_mat_inv * val;
+
+	// sRGB IEC 61966-2-1 2.2 Exponent Reference EOTF Display
+	// NOTE: We're linearizing the output here. Comment/adjust when
+	// *not* using a sRGB render target.
+	val = pow(val, vec3(2.2));
+
+	return val;
+}
+
+vec3 agx_look_punchy(vec3 val) {
+	const vec3 lw = vec3(0.2126, 0.7152, 0.0722);
+	float luma = dot(val, lw);
+
+	vec3 offset = vec3(0.0);
+	vec3 slope = vec3(1.0);
+	vec3 power = vec3(1.35, 1.35, 1.35);
+	float sat = 1.4;
+
+	// ASC CDL.
+	val = pow(val * slope + offset, power);
+	return luma + sat * (val - luma);
+}
+
+const mat3 LINEAR_SRGB_TO_LINEAR_REC2020 = mat3(
+		vec3(0.6274, 0.0691, 0.0164),
+		vec3(0.3293, 0.9195, 0.0880),
+		vec3(0.0433, 0.0113, 0.8956));
+
+// Adapted from https://iolite-engine.com/blog_posts/minimal_agx_implementation
+vec3 tonemap_agx_punchy(vec3 color, float white, bool punchy) {
+	color = agx(color, white);
+	if (punchy) {
+		color = agx_look_punchy(color);
+	}
+	color = agx_eotf(color);
+	return color;
+}
+
 // This is an approximation and simplification of EaryChow's AgX implementation that is used by Blender.
 // This code is based off of the script that generates the AgX_Base_sRGB.cube LUT that Blender uses.
 // Source: https://github.com/EaryChow/AgX_LUT_Gen/blob/main/AgXBasesRGB.py
@@ -337,6 +413,7 @@ vec3 tonemap_agx(vec3 color) {
 	return color;
 }
 
+
 vec3 linear_to_srgb(vec3 color) {
 	//if going to srgb, clamp from 0 to 1.
 	color = clamp(color, vec3(0.0), vec3(1.0));
@@ -349,6 +426,7 @@ vec3 linear_to_srgb(vec3 color) {
 #define TONEMAPPER_FILMIC 2
 #define TONEMAPPER_ACES 3
 #define TONEMAPPER_AGX 4
+#define TONEMAPPER_AGX_PUNCHY 5
 
 vec3 apply_tonemapping(vec3 color, float white) { // inputs are LINEAR
 	// Ensure color values passed to tonemappers are positive.
@@ -361,8 +439,10 @@ vec3 apply_tonemapping(vec3 color, float white) { // inputs are LINEAR
 		return tonemap_filmic(max(vec3(0.0f), color), white);
 	} else if (params.tonemapper == TONEMAPPER_ACES) {
 		return tonemap_aces(max(vec3(0.0f), color), white);
-	} else { // TONEMAPPER_AGX
+	} else if (params.tonemapper == TONEMAPPER_AGX) {
 		return tonemap_agx(color);
+	} else { // TONEMAPPER_AGX_PUNCHY
+		return tonemap_agx_punchy(max(vec3(0.0f), color), white, true);
 	}
 }
 
diff --git a/servers/rendering_server.cpp b/servers/rendering_server.cpp
@@ -3076,6 +3076,7 @@ void RenderingServer::_bind_methods() {
 	BIND_ENUM_CONSTANT(ENV_TONE_MAPPER_FILMIC);
 	BIND_ENUM_CONSTANT(ENV_TONE_MAPPER_ACES);
 	BIND_ENUM_CONSTANT(ENV_TONE_MAPPER_AGX);
+	BIND_ENUM_CONSTANT(ENV_TONE_MAPPER_AGX_PUNCHY);
 
 	BIND_ENUM_CONSTANT(ENV_SSR_ROUGHNESS_QUALITY_DISABLED);
 	BIND_ENUM_CONSTANT(ENV_SSR_ROUGHNESS_QUALITY_LOW);
diff --git a/servers/rendering_server.h b/servers/rendering_server.h
@@ -1254,6 +1254,7 @@ class RenderingServer : public Object {
 		ENV_TONE_MAPPER_FILMIC,
 		ENV_TONE_MAPPER_ACES,
 		ENV_TONE_MAPPER_AGX,
+		ENV_TONE_MAPPER_AGX_PUNCHY,
 	};
 
 	virtual void environment_set_tonemap(RID p_env, EnvironmentToneMapper p_tone_mapper, float p_exposure, float p_white) = 0;
