Update to 1.9.7 beta (#147)

* Rebuild mac libraries

* Updated more libraries

* Update web libraries

Author: Jhonnyg

defold-rive/include/rive/advance_flags.hpp

@@ -0,0 +1,26 @@
+#ifndef _RIVE_ADVANCE_FLAGS_HPP_
+#define _RIVE_ADVANCE_FLAGS_HPP_
+
+#include "rive/enum_bitset.hpp"
+
+namespace rive
+{
+enum class AdvanceFlags : unsigned short
+{
+    None = 0,
+
+    /// Whether NestedArtboards should advance
+    AdvanceNested = 1 << 0,
+
+    /// Whether the Component should animate when advancing
+    Animate = 1 << 1,
+
+    /// Whether this Component is on the root artboard
+    IsRoot = 1 << 2,
+
+    /// Whether we are advancing to a new frame
+    NewFrame = 1 << 3,
+};
+RIVE_MAKE_ENUM_BITSET(AdvanceFlags)
+} // namespace rive
+#endif

defold-rive/include/rive/advancing_component.hpp

@@ -0,0 +1,20 @@
+#ifndef _RIVE_ADVANCING_COMPONENT_HPP_
+#define _RIVE_ADVANCING_COMPONENT_HPP_
+
+#include "rive/advance_flags.hpp"
+
+namespace rive
+{
+class Component;
+class AdvancingComponent
+{
+public:
+    virtual bool advanceComponent(
+        float elapsedSeconds,
+        AdvanceFlags flags = AdvanceFlags::Animate |
+                             AdvanceFlags::NewFrame) = 0;
+    static AdvancingComponent* from(Component* component);
+};
+} // namespace rive
+
+#endif

defold-rive/include/rive/animation/arithmetic_operation.hpp

@@ -10,6 +10,17 @@ enum class ArithmeticOperation : int
     multiply = 2,
     divide = 3,
     modulo = 4,
+    squareRoot = 5,
+    power = 6,
+    exp = 7,
+    log = 8,
+    cosine = 9,
+    sine = 10,
+    tangent = 11,
+    acosine = 12,
+    asine = 13,
+    atangent = 14,
+    atangent2 = 15,
 };
 } // namespace rive
 

defold-rive/include/rive/animation/blend_animation_direct.hpp

@@ -4,11 +4,12 @@
 #include <stdio.h>
 namespace rive
 {
-
+class BindableProperty;
 enum class DirectBlendSource : unsigned int
 {
     inputId = 0,
     mixValue = 1,
+    dataBindId = 2,
 };
 
 class BlendAnimationDirect : public BlendAnimationDirectBase
@@ -17,7 +18,16 @@ class BlendAnimationDirect : public BlendAnimationDirectBase
     StatusCode onAddedDirty(CoreContext* context) override;
     StatusCode onAddedClean(CoreContext* context) override;
     StatusCode import(ImportStack& importStack) override;
+    void bindableProperty(BindableProperty* value)
+    {
+        m_bindableProperty = value;
+    };
+    BindableProperty* bindableProperty() const { return m_bindableProperty; };
+
+private:
+    BindableProperty* m_bindableProperty;
 };
+
 } // namespace rive
 
 #endif

defold-rive/include/rive/animation/blend_state_1d.hpp

@@ -7,10 +7,6 @@ namespace rive
 class BlendState1D : public BlendState1DBase
 {
 public:
-    bool hasValidInputId() const { return inputId() != Core::emptyId; }
-
-    StatusCode import(ImportStack& importStack) override;
-
     std::unique_ptr<StateInstance> makeInstance(
         ArtboardInstance*) const override;
 };

defold-rive/include/rive/animation/blend_state_1d_input.hpp

@@ -0,0 +1,16 @@
+#ifndef _RIVE_BLEND_STATE1_DINPUT_HPP_
+#define _RIVE_BLEND_STATE1_DINPUT_HPP_
+#include "rive/generated/animation/blend_state_1d_input_base.hpp"
+#include <stdio.h>
+namespace rive
+{
+class BlendState1DInput : public BlendState1DInputBase
+{
+public:
+    bool hasValidInputId() const { return inputId() != Core::emptyId; }
+
+    StatusCode import(ImportStack& importStack) override;
+};
+} // namespace rive
+
+#endif

defold-rive/include/rive/animation/blend_state_1d_viewmodel.hpp

@@ -0,0 +1,20 @@
+#ifndef _RIVE_BLEND_STATE1_DVIEW_MODEL_HPP_
+#define _RIVE_BLEND_STATE1_DVIEW_MODEL_HPP_
+#include "rive/generated/animation/blend_state_1d_viewmodel_base.hpp"
+#include "rive/data_bind/bindable_property.hpp"
+#include <stdio.h>
+namespace rive
+{
+class BlendState1DViewModel : public BlendState1DViewModelBase
+{
+public:
+    StatusCode import(ImportStack& importStack) override;
+
+    BindableProperty* bindableProperty() const { return m_bindableProperty; };
+
+protected:
+    BindableProperty* m_bindableProperty;
+};
+} // namespace rive
+
+#endif

defold-rive/include/rive/animation/cubic_interpolator.hpp

