From a887f48d1d74b6903045450e10e4735e234acbbe Mon Sep 17 00:00:00 2001 From: Aaron Franke Date: Sat, 10 Dec 2022 21:41:41 -0600 Subject: [PATCH] [3.x] Backport moving camera and light logic to GLTF subclasses --- modules/gltf/doc_classes/GLTFCamera.xml | 25 ++- modules/gltf/doc_classes/GLTFLight.xml | 15 ++ modules/gltf/extensions/gltf_light.cpp | 118 ++++++++++++++ modules/gltf/extensions/gltf_light.h | 10 ++ modules/gltf/gltf_document.cpp | 196 ++---------------------- modules/gltf/structures/gltf_camera.cpp | 84 ++++++++++ modules/gltf/structures/gltf_camera.h | 34 ++-- 7 files changed, 288 insertions(+), 194 deletions(-) diff --git a/modules/gltf/doc_classes/GLTFCamera.xml b/modules/gltf/doc_classes/GLTFCamera.xml index 3ddc337a078..4bb2df60419 100644 --- a/modules/gltf/doc_classes/GLTFCamera.xml +++ b/modules/gltf/doc_classes/GLTFCamera.xml @@ -1,22 +1,45 @@ + Represents a GLTF camera. + 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. + https://registry.khronos.org/glTF/specs/2.0/glTF-2.0.html#reference-camera + https://github.com/KhronosGroup/glTF-Tutorials/blob/master/gltfTutorial/gltfTutorial_015_SimpleCameras.md + + + + Serializes this GLTFCamera instance into a [Dictionary]. + + + + + + Converts this GLTFCamera instance into a Godot [Camera] node. + + - + + 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. + 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. + + + 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. + 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. + 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. diff --git a/modules/gltf/doc_classes/GLTFLight.xml b/modules/gltf/doc_classes/GLTFLight.xml index 9abfc4fdbc0..0a9f5d57756 100644 --- a/modules/gltf/doc_classes/GLTFLight.xml +++ b/modules/gltf/doc_classes/GLTFLight.xml @@ -1,13 +1,28 @@ + Represents a GLTF light. + 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. + https://github.com/KhronosGroup/glTF/blob/main/extensions/2.0/Khronos/KHR_lights_punctual + + + + Serializes this GLTFLight instance into a [Dictionary]. + + + + + + Converts this GLTFLight instance into a Godot [Light] node. + + diff --git a/modules/gltf/extensions/gltf_light.cpp b/modules/gltf/extensions/gltf_light.cpp index 05f0c7cc9bf..2b5709379cf 100644 --- a/modules/gltf/extensions/gltf_light.cpp +++ b/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::from_node(const Light *p_light) { + Ref 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(p_light)) { + l->type = "directional"; + const DirectionalLight *light = cast_to(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(p_light)) { + l->type = "point"; + const OmniLight *light = cast_to(p_light); + l->range = light->get_param(OmniLight::PARAM_RANGE); + l->intensity = light->get_param(OmniLight::PARAM_ENERGY); + } else if (cast_to(p_light)) { + l->type = "spot"; + const SpotLight *light = cast_to(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::from_dictionary(const Dictionary p_dictionary) { + ERR_FAIL_COND_V_MSG(!p_dictionary.has("type"), Ref(), "Failed to parse GLTF light, missing required field 'type'."); + Ref 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; +} diff --git a/modules/gltf/extensions/gltf_light.h b/modules/gltf/extensions/gltf_light.h index e0cc89f1904..b3c9d5363c3 100644 --- a/modules/gltf/extensions/gltf_light.h +++ b/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 from_node(const Light *p_light); + Light *to_node() const; + + static Ref from_dictionary(const Dictionary p_dictionary); + Dictionary to_dictionary() const; }; #endif // GLTF_LIGHT_H diff --git a/modules/gltf/gltf_document.cpp b/modules/gltf/gltf_document.cpp index 3fc371d3272..4402fe99b0a 100644 --- a/modules/gltf/gltf_document.cpp +++ b/modules/gltf/gltf_document.cpp @@ -4636,27 +4636,8 @@ Error GLTFDocument::_serialize_lights(Ref p_state) { } Array lights; for (GLTFLightIndex i = 0; i < p_state->lights.size(); i++) { - Dictionary d; Ref 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 p_state) { Array cameras; cameras.resize(p_state->cameras.size()); for (GLTFCameraIndex i = 0; i < p_state->cameras.size(); i++) { - Dictionary d; - Ref 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 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 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; + Ref light = GLTFLight::from_dictionary(lights[light_i]); + if (light.is_null()) { + return Error::ERR_PARSE_ERROR; } - if (d.has("intensity")) { - light->intensity = d["intensity"]; - } - if (d.has("range")) { - light->range = d["range"]; - } - 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 p_state) { const Array cameras = p_state->json["cameras"]; for (GLTFCameraIndex i = 0; i < cameras.size(); i++) { - const Dictionary &d = cameras[i]; - - Ref 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 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 p_state, Node *p_scene_par print_verbose("glTF: Creating light for: " + gltf_node->get_name()); Ref 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 p_state, Node *p_scene_parent, const GLTFNodeIndex p_node_index) { @@ -5332,35 +5203,16 @@ Camera *GLTFDocument::_generate_camera(Ref 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 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 p_state, Camera *p_camera) { print_verbose("glTF: Converting camera: " + p_camera->get_name()); - Ref 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 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 p_state, Camera *p_ GLTFLightIndex GLTFDocument::_convert_light(Ref p_state, Light *p_light) { print_verbose("glTF: Converting light: " + p_light->get_name()); - Ref l; - l.instance(); - l->color = p_light->get_color(); - if (cast_to(p_light)) { - l->type = "directional"; - DirectionalLight *light = cast_to(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(p_light)) { - l->type = "point"; - OmniLight *light = cast_to(p_light); - l->range = light->get_param(OmniLight::PARAM_RANGE); - l->intensity = light->get_param(OmniLight::PARAM_ENERGY); - } else if (cast_to(p_light)) { - l->type = "spot"; - SpotLight *light = cast_to(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 l = GLTFLight::from_node(p_light); GLTFLightIndex light_index = p_state->lights.size(); p_state->lights.push_back(l); diff --git a/modules/gltf/structures/gltf_camera.cpp b/modules/gltf/structures/gltf_camera.cpp index 0efdfb06f9c..25b2f32acd5 100644 --- a/modules/gltf/structures/gltf_camera.cpp +++ b/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::from_node(const Camera *p_camera) { + Ref 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::from_dictionary(const Dictionary p_dictionary) { + ERR_FAIL_COND_V_MSG(!p_dictionary.has("type"), Ref(), "Failed to parse GLTF camera, missing required field 'type'."); + Ref 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; +} diff --git a/modules/gltf/structures/gltf_camera.h b/modules/gltf/structures/gltf_camera.h index f8da3c248de..a254a63367a 100644 --- a/modules/gltf/structures/gltf_camera.h +++ b/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 from_node(const Camera *p_camera); + Camera *to_node() const; + + static Ref from_dictionary(const Dictionary p_dictionary); + Dictionary to_dictionary() const; }; #endif // GLTF_CAMERA_H