Update for Defold version 1.9.8 (#149)

* Update headers

* Update build scripts

* Update work-in-progress

* Build remaining packages

* Updated plugins

Author: Jhonnyg

defold-rive/include/defold/defold_graphics.h

@@ -198,7 +198,7 @@ namespace dmGraphics
     };
 
 	HTexture NewTexture(HContext context, const TextureCreationParams& params);
-    void SetTexture(HTexture texture, const TextureParams& params);
+    void     SetTexture(HTexture texture, const TextureParams& params);
 
     HRenderTarget NewRenderTarget(HContext context, uint32_t buffer_type_flags, const RenderTargetCreationParams params);
     void          DeleteRenderTarget(HRenderTarget render_target);
@@ -207,7 +207,6 @@ namespace dmGraphics
     HUniformLocation GetUniformLocation(HProgram prog, const char* name);
     uint32_t         GetUniformName(HProgram prog, uint32_t index, char* buffer, uint32_t buffer_size, Type* type, int32_t* size);
     uint32_t         GetUniformCount(HProgram prog);
-    HProgram         NewProgram(HContext context, HVertexProgram vertex_program, HFragmentProgram fragment_program);
 
     void SetStencilMask(HContext context, uint32_t mask);
     void SetStencilFunc(HContext context, CompareFunc func, uint32_t ref, uint32_t mask);

defold-rive/include/defold/defold_render.h

@@ -22,8 +22,7 @@
 namespace dmRender
 {
     const dmVMath::Matrix4& GetViewMatrix(HRenderContext render_context);
-    const dmVMath::Matrix4& GetViewProjectionMatrix(HRenderContext render_context);
-    HMaterial               NewMaterial(HRenderContext render_context, dmGraphics::HVertexProgram vertex_program, dmGraphics::HFragmentProgram fragment_program);
+    HMaterial               NewMaterial(dmRender::HRenderContext render_context, dmGraphics::HProgram program);
     void                    SetMaterialTags(HMaterial material, uint32_t tag_count, const dmhash_t* tags);
     bool                    SetMaterialSampler(HMaterial material, dmhash_t name_hash, uint32_t unit, dmGraphics::TextureWrap u_wrap, dmGraphics::TextureWrap v_wrap, dmGraphics::TextureFilter min_filter, dmGraphics::TextureFilter mag_filter, float max_anisotropy);
 }

defold-rive/include/defold/shaders/rivemodel_blit.fpc.gen.h

@@ -0,0 +1,5 @@
+// Generated with bob.jar version: 1.9.8  sha1: 31dffed4341ecaf2e9bc6bf447f5bed6da05b8e7  built: 2025-03-05 13:17:23
+// Generated, do not edit!
+#include <stdint.h>
+extern "C" uint8_t RIVEMODEL_BLIT_SPC[];
+extern "C" uint32_t RIVEMODEL_BLIT_SPC_SIZE;

defold-rive/include/defold/shaders/rivemodel_blit.spc.gen.h

@@ -21,6 +21,9 @@ enum class ArithmeticOperation : int
     asine = 13,
     atangent = 14,
     atangent2 = 15,
+    round = 16,
+    floor = 17,
+    ceil = 18,
 };
 } // namespace rive
 

defold-rive/include/defold/shaders/rivemodel_blit.vpc.gen.h

@@ -0,0 +1,21 @@
+#ifndef _RIVE_DATA_CONVERTER_TO_STRING_FLAGS_HPP_
+#define _RIVE_DATA_CONVERTER_TO_STRING_FLAGS_HPP_
+
+#include "rive/enum_bitset.hpp"
+
+namespace rive
+{
+enum class DataConverterToStringFlags : unsigned short
+{
+
+    /// Whether to round to decimals
+    Round = 1 << 0,
+
+    /// Whether to remove trailing zeros
+    TrailingZeros = 1 << 1,
+
+};
+
+RIVE_MAKE_ENUM_BITSET(DataConverterToStringFlags)
+} // namespace rive
+#endif

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

@@ -11,7 +11,9 @@ class ElasticEase
     float easeIn(float factor) const;
     float easeInOut(float factor) const;
 
+#ifndef TESTING
 private:
