Move GLTF light conversion code into GLTFLight

2 files changed, 125 insertions, 0 deletions

diff --git a/modules/gltf/extensions/gltf_light.cpp b/modules/gltf/extensions/gltf_light.cpp
index af21a4e804..ab5a15c671 100644
--- a/modules/gltf/extensions/gltf_light.cpp
+++ b/modules/gltf/extensions/gltf_light.cpp
@@ -31,6 +31,12 @@
 #include "gltf_light.h"
 
 void GLTFLight::_bind_methods() {
+	ClassDB::bind_static_method("GLTFLight", D_METHOD("from_node", "light_node"), &GLTFLight::from_node);
+	ClassDB::bind_method(D_METHOD("to_node"), &GLTFLight::to_node);
+
+	ClassDB::bind_static_method("GLTFLight", D_METHOD("from_dictionary", "dictionary"), &GLTFLight::from_dictionary);
+	ClassDB::bind_method(D_METHOD("to_dictionary"), &GLTFLight::to_dictionary);
+
 	ClassDB::bind_method(D_METHOD("get_color"), &GLTFLight::get_color);
 	ClassDB::bind_method(D_METHOD("set_color", "color"), &GLTFLight::set_color);
 	ClassDB::bind_method(D_METHOD("get_intensity"), &GLTFLight::get_intensity);
@@ -99,3 +105,116 @@ float GLTFLight::get_outer_cone_angle() {
 void GLTFLight::set_outer_cone_angle(float p_outer_cone_angle) {
 	outer_cone_angle = p_outer_cone_angle;
 }
+
+Ref<GLTFLight> GLTFLight::from_node(const Light3D *p_light) {
+	Ref<GLTFLight> l;
+	l.instantiate();
+	l->color = p_light->get_color();
+	if (cast_to<DirectionalLight3D>(p_light)) {
+		l->light_type = "directional";
+		const DirectionalLight3D *light = cast_to<const DirectionalLight3D>(p_light);
+		l->intensity = light->get_param(DirectionalLight3D::PARAM_ENERGY);
+		l->range = FLT_MAX; // Range for directional lights is infinite in Godot.
+	} else if (cast_to<const OmniLight3D>(p_light)) {
+		l->light_type = "point";
+		const OmniLight3D *light = cast_to<const OmniLight3D>(p_light);
+		l->range = light->get_param(OmniLight3D::PARAM_RANGE);
+		l->intensity = light->get_param(OmniLight3D::PARAM_ENERGY);
+	} else if (cast_to<const SpotLight3D>(p_light)) {
+		l->light_type = "spot";
+		const SpotLight3D *light = cast_to<const SpotLight3D>(p_light);
+		l->range = light->get_param(SpotLight3D::PARAM_RANGE);
+		l->intensity = light->get_param(SpotLight3D::PARAM_ENERGY);
+		l->outer_cone_angle = Math::deg_to_rad(light->get_param(SpotLight3D::PARAM_SPOT_ANGLE));
+		// This equation is the inverse of the import equation (which has a desmos link).
+		float angle_ratio = 1 - (0.2 / (0.1 + light->get_param(SpotLight3D::PARAM_SPOT_ATTENUATION)));
+		angle_ratio = MAX(0, angle_ratio);
+		l->inner_cone_angle = l->outer_cone_angle * angle_ratio;
+	}
+	return l;
+}
+
+Light3D *GLTFLight::to_node() const {
+	if (light_type == "directional") {
+		DirectionalLight3D *light = memnew(DirectionalLight3D);
+		light->set_param(Light3D::PARAM_ENERGY, intensity);
+		light->set_color(color);
+		return light;
+	}
+	const float range = CLAMP(this->range, 0, 4096);
+	if (light_type == "point") {
+		OmniLight3D *light = memnew(OmniLight3D);
+		light->set_param(OmniLight3D::PARAM_ENERGY, intensity);
+		light->set_param(OmniLight3D::PARAM_RANGE, range);
+		light->set_color(color);
+		return light;
+	}
+	if (light_type == "spot") {
+		SpotLight3D *light = memnew(SpotLight3D);
+		light->set_param(SpotLight3D::PARAM_ENERGY, intensity);
+		light->set_param(SpotLight3D::PARAM_RANGE, range);
+		light->set_param(SpotLight3D::PARAM_SPOT_ANGLE, Math::rad_to_deg(outer_cone_angle));
+		light->set_color(color);
+		// Line of best fit derived from guessing, see https://www.desmos.com/calculator/biiflubp8b
+		// The points in desmos are not exact, except for (1, infinity).
+		float angle_ratio = inner_cone_angle / outer_cone_angle;
+		float angle_attenuation = 0.2 / (1 - angle_ratio) - 0.1;
+		light->set_param(SpotLight3D::PARAM_SPOT_ATTENUATION, angle_attenuation);
+		return light;
+	}
+	return memnew(Light3D);
+}
+
+Ref<GLTFLight> GLTFLight::from_dictionary(const Dictionary p_dictionary) {
+	ERR_FAIL_COND_V_MSG(!p_dictionary.has("type"), Ref<GLTFLight>(), "Failed to parse GLTF light, missing required field 'type'.");
+	Ref<GLTFLight> light;
+	light.instantiate();
+	const String &type = p_dictionary["type"];
+	light->light_type = type;
+
+	if (p_dictionary.has("color")) {
+		const Array &arr = p_dictionary["color"];
+		if (arr.size() == 3) {
+			light->color = Color(arr[0], arr[1], arr[2]).linear_to_srgb();
+		} else {
+			ERR_PRINT("Error parsing GLTF light: The color must have exactly 3 numbers.");
+		}
+	}
+	if (p_dictionary.has("intensity")) {
+		light->intensity = p_dictionary["intensity"];
+	}
+	if (p_dictionary.has("range")) {
+		light->range = p_dictionary["range"];
+	}
+	if (type == "spot") {
+		const Dictionary &spot = p_dictionary["spot"];
+		light->inner_cone_angle = spot["innerConeAngle"];
+		light->outer_cone_angle = spot["outerConeAngle"];
+		if (light->inner_cone_angle >= light->outer_cone_angle) {
+			ERR_PRINT("Error parsing GLTF light: The inner angle must be smaller than the outer angle.");
+		}
+	} else if (type != "point" && type != "directional") {
+		ERR_PRINT("Error parsing GLTF light: Light type '" + type + "' is unknown.");
+	}
+	return light;
+}
+
+Dictionary GLTFLight::to_dictionary() const {
+	Dictionary d;
+	Array color_array;
+	color_array.resize(3);
+	color_array[0] = color.r;
+	color_array[1] = color.g;
+	color_array[2] = color.b;
+	d["color"] = color_array;
+	d["type"] = light_type;
+	if (light_type == "spot") {
+		Dictionary spot_dict;
+		spot_dict["innerConeAngle"] = inner_cone_angle;
+		spot_dict["outerConeAngle"] = outer_cone_angle;
+		d["spot"] = spot_dict;
+	}
+	d["intensity"] = intensity;
+	d["range"] = range;
+	return d;
+}
diff --git a/modules/gltf/extensions/gltf_light.h b/modules/gltf/extensions/gltf_light.h
index f0765a1bbc..04980e144c 100644
--- a/modules/gltf/extensions/gltf_light.h
+++ b/modules/gltf/extensions/gltf_light.h
@@ -70,6 +70,12 @@ public:
 
 	float get_outer_cone_angle();
 	void set_outer_cone_angle(float p_outer_cone_angle);
+
+	static Ref<GLTFLight> from_node(const Light3D *p_light);
+	Light3D *to_node() const;
+
+	static Ref<GLTFLight> from_dictionary(const Dictionary p_dictionary);
+	Dictionary to_dictionary() const;
 };
 
 #endif // GLTF_LIGHT_H