Merge pull request #69929 from aaronfranke/3.x-gltf-subclasses

[3.x] Backport moving camera and light logic to GLTF subclasses, fix ortho cameras

modules/gltf/doc_classes/GLTFCamera.xml

@@ -1,22 +1,45 @@
 <?xml version="1.0" encoding="UTF-8" ?>
 <class name="GLTFCamera" inherits="Resource" version="3.6" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="../../../doc/class.xsd">
 	<brief_description>
+		Represents a GLTF camera.
 	</brief_description>
 	<description>
+		Represents a camera as defined by the base GLTF spec.
 		[b]Note:[/b] This class is only compiled in editor builds. Run-time glTF loading and saving is [i]not[/i] available in exported projects. References to [GLTFCamera] within a script will cause an error in an exported project.
 	</description>
 	<tutorials>
+		<link title="GLTF camera detailed specification">https://registry.khronos.org/glTF/specs/2.0/glTF-2.0.html#reference-camera</link>
+		<link title="GLTF camera spec and example file">https://github.com/KhronosGroup/glTF-Tutorials/blob/master/gltfTutorial/gltfTutorial_015_SimpleCameras.md</link>
 	</tutorials>
 	<methods>
+		<method name="to_dictionary" qualifiers="const">
+			<return type="Dictionary" />
+			<description>
+				Serializes this GLTFCamera instance into a [Dictionary].
+			</description>
+		</method>
+		<method name="to_node" qualifiers="const">
+			<return type="Camera" />
+			<description>
+				Converts this GLTFCamera instance into a Godot [Camera] node.
+			</description>
+		</method>
 	</methods>
 	<members>
-		<member name="fov_size" type="float" setter="set_fov_size" getter="get_fov_size" default="75.0">
+		<member name="fov_size" type="float" setter="set_fov_size" getter="get_fov_size" default="1.309">
+			The FOV of the camera. This class and GLTF define the camera FOV in radians, while Godot uses degrees. This maps to GLTF's [code]yfov[/code] property. This value is only used for perspective cameras, when [member perspective] is true.
 		</member>
 		<member name="perspective" type="bool" setter="set_perspective" getter="get_perspective" default="true">
+			Whether or not the camera is in perspective mode. If false, the camera is in orthographic/orthogonal mode. This maps to GLTF's camera [code]type[/code] property. See [member Camera.projection] and the GLTF spec for more information.
+		</member>
+		<member name="size_mag" type="float" setter="set_size_mag" getter="get_size_mag" default="0.5">
+			The size of the camera. This class and GLTF define the camera size magnitude as a radius in meters, while Godot defines it as a diameter in meters. This maps to GLTF's [code]ymag[/code] property. This value is only used for orthographic/orthogonal cameras, when [member perspective] is false.
 		</member>
 		<member name="zfar" type="float" setter="set_zfar" getter="get_zfar" default="4000.0">
+			The distance to the far culling boundary for this camera relative to its local Z axis, in meters. This maps to GLTF's [code]zfar[/code] property.
 		</member>
 		<member name="znear" type="float" setter="set_znear" getter="get_znear" default="0.05">
+			The distance to the near culling boundary for this camera relative to its local Z axis, in meters. This maps to GLTF's [code]znear[/code] property.
 		</member>
 	</members>
 	<constants>

modules/gltf/doc_classes/GLTFLight.xml

@@ -1,13 +1,28 @@
 <?xml version="1.0" encoding="UTF-8" ?>
 <class name="GLTFLight" inherits="Resource" version="3.6" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="../../../doc/class.xsd">
 	<brief_description>
+		Represents a GLTF light.
 	</brief_description>
 	<description>
+		Represents a light as defined by the [code]KHR_lights_punctual[/code] GLTF extension.
 		[b]Note:[/b] This class is only compiled in editor builds. Run-time glTF loading and saving is [i]not[/i] available in exported projects. References to [GLTFLight] within a script will cause an error in an exported project.
 	</description>
 	<tutorials>