+#endif
     float computeActualAmplitude(float time) const;
     float m_amplitude;
     float m_period;

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

@@ -8,6 +8,7 @@ namespace rive
 class ListenerViewModelChange : public ListenerViewModelChangeBase
 {
 public:
+    ~ListenerViewModelChange();
     void perform(StateMachineInstance* stateMachineInstance,
                  Vec2D position,
                  Vec2D previousPosition) const override;

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

@@ -35,7 +35,7 @@ class NestedStateMachine : public NestedStateMachineBase
     size_t inputCount() { return m_nestedInputs.size(); }
     NestedInput* input(size_t index);
     NestedInput* input(std::string name);
-    void setDataContextFromInstance(ViewModelInstance* viewModelInstance);
+    void bindViewModelInstance(rcp<ViewModelInstance> viewModelInstance);
     void dataContext(DataContext* dataContext);
 };
 } // namespace rive

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

@@ -79,15 +79,22 @@ class Triggerable
 {
 
 public:
-    bool useInLayer(StateMachineLayerInstance* layer) const
+    bool isUsedInLayer(StateMachineLayerInstance* layer) const
+    {
+        auto it = std::find(m_usedLayers.begin(), m_usedLayers.end(), layer);
+        if (it == m_usedLayers.end())
+        {
+            return false;
+        }
+        return true;
+    }
+    void 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:

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

@@ -100,8 +100,8 @@ class StateMachineInstance : public Scene,
     SMIBool* getBool(const std::string& name) const override;
     SMINumber* getNumber(const std::string& name) const override;
     SMITrigger* getTrigger(const std::string& name) const override;
-    void setDataContextFromInstance(
-        ViewModelInstance* viewModelInstance) override;
+    void bindViewModelInstance(
+        rcp<ViewModelInstance> viewModelInstance) override;
     void dataContext(DataContext* dataContext);
 
     size_t currentAnimationCount() const;

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

@@ -134,6 +134,10 @@ class StateTransition : public StateTransitionBase
     /// correct time to the animation instance in the stateFrom, when
     /// applicable (when it's an AnimationState).
     bool applyExitCondition(StateInstance* stateFrom) const;
+
+    /// Marks any trigger based condition as used for this layer
+    void useLayerInConditions(StateMachineInstance* stateMachineInstance,
+                              StateMachineLayerInstance* layerInstance) const;
 };
 } // namespace rive
 

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

@@ -18,6 +18,10 @@ class TransitionComparator : public TransitionComparatorBase
                          const StateMachineInstance* stateMachineInstance,
                          StateMachineLayerInstance* layerInstance);
 
+    virtual void useInLayer(const StateMachineInstance* stateMachineInstance,
+                            StateMachineLayerInstance* layerInstance) const
+    {}
+
 protected:
     bool compareNumbers(float left, float right, TransitionConditionOp op);
     bool compareBooleans(bool left, bool right, TransitionConditionOp op);

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

@@ -22,6 +22,10 @@ class TransitionCondition : public TransitionConditionBase
         return true;
     }
 