@@ -9,6 +9,7 @@ class CubicInterpolator : public CubicInterpolatorBase
 {
 public:
     StatusCode onAddedDirty(CoreContext* context) override;
+    void initialize() override;
 
 protected:
     CubicInterpolatorSolver m_solver;

defold-rive/include/rive/animation/data_converter_range_mapper_flags.hpp

@@ -0,0 +1,27 @@
+#ifndef _RIVE_DATA_CONVERTER_RANGE_MAPPER_FLAGS_HPP_
+#define _RIVE_DATA_CONVERTER_RANGE_MAPPER_FLAGS_HPP_
+
+#include "rive/enum_bitset.hpp"
+
+namespace rive
+{
+enum class DataConverterRangeMapperFlags : unsigned short
+{
+
+    /// Whether the lower bound should be clamped
+    ClampLower = 1 << 0,
+
+    /// Whether the upper bound should be clamped
+    ClampUpper = 1 << 1,
+
+    /// Whether the value should wrap if it exceeds the range
+    Modulo = 1 << 2,
+
+    /// Whether to reverse the mapping
+    Reverse = 1 << 3,
+
+};
+
+RIVE_MAKE_ENUM_BITSET(DataConverterRangeMapperFlags)
+} // namespace rive
+#endif

defold-rive/include/rive/animation/elastic_interpolator.hpp

@@ -15,6 +15,7 @@ class ElasticInterpolator : public ElasticInterpolatorBase
     float transform(float factor) const override;
 
     Easing easing() const { return (Easing)easingValue(); }
+    void initialize() override;
 
 private:
     ElasticEase m_elastic;

defold-rive/include/rive/animation/hittable.hpp

@@ -0,0 +1,22 @@
+#ifndef _RIVE_HITTABLE_HPP_
+#define _RIVE_HITTABLE_HPP_
+
+#include "rive/math/aabb.hpp"
+
+namespace rive
+{
+class Component;
+
+// A Component that can be hit-tested via two passes: a faster AABB pass, and a
+// more accurate HiFi pass.
+class Hittable
+{
+public:
+    static Hittable* from(Component* component);
+    virtual bool hitTestAABB(const Vec2D& position) = 0;
+    virtual bool hitTestHiFi(const Vec2D& position, float hitRadius) = 0;
+    virtual ~Hittable() {}
+};
+} // namespace rive
+
+#endif

defold-rive/include/rive/animation/keyframe_interpolator.hpp

@@ -25,6 +25,8 @@ class KeyFrameInterpolator : public KeyFrameInterpolatorBase
     virtual float transform(float factor) const = 0;
 
     StatusCode import(ImportStack& importStack) override;
+
+    virtual void initialize(){};
 };
 } // namespace rive
 

defold-rive/include/rive/animation/nested_remap_animation.hpp

@@ -8,7 +8,7 @@ class NestedRemapAnimation : public NestedRemapAnimationBase
 {
 public:
     void timeChanged() override;
-    bool advance(float elapsedSeconds) override;
+    bool advance(float elapsedSeconds, bool newFrame) override;
     void initializeAnimation(ArtboardInstance*) override;
 };
 } // namespace rive

defold-rive/include/rive/animation/nested_simple_animation.hpp

@@ -7,7 +7,7 @@ namespace rive
 class NestedSimpleAnimation : public NestedSimpleAnimationBase
 {
 public:
-    bool advance(float elapsedSeconds) override;
+    bool advance(float elapsedSeconds, bool newFrame) override;
 };
 } // namespace rive
 

defold-rive/include/rive/animation/nested_state_machine.hpp

@@ -20,17 +20,16 @@ class NestedStateMachine : public NestedStateMachineBase
 public:
     NestedStateMachine();
     ~NestedStateMachine() override;
-    bool advance(float elapsedSeconds) override;
+    bool advance(float elapsedSeconds, bool newFrame) override;
     void initializeAnimation(ArtboardInstance*) override;
     StateMachineInstance* stateMachineInstance();
 
     HitResult pointerMove(Vec2D position);
     HitResult pointerDown(Vec2D position);
     HitResult pointerUp(Vec2D position);
     HitResult pointerExit(Vec2D position);
-#ifdef WITH_RIVE_TOOLS
+    bool tryChangeState();
     bool hitTest(Vec2D position) const;
-#endif
 
     void addNestedInput(NestedInput* input);
     size_t inputCount() { return m_nestedInputs.size(); }

defold-rive/include/rive/animation/state_machine_input_instance.hpp

@@ -3,6 +3,8 @@
 
 #include <string>
 #include <stdint.h>
+#include <vector>
+#include <algorithm>
 
 namespace rive
 {
@@ -73,17 +75,38 @@ class SMINumber : public SMIInput
     void value(float newValue);
 };
 
-class SMITrigger : public SMIInput
+class Triggerable
+{
+
+public:
+    bool useInLayer(StateMachineLayerInstance* layer) const
+    {
+        auto it = std::find(m_usedLayers.begin(), m_usedLayers.end(), layer);
+        if (it == m_usedLayers.end())
+        {
+            m_usedLayers.push_back(layer);
+            return true;
+        }
+        return false;
+    }
+
+protected:
+    mutable std::vector<StateMachineLayerInstance*> m_usedLayers;
+};
+
+class SMITrigger : public SMIInput, public Triggerable
 {
     friend class StateMachineInstance;
     friend class TransitionTriggerCondition;
-
-private:
     bool m_fired = false;
 
     SMITrigger(const StateMachineTrigger* input,
                StateMachineInstance* machineInstance);
-    void advanced() override { m_fired = false; }
+    void advanced() override
+    {
+        m_fired = false;
+        m_usedLayers.clear();
+    }
 
 public:
     void fire();