+		<link title="KHR_lights_punctual GLTF extension spec">https://github.com/KhronosGroup/glTF/blob/main/extensions/2.0/Khronos/KHR_lights_punctual</link>
 	</tutorials>
 	<methods>
+		<method name="to_dictionary" qualifiers="const">
+			<return type="Dictionary" />
+			<description>
+				Serializes this GLTFLight instance into a [Dictionary].
+			</description>
+		</method>
+		<method name="to_node" qualifiers="const">
+			<return type="Light" />
+			<description>
+				Converts this GLTFLight instance into a Godot [Light] node.
+			</description>
+		</method>
 	</methods>
 	<members>
 		<member name="color" type="Color" setter="set_color" getter="get_color" default="Color( 1, 1, 1, 1 )">

modules/gltf/extensions/gltf_light.cpp

@@ -30,7 +30,12 @@
 
 #include "gltf_light.h"
 
+#include "scene/3d/light.h"
+
 void GLTFLight::_bind_methods() {
+	ClassDB::bind_method(D_METHOD("to_node"), &GLTFLight::to_node);
+	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 +104,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 Light *p_light) {
+	Ref<GLTFLight> l;
+	l.instance();
+	ERR_FAIL_COND_V_MSG(!p_light, l, "Tried to create a GLTFLight from a Light node, but the given node was null.");
+	l->color = p_light->get_color();
+	if (cast_to<const DirectionalLight>(p_light)) {
+		l->type = "directional";
+		const DirectionalLight *light = cast_to<const DirectionalLight>(p_light);
+		l->intensity = light->get_param(DirectionalLight::PARAM_ENERGY);
+		l->range = FLT_MAX; // Range for directional lights is infinite in Godot.
+	} else if (cast_to<const OmniLight>(p_light)) {
+		l->type = "point";
+		const OmniLight *light = cast_to<const OmniLight>(p_light);
+		l->range = light->get_param(OmniLight::PARAM_RANGE);
+		l->intensity = light->get_param(OmniLight::PARAM_ENERGY);
+	} else if (cast_to<const SpotLight>(p_light)) {
+		l->type = "spot";
+		const SpotLight *light = cast_to<const SpotLight>(p_light);
+		l->range = light->get_param(SpotLight::PARAM_RANGE);
+		l->intensity = light->get_param(SpotLight::PARAM_ENERGY);
+		l->outer_cone_angle = Math::deg2rad(light->get_param(SpotLight::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(SpotLight::PARAM_SPOT_ATTENUATION)));
+		angle_ratio = MAX(0, angle_ratio);
+		l->inner_cone_angle = l->outer_cone_angle * angle_ratio;
+	}
+	return l;
+}
+
+Light *GLTFLight::to_node() const {
+	if (type == "directional") {
+		DirectionalLight *light = memnew(DirectionalLight);
+		light->set_param(Light::PARAM_ENERGY, intensity);
+		light->set_color(color);
+		return light;
+	}
+	if (type == "point") {
+		OmniLight *light = memnew(OmniLight);
+		light->set_param(OmniLight::PARAM_ENERGY, intensity);
+		light->set_param(OmniLight::PARAM_RANGE, CLAMP(range, 0, 4096));
+		light->set_color(color);
+		return light;
+	}
+	if (type == "spot") {
+		SpotLight *light = memnew(SpotLight);
+		light->set_param(SpotLight::PARAM_ENERGY, intensity);
+		light->set_param(SpotLight::PARAM_RANGE, CLAMP(range, 0, 4096));
+		light->set_param(SpotLight::PARAM_SPOT_ANGLE, Math::rad2deg(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(SpotLight::PARAM_SPOT_ATTENUATION, angle_attenuation);
+		return light;
+	}
+	return memnew(Light);
+}
+
+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.instance();
+	const String &type = p_dictionary["type"];
+	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]).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"] = type;
+	if (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;
+}

modules/gltf/extensions/gltf_light.h

@@ -34,6 +34,10 @@
 #include "../gltf_defines.h"
 #include "core/resource.h"
 