+    virtual void useInLayer(const StateMachineInstance* stateMachineInstance,
+                            StateMachineLayerInstance* layerInstance) const
+    {}
+
 protected:
     virtual bool validateInputType(const StateMachineInput* input) const
     {

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

@@ -10,6 +10,7 @@ class TransitionPropertyViewModelComparator
     : public TransitionPropertyViewModelComparatorBase
 {
 public:
+    ~TransitionPropertyViewModelComparator();
     StatusCode import(ImportStack& importStack) override;
     bool compare(TransitionComparator* comparand,
                  TransitionConditionOp operation,
@@ -18,15 +19,20 @@ class TransitionPropertyViewModelComparator
     template <typename T = BindableProperty, typename U>
     U value(const StateMachineInstance* stateMachineInstance)
     {
-        if (m_bindableProperty->is<T>())
+        if (m_bindableProperty != nullptr && m_bindableProperty->is<T>())
         {
             auto bindableInstance =
                 stateMachineInstance->bindablePropertyInstance(
                     m_bindableProperty);
-            return bindableInstance->as<T>()->propertyValue();
+            if (bindableInstance != nullptr)
+            {
+                return bindableInstance->as<T>()->propertyValue();
+            }
         }
-        return (new T())->propertyValue();
+        return T::defaultValue;
     };
+    void useInLayer(const StateMachineInstance* stateMachineInstance,
+                    StateMachineLayerInstance* layerInstance) const override;
 
 protected:
     BindableProperty* m_bindableProperty;

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

@@ -9,6 +9,8 @@ class TransitionTriggerCondition : public TransitionTriggerConditionBase
 public:
     bool evaluate(const StateMachineInstance* stateMachineInstance,
                   StateMachineLayerInstance* layerInstance) const override;
+    void useInLayer(const StateMachineInstance* stateMachineInstance,
+                    StateMachineLayerInstance* layerInstance) const override;
 
 protected:
     bool validateInputType(const StateMachineInput* input) const override;

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

@@ -14,8 +14,11 @@ class TransitionViewModelCondition : public TransitionViewModelConditionBase
     TransitionComparator* m_rightComparator;
 
 public:
+    ~TransitionViewModelCondition();
     bool evaluate(const StateMachineInstance* stateMachineInstance,
                   StateMachineLayerInstance* layerInstance) const override;
+    void useInLayer(const StateMachineInstance* stateMachineInstance,
+                    StateMachineLayerInstance* layerInstance) const override;
     TransitionComparator* leftComparator() const { return m_leftComparator; };
     TransitionComparator* rightComparator() const { return m_rightComparator; };
     void comparator(TransitionComparator* value)

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

@@ -66,10 +66,10 @@ class Artboard : public ArtboardBase, public CoreContext
     std::vector<DataBind*> m_DataBinds;
     std::vector<DataBind*> m_AllDataBinds;
     DataContext* m_DataContext = nullptr;
+    bool m_ownsDataContext = false;
     bool m_JoysticksApplyBeforeUpdate = true;
 
     unsigned int m_DirtDepth = 0;
-    RawPath m_backgroundRawPath;
     Factory* m_Factory = nullptr;
     Drawable* m_FirstDrawable = nullptr;
     bool m_IsInstance = false;
@@ -101,6 +101,12 @@ class Artboard : public ArtboardBase, public CoreContext
     void host(NestedArtboard* nestedArtboard);
     NestedArtboard* host() const;
 
+    // Implemented for ShapePaintContainer.
+    const Mat2D& shapeWorldTransform() const override
+    {
+        return worldTransform();
+    }
+
 private:
 #ifdef TESTING
 public:
@@ -172,8 +178,8 @@ class Artboard : public ArtboardBase, public CoreContext
     void addToRenderPath(RenderPath* path, const Mat2D& transform);
 
 #ifdef TESTING
-    RenderPath* clipPath() const { return m_clipPath.get(); }
-    RenderPath* backgroundPath() const { return m_backgroundPath.get(); }
+    ShapePaintPath* clipPath() { return &m_worldPath; }
+    ShapePaintPath* backgroundPath() { return &m_localPath; }
 #endif
 
     const std::vector<Core*>& objects() const { return m_Objects; }
@@ -203,12 +209,12 @@ class Artboard : public ArtboardBase, public CoreContext
     void dataContext(DataContext* dataContext);
     void internalDataContext(DataContext* dataContext, bool isRoot);
     void clearDataContext();
-    void setDataContextFromInstance(ViewModelInstance* viewModelInstance,
-                                    DataContext* parent);
-    void setDataContextFromInstance(ViewModelInstance* viewModelInstance,
-                                    DataContext* parent,
-                                    bool isRoot);
-    void setDataContextFromInstance(ViewModelInstance* viewModelInstance);
+    void bindViewModelInstance(rcp<ViewModelInstance> viewModelInstance,
+                               DataContext* parent);
+    void bindViewModelInstance(rcp<ViewModelInstance> viewModelInstance,
+                               DataContext* parent,
+                               bool isRoot);
+    void bindViewModelInstance(rcp<ViewModelInstance> viewModelInstance);
     void addDataBind(DataBind* dataBind);
     void populateDataBinds(std::vector<DataBind*>* dataBinds);
     void sortDataBinds();
@@ -415,6 +421,7 @@ class Artboard : public ArtboardBase, public CoreContext
     void onLayoutDirty(ArtboardCallback callback)
     {
         m_layoutDirtyCallback = callback;
+        addDirt(ComponentDirt::Components);
     }
 #endif
 };

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

@@ -29,6 +29,7 @@ class CommandPath : public RefCnt<CommandPath>
     virtual void close() = 0;
 
     virtual RenderPath* renderPath() = 0;
+    virtual const RenderPath* renderPath() const = 0;
 
     // non-virtual helpers
 

defold-rive/include/rive/artboard.hpp

@@ -3,12 +3,12 @@
 #include <stdio.h>
 namespace rive
 {
-class LayoutComponent;
+class LayoutNodeProvider;
 
 class LayoutConstraint
 {
 public:
-    virtual void constrainChild(LayoutComponent* component) {}
+    virtual void constrainChild(LayoutNodeProvider* child) {}
 };
 } // namespace rive
 

defold-rive/include/rive/command_path.hpp

@@ -11,6 +11,7 @@
 #include <stdio.h>
 namespace rive
 {
+class LayoutNodeProvider;
 
 class ScrollConstraint : public ScrollConstraintBase,
                          public AdvancingComponent,
@@ -23,23 +24,29 @@ class ScrollConstraint : public ScrollConstraintBase,
     float m_offsetY = 0;
     ScrollPhysics* m_physics;
     Mat2D m_scrollTransform;
+    bool m_isDragging = false;
+
+    Vec2D positionAtIndex(float index);
+    float indexAtPosition(Vec2D pos);
 
 public:
     void constrain(TransformComponent* component) override;
     std::vector<DraggableProxy*> draggables() override;
     void buildDependencies() override;
     StatusCode import(ImportStack& importStack) override;
+    StatusCode onAddedDirty(CoreContext* context) override;
     Core* clone() const override;
     void dragView(Vec2D delta);
     void runPhysics();
-    void constrainChild(LayoutComponent* component) override;
+    void constrainChild(LayoutNodeProvider* child) override;
     bool advanceComponent(float elapsedSeconds,
                           AdvanceFlags flags = AdvanceFlags::Animate |
                                                AdvanceFlags::NewFrame) override;
 
     ScrollPhysics* physics() const { return m_physics; }
     void physics(ScrollPhysics* physics) { m_physics = physics; }
     void initPhysics();
+    void stopPhysics();
 
     ScrollPhysicsType physicsType() const
     {
@@ -147,6 +154,16 @@ class ScrollConstraint : public ScrollConstraintBase,
         m_offsetY = value;
         content()->markWorldTransformDirty();
     }
+
+    void scrollOffsetXChanged() override { offsetX(scrollOffsetX()); }
+    void scrollOffsetYChanged() override { offsetY(scrollOffsetY()); }
+
+    float scrollPercentX() override;
+    float scrollPercentY() override;
+    float scrollIndex() override;
+    void setScrollPercentX(float value) override;
+    void setScrollPercentY(float value) override;
+    void setScrollIndex(float value) override;
 };
 } // namespace rive
 

defold-rive/include/rive/constraints/layout_constraint.hpp

@@ -53,7 +53,11 @@ class ScrollPhysics : public ScrollPhysicsBase
         m_isRunning = true;
     }
     virtual void stop() { m_isRunning = false; }
-    virtual void reset() {}
+    virtual void reset()
+    {
+        m_acceleration = Vec2D();
+        stop();
+    }
     StatusCode import(ImportStack& importStack) override;
 };
 } // namespace rive

defold-rive/include/rive/constraints/scrolling/scroll_constraint.hpp

@@ -13,10 +13,12 @@ class ContainerComponent : public ContainerComponentBase
     virtual void addChild(Component* component);
     bool collapse(bool value) override;
 
-    // Returns true if it searched through all of its children. predicate can
-    // return false to stop searching.
+    // Returns whether predicate returns true for the current Component.
     bool forAll(std::function<bool(Component*)> predicate);
-    bool forEachChild(std::function<bool(Component*)> predicate);
+
+    // Recursively descend onto all the children in the hierarchy tree.
+    // If predicate returns false, it won't recurse down a particular branch.
+    void forEachChild(std::function<bool(Component*)> predicate);
 
 private:
     std::vector<Component*> m_children;