Core/Misc: update g3dlite lib (#2904)

* Core/Misc: update g3dlite lib

* update

Co-authored-by: Francesco Borzì <borzifrancesco@gmail.com>

deps/g3dlite/source/UprightFrame.cpp

@@ -1,11 +1,7 @@
 /**
-  @file UprightFrame.cpp
-  Box class
+  \file UprightFrame.cpp
 
-  @maintainer Morgan McGuire, http://graphics.cs.williams.edu
-
-  @created 2007-05-02
-  @edited  2007-05-05
+  \maintainer Morgan McGuire, http://graphics.cs.williams.edu
 */
 
 #include "G3D/UprightFrame.h"
@@ -17,12 +13,38 @@ namespace G3D {
 UprightFrame::UprightFrame(const CoordinateFrame& cframe) {
     Vector3 look = cframe.lookVector();
 
-    yaw = G3D::pi() + atan2(look.x, look.z);
+    yaw = (float)(G3D::pi() + atan2(look.x, look.z));
     pitch = asin(look.y);
 
     translation = cframe.translation;
 }
 
+
+UprightFrame::UprightFrame(const Any& any) {
+    any.verifyName("UprightFrame");
+    any.verifyType(Any::TABLE);
+
+    translation = any["translation"];
+    pitch = any["pitch"];
+    yaw = any["yaw"];
+}
+
+
+Any UprightFrame::toAny() const {
+    Any any(Any::TABLE, "UprightFrame");
+
+    any["translation"] = translation;
+    any["pitch"] = pitch;
+    any["yaw"] = yaw;
+
+    return any;
+}
+
+
+UprightFrame& UprightFrame::operator=(const Any& any) {
+    *this = UprightFrame(any);
+    return *this;
+}
     
 CoordinateFrame UprightFrame::toCoordinateFrame() const {
     CoordinateFrame cframe;
@@ -59,15 +81,15 @@ void UprightFrame::unwrapYaw(UprightFrame* a, int N) {
             // to be interpolated the long way.
 
             // Find canonical [0, 2pi] versions of these numbers
-            float p = wrap(prev, twoPi());
-            float c = wrap(cur, twoPi());
+            float p = (float)wrap(prev, twoPi());
+            float c = (float)wrap(cur, twoPi());
             
             // Find the difference -pi < diff < pi between the current and previous values
             float diff = c - p;
             if (diff < -G3D::pi()) {
-                diff += twoPi();
+                diff += (float)twoPi();
             } else if (diff > G3D::pi()) {
-                diff -= twoPi();
+                diff -= (float)twoPi();
             } 
 
             // Offset the current from the previous by the difference
@@ -77,7 +99,6 @@ void UprightFrame::unwrapYaw(UprightFrame* a, int N) {
     }
 }
 
-
 void UprightFrame::serialize(class BinaryOutput& b) const {
     translation.serialize(b);
     b.writeFloat32(pitch);
@@ -91,9 +112,70 @@ void UprightFrame::deserialize(class BinaryInput& b) {
     yaw = b.readFloat32();
 }
 
+///////////////////////////////////////////////////////////////////////////////////////////
+
+UprightSpline::UprightSpline() : Spline<UprightFrame>() {
+}
+
+
+UprightSpline::UprightSpline(const Any& any) {
+    any.verifyName("UprightSpline");
+    any.verifyType(Any::TABLE);
+
+    extrapolationMode = any["extrapolationMode"];
+
+    const Any& controlsAny = any["control"];
+    controlsAny.verifyType(Any::ARRAY);
+
+    control.resize(controlsAny.length());
+    for (int controlIndex = 0; controlIndex < control.length(); ++controlIndex) {
+        control[controlIndex] = controlsAny[controlIndex];
+    }
+
+    const Any& timesAny = any["time"];
+    timesAny.verifyType(Any::ARRAY);
+
+    time.resize(timesAny.length());
+    for (int timeIndex = 0; timeIndex < time.length(); ++timeIndex) {
+        time[timeIndex] = timesAny[timeIndex];
+    }
+}
+
+
+Any UprightSpline::toAny(const std::string& myName) const {
+    Any any(Any::TABLE, myName);
+
+    any["extrapolationMode"] = extrapolationMode;
+
+    Any controlsAny(Any::ARRAY);
+    for (int controlIndex = 0; controlIndex < control.length(); ++controlIndex) {
+        controlsAny.append(control[controlIndex]);
+    }
+    any["control"] = controlsAny;
+
+    Any timesAny(Any::ARRAY);
+    for (int timeIndex = 0; timeIndex < time.length(); ++timeIndex) {
+        timesAny.append(Any(time[timeIndex]));
+    }
+    any["time"] = timesAny;
+
+    return any;
+}
+
+
+Any UprightSpline::toAny() const {
+    return toAny("UprightSpline");
+}
+
+
+UprightSpline& UprightSpline::operator=(const Any& any) {
+    *this = UprightSpline(any);
+    return *this;
+}
+
 
 void UprightSpline::serialize(class BinaryOutput& b) const {
-    b.writeBool8(cyclic);
+    b.writeInt32(extrapolationMode);
 
     b.writeInt32(control.size());
     for (int i = 0; i < control.size(); ++i) {
@@ -107,7 +189,7 @@ void UprightSpline::serialize(class BinaryOutput& b) const {
 
 
 void UprightSpline::deserialize(class BinaryInput& b) {
-    cyclic = b.readBool8();
+    extrapolationMode = SplineExtrapolationMode(b.readInt32());
 
     control.resize(b.readInt32());
     for (int i = 0; i < control.size(); ++i) {
@@ -124,7 +206,7 @@ void UprightSpline::deserialize(class BinaryInput& b) {
         // Import legacy path
         time.resize(control.size());
         for (int i = 0; i < time.size(); ++i) {
-            time[i] = i;
+            time[i] = (float)i;
         }
     }
 }