+class Light;
+
+// https://github.com/KhronosGroup/glTF/blob/main/extensions/2.0/Khronos/KHR_lights_punctual
+
 class GLTFLight : public Resource {
 	GDCLASS(GLTFLight, Resource)
 	friend class GLTFDocument;
@@ -67,6 +71,12 @@ public:
 
 	float get_outer_cone_angle();
 	void set_outer_cone_angle(float p_outer_cone_angle);
+
+	static Ref<GLTFLight> from_node(const Light *p_light);
+	Light *to_node() const;
+
+	static Ref<GLTFLight> from_dictionary(const Dictionary p_dictionary);
+	Dictionary to_dictionary() const;
 };
 
 #endif // GLTF_LIGHT_H

modules/gltf/gltf_document.cpp

@@ -4636,27 +4636,8 @@ Error GLTFDocument::_serialize_lights(Ref<GLTFState> p_state) {
 	}
 	Array lights;
 	for (GLTFLightIndex i = 0; i < p_state->lights.size(); i++) {
-		Dictionary d;
 		Ref<GLTFLight> light = p_state->lights[i];
-		Array color;
-		color.resize(3);
-		color[0] = light->color.r;
-		color[1] = light->color.g;
-		color[2] = light->color.b;
-		d["color"] = color;
-		d["type"] = light->type;
-		if (light->type == "spot") {
-			Dictionary s;
-			float inner_cone_angle = light->inner_cone_angle;
-			s["innerConeAngle"] = inner_cone_angle;
-			float outer_cone_angle = light->outer_cone_angle;
-			s["outerConeAngle"] = outer_cone_angle;
-			d["spot"] = s;
-		}
-		float intensity = light->intensity;
-		d["intensity"] = intensity;
-		float range = light->range;
-		d["range"] = range;
+		Dictionary d = light->to_dictionary();
 		lights.push_back(d);
 	}
 
@@ -4679,27 +4660,8 @@ Error GLTFDocument::_serialize_cameras(Ref<GLTFState> p_state) {
 	Array cameras;
 	cameras.resize(p_state->cameras.size());
 	for (GLTFCameraIndex i = 0; i < p_state->cameras.size(); i++) {
-		Dictionary d;
-
 		Ref<GLTFCamera> camera = p_state->cameras[i];
-
-		if (camera->get_perspective() == false) {
-			Dictionary og;
-			og["ymag"] = Math::deg2rad(camera->get_fov_size());
-			og["xmag"] = Math::deg2rad(camera->get_fov_size());
-			og["zfar"] = camera->get_zfar();
-			og["znear"] = camera->get_znear();
-			d["orthographic"] = og;
-			d["type"] = "orthographic";
-		} else if (camera->get_perspective()) {
-			Dictionary ppt;
-			// GLTF spec is in radians, Godot's camera is in degrees.
-			ppt["yfov"] = Math::deg2rad(camera->get_fov_size());
-			ppt["zfar"] = camera->get_zfar();
-			ppt["znear"] = camera->get_znear();
-			d["perspective"] = ppt;
-			d["type"] = "perspective";
-		}
+		Dictionary d = camera->to_dictionary();
 		cameras[i] = d;
 	}
 
@@ -4730,35 +4692,10 @@ Error GLTFDocument::_parse_lights(Ref<GLTFState> p_state) {
 	const Array &lights = lights_punctual["lights"];
 
 	for (GLTFLightIndex light_i = 0; light_i < lights.size(); light_i++) {
-		const Dictionary &d = lights[light_i];
-
-		Ref<GLTFLight> light;
-		light.instance();
-		ERR_FAIL_COND_V(!d.has("type"), ERR_PARSE_ERROR);
-		const String &type = d["type"];
-		light->type = type;
-
-		if (d.has("color")) {
-			const Array &arr = d["color"];
-			ERR_FAIL_COND_V(arr.size() != 3, ERR_PARSE_ERROR);
-			const Color c = Color(arr[0], arr[1], arr[2]).to_srgb();
-			light->color = c;
-		}
-		if (d.has("intensity")) {
-			light->intensity = d["intensity"];
-		}
-		if (d.has("range")) {
-			light->range = d["range"];
+		Ref<GLTFLight> light = GLTFLight::from_dictionary(lights[light_i]);
+		if (light.is_null()) {
+			return Error::ERR_PARSE_ERROR;
 		}
-		if (type == "spot") {
-			const Dictionary &spot = d["spot"];
-			light->inner_cone_angle = spot["innerConeAngle"];
-			light->outer_cone_angle = spot["outerConeAngle"];
-			ERR_CONTINUE_MSG(light->inner_cone_angle >= light->outer_cone_angle, "The inner angle must be smaller than the outer angle.");
-		} else if (type != "point" && type != "directional") {
-			ERR_CONTINUE_MSG(true, "Light type is unknown.");
-		}
-
 		p_state->lights.push_back(light);
 	}
 
@@ -4775,38 +4712,10 @@ Error GLTFDocument::_parse_cameras(Ref<GLTFState> p_state) {
 	const Array cameras = p_state->json["cameras"];
 
 	for (GLTFCameraIndex i = 0; i < cameras.size(); i++) {
-		const Dictionary &d = cameras[i];
-
-		Ref<GLTFCamera> camera;
-		camera.instance();
-		ERR_FAIL_COND_V(!d.has("type"), ERR_PARSE_ERROR);
-		const String &type = d["type"];
-		if (type == "orthographic") {
-			camera->set_perspective(false);
-			if (d.has("orthographic")) {
-				const Dictionary &og = d["orthographic"];
-				// GLTF spec is in radians, Godot's camera is in degrees.
-				camera->set_fov_size(Math::rad2deg(real_t(og["ymag"])));
-				camera->set_zfar(og["zfar"]);
-				camera->set_znear(og["znear"]);
-			} else {
-				camera->set_fov_size(10);
-			}
-		} else if (type == "perspective") {
-			camera->set_perspective(true);
-			if (d.has("perspective")) {
-				const Dictionary &ppt = d["perspective"];
-				// GLTF spec is in radians, Godot's camera is in degrees.
-				camera->set_fov_size(Math::rad2deg(real_t(ppt["yfov"])));
-				camera->set_zfar(ppt["zfar"]);
-				camera->set_znear(ppt["znear"]);
-			} else {
-				camera->set_fov_size(10);
-			}
-		} else {
-			ERR_FAIL_V_MSG(ERR_PARSE_ERROR, "Camera should be in 'orthographic' or 'perspective'");
+		Ref<GLTFCamera> camera = GLTFCamera::from_dictionary(cameras[i]);
+		if (camera.is_null()) {
+			return Error::ERR_PARSE_ERROR;
 		}
-
 		p_state->cameras.push_back(camera);
 	}
 
@@ -5286,45 +5195,7 @@ Spatial *GLTFDocument::_generate_light(Ref<GLTFState> p_state, Node *p_scene_par
 	print_verbose("glTF: Creating light for: " + gltf_node->get_name());
 
 	Ref<GLTFLight> l = p_state->lights[gltf_node->light];
-
-	float intensity = l->intensity;
-	if (intensity > 10) {
-		// GLTF spec has the default around 1, but Blender defaults lights to 100.
-		// The only sane way to handle this is to check where it came from and
-		// handle it accordingly. If it's over 10, it probably came from Blender.
-		intensity /= 100;
-	}
-
-	if (l->type == "directional") {
-		DirectionalLight *light = memnew(DirectionalLight);
-		light->set_param(Light::PARAM_ENERGY, intensity);
-		light->set_color(l->color);
-		return light;
-	}
-
-	const float range = CLAMP(l->range, 0, 4096);
-	if (l->type == "point") {
-		OmniLight *light = memnew(OmniLight);
-		light->set_param(OmniLight::PARAM_ENERGY, intensity);
-		light->set_param(OmniLight::PARAM_RANGE, range);
-		light->set_color(l->color);
-		return light;
-	}
-	if (l->type == "spot") {
-		SpotLight *light = memnew(SpotLight);
-		light->set_param(SpotLight::PARAM_ENERGY, intensity);
-		light->set_param(SpotLight::PARAM_RANGE, range);
-		light->set_param(SpotLight::PARAM_SPOT_ANGLE, Math::rad2deg(l->outer_cone_angle));
-		light->set_color(l->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 = l->inner_cone_angle / l->outer_cone_angle;
-		float angle_attenuation = 0.2 / (1 - angle_ratio) - 0.1;
-		light->set_param(SpotLight::PARAM_SPOT_ATTENUATION, angle_attenuation);
-		return light;
-	}
-	return memnew(Spatial);
+	return l->to_node();
 }
 
 Camera *GLTFDocument::_generate_camera(Ref<GLTFState> p_state, Node *p_scene_parent, const GLTFNodeIndex p_node_index) {
@@ -5332,35 +5203,16 @@ Camera *GLTFDocument::_generate_camera(Ref<GLTFState> p_state, Node *p_scene_par
 
 	ERR_FAIL_INDEX_V(gltf_node->camera, p_state->cameras.size(), nullptr);
 
-	Camera *camera = memnew(Camera);
 	print_verbose("glTF: Creating camera for: " + gltf_node->get_name());
 
 	Ref<GLTFCamera> c = p_state->cameras[gltf_node->camera];
-	if (c->get_perspective()) {
-		camera->set_perspective(c->get_fov_size(), c->get_znear(), c->get_zfar());
-	} else {
-		camera->set_orthogonal(c->get_fov_size(), c->get_znear(), c->get_zfar());
-	}
-
-	return camera;
+	return c->to_node();
 }
 
 GLTFCameraIndex GLTFDocument::_convert_camera(Ref<GLTFState> p_state, Camera *p_camera) {
 	print_verbose("glTF: Converting camera: " + p_camera->get_name());
 
-	Ref<GLTFCamera> c;
-	c.instance();
-
-	if (p_camera->get_projection() == Camera::Projection::PROJECTION_PERSPECTIVE) {
-		c->set_perspective(true);
-		c->set_fov_size(p_camera->get_fov());
-		c->set_zfar(p_camera->get_zfar());
-		c->set_znear(p_camera->get_znear());
-	} else {
-		c->set_fov_size(p_camera->get_fov());
-		c->set_zfar(p_camera->get_zfar());
-		c->set_znear(p_camera->get_znear());
-	}
+	Ref<GLTFCamera> c = GLTFCamera::from_node(p_camera);
 	GLTFCameraIndex camera_index = p_state->cameras.size();
 	p_state->cameras.push_back(c);
 	return camera_index;
@@ -5369,31 +5221,7 @@ GLTFCameraIndex GLTFDocument::_convert_camera(Ref<GLTFState> p_state, Camera *p_
 GLTFLightIndex GLTFDocument::_convert_light(Ref<GLTFState> p_state, Light *p_light) {
 	print_verbose("glTF: Converting light: " + p_light->get_name());
 
-	Ref<GLTFLight> l;
-	l.instance();
-	l->color = p_light->get_color();
-	if (cast_to<DirectionalLight>(p_light)) {
-		l->type = "directional";
-		DirectionalLight *light = cast_to<DirectionalLight>(p_light);
-		l->intensity = light->get_param(DirectionalLight::PARAM_ENERGY);
-		l->range = FLT_MAX; // Range for directional lights is infinite in Godot.
-	} else if (cast_to<OmniLight>(p_light)) {
-		l->type = "point";
-		OmniLight *light = cast_to<OmniLight>(p_light);
-		l->range = light->get_param(OmniLight::PARAM_RANGE);
-		l->intensity = light->get_param(OmniLight::PARAM_ENERGY);
-	} else if (cast_to<SpotLight>(p_light)) {
-		l->type = "spot";
-		SpotLight *light = cast_to<SpotLight>(p_light);
-		l->range = light->get_param(SpotLight::PARAM_RANGE);
-		l->intensity = light->get_param(SpotLight::PARAM_ENERGY);
-		l->outer_cone_angle = Math::deg2rad(light->get_param(SpotLight::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(SpotLight::PARAM_SPOT_ATTENUATION)));
-		angle_ratio = MAX(0, angle_ratio);
-		l->inner_cone_angle = l->outer_cone_angle * angle_ratio;
-	}
+	Ref<GLTFLight> l = GLTFLight::from_node(p_light);
 
 	GLTFLightIndex light_index = p_state->lights.size();
 	p_state->lights.push_back(l);

modules/gltf/structures/gltf_camera.cpp

@@ -30,11 +30,18 @@
 
 #include "gltf_camera.h"
 
+#include "scene/3d/camera.h"
+
 void GLTFCamera::_bind_methods() {
+	ClassDB::bind_method(D_METHOD("to_node"), &GLTFCamera::to_node);
+	ClassDB::bind_method(D_METHOD("to_dictionary"), &GLTFCamera::to_dictionary);
+
 	ClassDB::bind_method(D_METHOD("get_perspective"), &GLTFCamera::get_perspective);
 	ClassDB::bind_method(D_METHOD("set_perspective", "perspective"), &GLTFCamera::set_perspective);
 	ClassDB::bind_method(D_METHOD("get_fov_size"), &GLTFCamera::get_fov_size);
 	ClassDB::bind_method(D_METHOD("set_fov_size", "fov_size"), &GLTFCamera::set_fov_size);
+	ClassDB::bind_method(D_METHOD("get_size_mag"), &GLTFCamera::get_size_mag);
+	ClassDB::bind_method(D_METHOD("set_size_mag", "size_mag"), &GLTFCamera::set_size_mag);
 	ClassDB::bind_method(D_METHOD("get_zfar"), &GLTFCamera::get_zfar);
 	ClassDB::bind_method(D_METHOD("set_zfar", "zfar"), &GLTFCamera::set_zfar);
 	ClassDB::bind_method(D_METHOD("get_znear"), &GLTFCamera::get_znear);
@@ -42,6 +49,83 @@ void GLTFCamera::_bind_methods() {
 
 	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "perspective"), "set_perspective", "get_perspective"); // bool
 	ADD_PROPERTY(PropertyInfo(Variant::REAL, "fov_size"), "set_fov_size", "get_fov_size"); // float
+	ADD_PROPERTY(PropertyInfo(Variant::REAL, "size_mag"), "set_size_mag", "get_size_mag"); // float
 	ADD_PROPERTY(PropertyInfo(Variant::REAL, "zfar"), "set_zfar", "get_zfar"); // float
 	ADD_PROPERTY(PropertyInfo(Variant::REAL, "znear"), "set_znear", "get_znear"); // float
 }
+
+Ref<GLTFCamera> GLTFCamera::from_node(const Camera *p_camera) {
+	Ref<GLTFCamera> c;
+	c.instance();
+	ERR_FAIL_COND_V_MSG(!p_camera, c, "Tried to create a GLTFCamera from a Camera node, but the given node was null.");
+	c->set_perspective(p_camera->get_projection() == Camera::Projection::PROJECTION_PERSPECTIVE);
+	// GLTF spec (yfov) is in radians, Godot's camera (fov) is in degrees.
+	c->set_fov_size(Math::deg2rad(p_camera->get_fov()));
+	// GLTF spec (xmag and ymag) is a radius in meters, Godot's camera (size) is a diameter in meters.
+	c->set_size_mag(p_camera->get_size() * 0.5f);
+	c->set_zfar(p_camera->get_zfar());
+	c->set_znear(p_camera->get_znear());
+	return c;
+}
+
+Camera *GLTFCamera::to_node() const {
+	Camera *camera = memnew(Camera);
+	camera->set_projection(perspective ? Camera::PROJECTION_PERSPECTIVE : Camera::PROJECTION_ORTHOGONAL);
+	// GLTF spec (yfov) is in radians, Godot's camera (fov) is in degrees.
+	camera->set_fov(Math::rad2deg(fov));
+	// GLTF spec (xmag and ymag) is a radius in meters, Godot's camera (size) is a diameter in meters.
+	camera->set_size(size_mag * 2.0f);
+	camera->set_znear(znear);
+	camera->set_zfar(zfar);
+	return camera;
+}
+
+Ref<GLTFCamera> GLTFCamera::from_dictionary(const Dictionary p_dictionary) {
+	ERR_FAIL_COND_V_MSG(!p_dictionary.has("type"), Ref<GLTFCamera>(), "Failed to parse GLTF camera, missing required field 'type'.");
+	Ref<GLTFCamera> camera;
+	camera.instance();
+	const String &type = p_dictionary["type"];
+	if (type == "perspective") {
+		camera->set_perspective(true);
+		if (p_dictionary.has("perspective")) {
+			const Dictionary &persp = p_dictionary["perspective"];
+			camera->set_fov_size(persp["yfov"]);
+			if (persp.has("zfar")) {
+				camera->set_zfar(persp["zfar"]);
+			}
+			camera->set_znear(persp["znear"]);
+		}
+	} else if (type == "orthographic") {
+		camera->set_perspective(false);
+		if (p_dictionary.has("orthographic")) {
+			const Dictionary &ortho = p_dictionary["orthographic"];
+			camera->set_size_mag(ortho["ymag"]);
+			camera->set_zfar(ortho["zfar"]);
+			camera->set_znear(ortho["znear"]);
+		}
+	} else {
+		ERR_PRINT("Error parsing GLTF camera: Camera type '" + type + "' is unknown, should be perspective or orthographic.");
+	}
+	return camera;
+}
+
+Dictionary GLTFCamera::to_dictionary() const {
+	Dictionary d;
+	if (perspective) {
+		Dictionary persp;
+		persp["yfov"] = fov;
+		persp["zfar"] = zfar;
+		persp["znear"] = znear;
+		d["perspective"] = persp;
+		d["type"] = "perspective";
+	} else {
+		Dictionary ortho;
+		ortho["ymag"] = size_mag;
+		ortho["xmag"] = size_mag;
+		ortho["zfar"] = zfar;
+		ortho["znear"] = znear;
+		d["orthographic"] = ortho;
+		d["type"] = "orthographic";
+	}
+	return d;
+}

modules/gltf/structures/gltf_camera.h

@@ -33,14 +33,22 @@
 
 #include "core/resource.h"
 
+class Camera;
+
+// Reference and test file:
+// https://github.com/KhronosGroup/glTF-Tutorials/blob/master/gltfTutorial/gltfTutorial_015_SimpleCameras.md
+
 class GLTFCamera : public Resource {
 	GDCLASS(GLTFCamera, Resource);
 
 private:
+	// GLTF has no default camera values, they should always be specified in
+	// the GLTF file. Here we default to Godot's default camera settings.
 	bool perspective = true;
-	float fov_size = 75.0;
-	float zfar = 4000.0;
-	float znear = 0.05;
+	real_t fov = Math::deg2rad(75.0);
+	real_t size_mag = 0.5;
+	real_t zfar = 4000.0;
+	real_t znear = 0.05;
 
 protected:
 	static void _bind_methods();
@@ -48,12 +56,20 @@ protected:
 public:
 	bool get_perspective() const { return perspective; }
 	void set_perspective(bool p_val) { perspective = p_val; }
-	float get_fov_size() const { return fov_size; }
-	void set_fov_size(float p_val) { fov_size = p_val; }
-	float get_zfar() const { return zfar; }
-	void set_zfar(float p_val) { zfar = p_val; }
-	float get_znear() const { return znear; }
-	void set_znear(float p_val) { znear = p_val; }
+	real_t get_fov_size() const { return fov; }
+	void set_fov_size(real_t p_val) { fov = p_val; }
+	real_t get_size_mag() const { return size_mag; }
+	void set_size_mag(real_t p_val) { size_mag = p_val; }
+	real_t get_zfar() const { return zfar; }
+	void set_zfar(real_t p_val) { zfar = p_val; }
+	real_t get_znear() const { return znear; }
+	void set_znear(real_t p_val) { znear = p_val; }
+
+	static Ref<GLTFCamera> from_node(const Camera *p_camera);
+	Camera *to_node() const;
+
+	static Ref<GLTFCamera> from_dictionary(const Dictionary p_dictionary);
+	Dictionary to_dictionary() const;
 };
 
 #endif // GLTF_CAMERA_H