├── example ├── build.sh ├── run.sh ├── assets │ ├── Filip.flr │ └── Teddy.flr ├── .vscode │ ├── c_cpp_properties.json │ ├── launch.json │ └── tasks.json └── build │ └── genie.lua ├── test ├── run.sh ├── assets │ └── Filip.flr ├── src │ └── main.cpp ├── .vscode │ ├── c_cpp_properties.json │ ├── launch.json │ └── tasks.json └── build │ └── genie.lua ├── flare ├── .vscode │ ├── settings.json │ ├── c_cpp_properties.json │ └── tasks.json ├── src │ ├── actor_drawable_proxy.cpp │ ├── actor_instance.cpp │ ├── animation │ │ ├── keyframes │ │ │ ├── keyframe_pos_x.cpp │ │ │ ├── keyframe_pos_y.cpp │ │ │ ├── keyframe_opacity.cpp │ │ │ ├── keyframe_scale_x.cpp │ │ │ ├── keyframe_scale_y.cpp │ │ │ ├── keyframe_rotation.cpp │ │ │ ├── keyframe_length.cpp │ │ │ ├── keyframe_constraint_strength.cpp │ │ │ ├── keyframe.cpp │ │ │ ├── keyframe_inner_radius.cpp │ │ │ ├── keyframe_stroke_end.cpp │ │ │ ├── keyframe_paint_opacity.cpp │ │ │ ├── keyframe_stroke_width.cpp │ │ │ ├── keyframe_stroke_start.cpp │ │ │ ├── keyframe_shape_width.cpp │ │ │ ├── keyframe_stroke_offset.cpp │ │ │ ├── keyframe_shape_height.cpp │ │ │ ├── keyframe_corner_radius.cpp │ │ │ ├── keyframe_sequence.cpp │ │ │ ├── keyframe_trigger.cpp │ │ │ ├── keyframe_active_child.cpp │ │ │ ├── keyframe_is_collision_enabled.cpp │ │ │ ├── keyframe_draw_order.cpp │ │ │ ├── keyframe_fill_color.cpp │ │ │ ├── keyframe_numeric.cpp │ │ │ └── keyframe_custom_property.cpp │ │ └── interpolators │ │ │ └── cubic_interpolator.cpp │ ├── paint │ │ ├── actor_fill.cpp │ │ ├── actor_color.cpp │ │ ├── actor_color_fill.cpp │ │ ├── actor_gradient_fill.cpp │ │ ├── actor_color_stroke.cpp │ │ ├── actor_radial_gradient.cpp │ │ ├── actor_radial_gradient_fill.cpp │ │ ├── actor_gradient_stroke.cpp │ │ ├── actor_radial_gradient_stroke.cpp │ │ └── actor_paint.cpp │ ├── nested_actor_asset.cpp │ ├── actor_root_bone.cpp │ ├── actor_event.cpp │ ├── path │ │ ├── actor_triangle.cpp │ │ ├── path_point.cpp │ │ ├── actor_ellipse.cpp │ │ ├── actor_polygon.cpp │ │ ├── actor_rectangle.cpp │ │ ├── actor_star.cpp │ │ └── straight_path_point.cpp │ ├── dependency_sorter.cpp │ ├── actor_bone.cpp │ ├── actor_jelly_bone.cpp │ ├── actor_targeted_constraint.cpp │ ├── actor_shape.cpp │ ├── actor_drawable.cpp │ ├── actor_constraint.cpp │ ├── actor_node_solo.cpp │ ├── block_reader.cpp │ ├── actor_skinnable.cpp │ ├── actor_bone_base.cpp │ └── actor_procedural_path.cpp ├── build │ ├── genie.lua │ └── flare.lua └── include │ └── flare │ ├── paint │ ├── fill_rule.hpp │ ├── stroke_cap.hpp │ ├── trim_path.hpp │ ├── stroke_join.hpp │ ├── actor_fill.hpp │ ├── actor_color.hpp │ ├── actor_radial_gradient.hpp │ ├── actor_color_fill.hpp │ ├── actor_color_stroke.hpp │ ├── actor_gradient_fill.hpp │ ├── actor_radial_gradient_fill.hpp │ ├── actor_gradient_stroke.hpp │ ├── actor_radial_gradient_stroke.hpp │ ├── actor_paint.hpp │ ├── actor_gradient_color.hpp │ └── actor_stroke.hpp │ ├── transform_space.hpp │ ├── actor_instance.hpp │ ├── animation │ ├── interpolators │ │ ├── keyframe_interpolator.hpp │ │ ├── cubic_interpolator.hpp │ │ ├── hold_interpolator.hpp │ │ ├── linear_interpolator.hpp │ │ ├── cubic_solver.hpp │ │ └── cubic_ease.hpp │ ├── keyframes │ │ ├── keyframe_pos_x.hpp │ │ ├── keyframe_pos_y.hpp │ │ ├── keyframe_length.hpp │ │ ├── keyframe_scale_x.hpp │ │ ├── keyframe_scale_y.hpp │ │ ├── keyframe_opacity.hpp │ │ ├── keyframe_rotation.hpp │ │ ├── keyframe_stroke_end.hpp │ │ ├── keyframe_shape_width.hpp │ │ ├── keyframe_inner_radius.hpp │ │ ├── keyframe_shape_height.hpp │ │ ├── keyframe_stroke_start.hpp │ │ ├── keyframe_stroke_width.hpp │ │ ├── keyframe_corner_radius.hpp │ │ ├── keyframe_paint_opacity.hpp │ │ ├── keyframe_stroke_offset.hpp │ │ ├── keyframe_constraint_strength.hpp │ │ ├── keyframe_sequence.hpp │ │ ├── keyframe_trigger.hpp │ │ ├── keyframe_is_collision_enabled.hpp │ │ ├── keyframe_color.hpp │ │ ├── keyframe_active_child.hpp │ │ ├── keyframe_gradient.hpp │ │ ├── keyframe_with_interpolation.hpp │ │ ├── keyframe_path_vertices.hpp │ │ ├── keyframe.hpp │ │ ├── keyframe_image_vertices.hpp │ │ ├── keyframe_radial_gradient.hpp │ │ ├── keyframe_draw_order.hpp │ │ ├── keyframe_numeric.hpp │ │ └── keyframe_custom_property.hpp │ ├── component_animation.hpp │ ├── actor_animation_instance.hpp │ ├── actor_animation.hpp │ └── property_animation.hpp │ ├── actor_drawable_proxy.hpp │ ├── path │ ├── actor_ellipse.hpp │ ├── actor_triangle.hpp │ ├── actor_polygon.hpp │ ├── actor_rectangle.hpp │ ├── actor_star.hpp │ ├── actor_base_path.hpp │ ├── actor_procedural_path.hpp │ └── actor_path.hpp │ ├── exceptions │ ├── overflow_exception.hpp │ ├── missing_file_exception.hpp │ └── unsupported_version_exception.hpp │ ├── actor_jelly_bone.hpp │ ├── dependency_sorter.hpp │ ├── actor_event.hpp │ ├── actor_root_bone.hpp │ ├── nested_actor_asset.hpp │ ├── actor_bone.hpp │ ├── actor_translation_constraint.hpp │ ├── blend_mode.hpp │ ├── actor_scale_constraint.hpp │ ├── actor_node_solo.hpp │ ├── block_reader.hpp │ ├── actor_skin.hpp │ ├── actor_bone_base.hpp │ ├── actor_shape.hpp │ ├── actor_distance_constraint.hpp │ ├── actor_constraint.hpp │ ├── actor_targeted_constraint.hpp │ ├── binary_reader.hpp │ ├── nested_actor_node.hpp │ ├── actor_drawable.hpp │ ├── actor_transform_constraint.hpp │ ├── actor_rotation_constraint.hpp │ ├── actor_axis_constraint.hpp │ ├── actor_skinnable.hpp │ ├── actor_flags.hpp │ ├── actor_static_mesh.hpp │ ├── block_types.hpp │ ├── jelly_component.hpp │ └── actor_ik_constraint.hpp ├── flare_math ├── build │ ├── genie.lua │ └── flare_math.lua ├── .vscode │ └── c_cpp_properties.json └── include │ └── flare_math │ ├── aabb.hpp │ ├── mat2d.hpp │ ├── transform_components.hpp │ └── vec2d.hpp ├── flare_skia ├── build │ ├── genie.lua │ └── flare_skia.lua ├── src │ ├── skr_actor_star.cpp │ ├── skr_actor_ellipse.cpp │ ├── srk_actor_polygon.cpp │ ├── skr_actor_triangle.cpp │ ├── skr_actor_rectangle.cpp │ ├── skr_actor_path.cpp │ ├── skr_drawable_proxy.cpp │ ├── skr_color_fill.cpp │ ├── skr_color_stroke.cpp │ ├── skr_actor_artboard.cpp │ ├── skr_fill.cpp │ ├── skr_stroke.cpp │ ├── skr_drawable.cpp │ ├── skr_gradient_fill.cpp │ ├── skr_gradient_stroke.cpp │ ├── skr_radial_gradient_fill.cpp │ └── skr_radial_gradient_stroke.cpp ├── include │ └── flare_skia │ │ ├── skr_actor_path.hpp │ │ ├── skr_actor_star.hpp │ │ ├── skr_actor_ellipse.hpp │ │ ├── skr_actor_polygon.hpp │ │ ├── skr_actor_artboard.hpp │ │ ├── skr_actor_triangle.hpp │ │ ├── skr_actor_rectangle.hpp │ │ ├── skr_color_fill.hpp │ │ ├── skr_color_stroke.hpp │ │ ├── skr_fill.hpp │ │ ├── skr_drawable_proxy.hpp │ │ ├── skr_drawable.hpp │ │ ├── skr_gradient_fill.hpp │ │ ├── skr_gradient_stroke.hpp │ │ ├── skr_stroke.hpp │ │ ├── skr_radial_gradient_fill.hpp │ │ ├── skr_actor_base_path.hpp │ │ ├── skr_radial_gradient_stroke.hpp │ │ ├── skr_actor.hpp │ │ └── skr_actor_shape.hpp └── .vscode │ └── tasks.json ├── generate_compile_commands.sh ├── .gitignore ├── flare.code-workspace ├── .clang-format ├── LICENSE └── dependencies └── make_dependencies.sh /example/build.sh: -------------------------------------------------------------------------------- 1 | cd build 2 | genie gmake 3 | make -j7 4 | cd ../ -------------------------------------------------------------------------------- /test/run.sh: -------------------------------------------------------------------------------- 1 | cd build 2 | genie ninja 3 | make 4 | cd ../ 5 | build/debug/bin/test -------------------------------------------------------------------------------- /example/run.sh: -------------------------------------------------------------------------------- 1 | cd build 2 | genie gmake 3 | make -j7 4 | cd ../ 5 | build/debug/bin/example -------------------------------------------------------------------------------- /test/assets/Filip.flr: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/2d-inc/flare_cpp/HEAD/test/assets/Filip.flr -------------------------------------------------------------------------------- /example/assets/Filip.flr: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/2d-inc/flare_cpp/HEAD/example/assets/Filip.flr -------------------------------------------------------------------------------- /example/assets/Teddy.flr: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/2d-inc/flare_cpp/HEAD/example/assets/Teddy.flr -------------------------------------------------------------------------------- /flare/.vscode/settings.json: -------------------------------------------------------------------------------- 1 | { 2 | "cquery.cacheDirectory": "${workspaceFolder}/.vscode/cquery_cached_index/" 3 | } -------------------------------------------------------------------------------- /flare/src/actor_drawable_proxy.cpp: -------------------------------------------------------------------------------- 1 | #include "flare/actor_drawable_proxy.hpp" 2 | 3 | using namespace flare; 4 | 5 | ActorDrawableProxy::ActorDrawableProxy(ActorDrawable* drawable) : m_Drawable(drawable) {} -------------------------------------------------------------------------------- /flare/build/genie.lua: -------------------------------------------------------------------------------- 1 | solution "flare" 2 | 3 | configurations 4 | { 5 | "Debug", 6 | "Release" 7 | } 8 | 9 | configuration "Debug" 10 | flags 11 | { 12 | "Symbols" 13 | } 14 | 15 | dofile("flare.lua") -------------------------------------------------------------------------------- /flare_math/build/genie.lua: -------------------------------------------------------------------------------- 1 | solution "flare_math" 2 | 3 | configurations 4 | { 5 | "Debug", 6 | "Release" 7 | } 8 | 9 | configuration "Debug" 10 | flags 11 | { 12 | "Symbols" 13 | } 14 | 15 | dofile("flare_math.lua") -------------------------------------------------------------------------------- /flare_skia/build/genie.lua: -------------------------------------------------------------------------------- 1 | solution "flare_skia" 2 | 3 | configurations 4 | { 5 | "Debug", 6 | "Release" 7 | } 8 | 9 | configuration "Debug" 10 | flags 11 | { 12 | "Symbols" 13 | } 14 | 15 | dofile("flare_skia.lua") -------------------------------------------------------------------------------- /flare_skia/src/skr_actor_star.cpp: -------------------------------------------------------------------------------- 1 | #include "flare_skia/skr_actor_star.hpp" 2 | 3 | using namespace flare; 4 | 5 | SkrActorStar::SkrActorStar() : SkrActorBasePath(this) {} 6 | 7 | void SkrActorStar::invalidateDrawable() { m_IsPathValid = false; } -------------------------------------------------------------------------------- /flare/include/flare/paint/fill_rule.hpp: -------------------------------------------------------------------------------- 1 | #ifndef _FLARE_FILL_RULE_HPP_ 2 | #define _FLARE_FILL_RULE_HPP_ 3 | 4 | namespace flare 5 | { 6 | enum class FillRule : signed int 7 | { 8 | EvenOdd = 0, 9 | NonZero = 1 10 | }; 11 | } 12 | 13 | #endif -------------------------------------------------------------------------------- /flare/include/flare/transform_space.hpp: -------------------------------------------------------------------------------- 1 | #ifndef _FLARE_TRANSFORMSPACE_HPP_ 2 | #define _FLARE_TRANSFORMSPACE_HPP_ 3 | 4 | namespace flare 5 | { 6 | enum class TransformSpace 7 | { 8 | Local = 0, 9 | World = 1 10 | }; 11 | } 12 | 13 | #endif -------------------------------------------------------------------------------- /flare/src/actor_instance.cpp: -------------------------------------------------------------------------------- 1 | #include "flare/actor_instance.hpp" 2 | 3 | using namespace flare; 4 | 5 | ActorInstance::ActorInstance(const Actor& actor) 6 | { 7 | copy(actor); 8 | /* 9 | */ 10 | } 11 | 12 | ActorInstance::~ActorInstance() {} -------------------------------------------------------------------------------- /flare_skia/src/skr_actor_ellipse.cpp: -------------------------------------------------------------------------------- 1 | #include "flare_skia/skr_actor_ellipse.hpp" 2 | 3 | using namespace flare; 4 | 5 | SkrActorEllipse::SkrActorEllipse() : SkrActorBasePath(this) {} 6 | 7 | void SkrActorEllipse::invalidateDrawable() { m_IsPathValid = false; } -------------------------------------------------------------------------------- /flare_skia/src/srk_actor_polygon.cpp: -------------------------------------------------------------------------------- 1 | #include "flare_skia/skr_actor_polygon.hpp" 2 | 3 | using namespace flare; 4 | 5 | SkrActorPolygon::SkrActorPolygon() : SkrActorBasePath(this) {} 6 | 7 | void SkrActorPolygon::invalidateDrawable() { m_IsPathValid = false; } -------------------------------------------------------------------------------- /flare_skia/src/skr_actor_triangle.cpp: -------------------------------------------------------------------------------- 1 | #include "flare_skia/skr_actor_triangle.hpp" 2 | 3 | using namespace flare; 4 | 5 | SkrActorTriangle::SkrActorTriangle() : SkrActorBasePath(this) {} 6 | 7 | void SkrActorTriangle::invalidateDrawable() { m_IsPathValid = false; } -------------------------------------------------------------------------------- /flare_skia/src/skr_actor_rectangle.cpp: -------------------------------------------------------------------------------- 1 | #include "flare_skia/skr_actor_rectangle.hpp" 2 | 3 | using namespace flare; 4 | 5 | SkrActorRectangle::SkrActorRectangle() : SkrActorBasePath(this) {} 6 | 7 | void SkrActorRectangle::invalidateDrawable() { m_IsPathValid = false; } -------------------------------------------------------------------------------- /flare/include/flare/paint/stroke_cap.hpp: -------------------------------------------------------------------------------- 1 | #ifndef _FLARE_STROKE_CAP_HPP_ 2 | #define _FLARE_STROKE_CAP_HPP_ 3 | 4 | namespace flare 5 | { 6 | enum class StrokeCap : signed int 7 | { 8 | Butt = 0, 9 | Round = 1, 10 | Square = 2 11 | }; 12 | } 13 | 14 | #endif -------------------------------------------------------------------------------- /flare/include/flare/paint/trim_path.hpp: -------------------------------------------------------------------------------- 1 | #ifndef _FLARE_TRIM_PATH_HPP_ 2 | #define _FLARE_TRIM_PATH_HPP_ 3 | 4 | namespace flare 5 | { 6 | enum class TrimPath : signed int 7 | { 8 | Off = 0, 9 | Sequential = 1, 10 | Synced = 2 11 | }; 12 | } 13 | 14 | #endif -------------------------------------------------------------------------------- /flare/include/flare/paint/stroke_join.hpp: -------------------------------------------------------------------------------- 1 | #ifndef _FLARE_STROKE_JOIN_HPP_ 2 | #define _FLARE_STROKE_JOIN_HPP_ 3 | 4 | namespace flare 5 | { 6 | enum class StrokeJoin : signed int 7 | { 8 | Miter = 0, 9 | Round = 1, 10 | Bevel = 2 11 | }; 12 | } 13 | 14 | #endif -------------------------------------------------------------------------------- /flare_skia/src/skr_actor_path.cpp: -------------------------------------------------------------------------------- 1 | #include "flare_skia/skr_actor_path.hpp" 2 | 3 | using namespace flare; 4 | 5 | SkrActorPath::SkrActorPath() : SkrActorBasePath(this) {} 6 | 7 | void SkrActorPath::invalidateDrawable() 8 | { 9 | Base::invalidateDrawable(); 10 | m_IsPathValid = false; 11 | } -------------------------------------------------------------------------------- /generate_compile_commands.sh: -------------------------------------------------------------------------------- 1 | function generate_commands() 2 | { 3 | cd build 4 | genie ninja 5 | ninja -C debug -t compdb cxx > ../compile_commands.json 6 | cd .. 7 | } 8 | 9 | cd flare_math && generate_commands && cd .. 10 | cd flare && generate_commands && cd .. 11 | cd test && generate_commands && cd .. -------------------------------------------------------------------------------- /flare/include/flare/actor_instance.hpp: -------------------------------------------------------------------------------- 1 | #ifndef _FLARE_ACTORINSTANCE_HPP_ 2 | #define _FLARE_ACTORINSTANCE_HPP_ 3 | 4 | #include "actor.hpp" 5 | 6 | namespace flare 7 | { 8 | class ActorInstance : public Actor 9 | { 10 | public: 11 | ActorInstance(const Actor& actor); 12 | ~ActorInstance(); 13 | }; 14 | } // namespace flare 15 | #endif -------------------------------------------------------------------------------- /flare_skia/src/skr_drawable_proxy.cpp: -------------------------------------------------------------------------------- 1 | #include "flare/actor_drawable.hpp" 2 | #include "flare_skia/skr_drawable_proxy.hpp" 3 | #include "flare_skia/skr_drawable.hpp" 4 | 5 | using namespace flare; 6 | 7 | SkrDrawableProxy::SkrDrawableProxy(ActorDrawable* drawable) : Base(drawable), m_SkrDrawable(dynamic_cast(drawable)) 8 | { 9 | 10 | } -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | .DS_Store 2 | /build/debug 3 | /build/release 4 | /build/Makefile 5 | */build/debug 6 | */build/release 7 | */build/Makefile 8 | *.ninja 9 | *.o 10 | *.a 11 | *.make 12 | compile_commands.json 13 | **/ipch/** 14 | **/cquery_cached_index/** 15 | dependencies/glfw 16 | dependencies/glfw_build 17 | dependencies/skia 18 | *.xcodeproj 19 | *.xcworkspace 20 | -------------------------------------------------------------------------------- /flare/include/flare/animation/interpolators/keyframe_interpolator.hpp: -------------------------------------------------------------------------------- 1 | #ifndef _FLARE_KEYFRAME_INTERPOLATOR_HPP_ 2 | #define _FLARE_KEYFRAME_INTERPOLATOR_HPP_ 3 | 4 | namespace flare 5 | { 6 | class KeyFrameInterpolator 7 | { 8 | public: 9 | virtual ~KeyFrameInterpolator() {} 10 | virtual float getEasedMix(float mix) const = 0; 11 | }; 12 | } // namespace flare 13 | 14 | #endif 15 | -------------------------------------------------------------------------------- /flare/src/animation/keyframes/keyframe_pos_x.cpp: -------------------------------------------------------------------------------- 1 | #include "flare/animation/keyframes/keyframe_pos_x.hpp" 2 | #include "flare/actor_node.hpp" 3 | 4 | using namespace flare; 5 | 6 | void KeyFramePosX::setValue(ActorComponent* component, float value, float mix) 7 | { 8 | ActorNode* node = reinterpret_cast(component); 9 | node->x(node->x() * (1.0f - mix) + value * mix); 10 | } -------------------------------------------------------------------------------- /flare/src/animation/keyframes/keyframe_pos_y.cpp: -------------------------------------------------------------------------------- 1 | #include "flare/animation/keyframes/keyframe_pos_y.hpp" 2 | #include "flare/actor_node.hpp" 3 | 4 | using namespace flare; 5 | 6 | void KeyFramePosY::setValue(ActorComponent* component, float value, float mix) 7 | { 8 | ActorNode* node = reinterpret_cast(component); 9 | node->y(node->y() * (1.0f - mix) + value * mix); 10 | } -------------------------------------------------------------------------------- /flare/src/animation/keyframes/keyframe_opacity.cpp: -------------------------------------------------------------------------------- 1 | #include "flare/animation/keyframes/keyframe_opacity.hpp" 2 | #include "flare/actor_node.hpp" 3 | 4 | using namespace flare; 5 | 6 | void KeyFrameOpacity::setValue(ActorComponent* component, float value, float mix) 7 | { 8 | ActorNode* node = reinterpret_cast(component); 9 | node->opacity(node->opacity() * (1.0f - mix) + value * mix); 10 | } -------------------------------------------------------------------------------- /flare/src/animation/keyframes/keyframe_scale_x.cpp: -------------------------------------------------------------------------------- 1 | #include "flare/animation/keyframes/keyframe_scale_x.hpp" 2 | #include "flare/actor_node.hpp" 3 | 4 | using namespace flare; 5 | 6 | void KeyFrameScaleX::setValue(ActorComponent* component, float value, float mix) 7 | { 8 | ActorNode* node = reinterpret_cast(component); 9 | node->scaleX(node->scaleX() * (1.0f - mix) + value * mix); 10 | } -------------------------------------------------------------------------------- /flare/src/animation/keyframes/keyframe_scale_y.cpp: -------------------------------------------------------------------------------- 1 | #include "flare/animation/keyframes/keyframe_scale_y.hpp" 2 | #include "flare/actor_node.hpp" 3 | 4 | using namespace flare; 5 | 6 | void KeyFrameScaleY::setValue(ActorComponent* component, float value, float mix) 7 | { 8 | ActorNode* node = reinterpret_cast(component); 9 | node->scaleY(node->scaleY() * (1.0f - mix) + value * mix); 10 | } -------------------------------------------------------------------------------- /flare/src/animation/keyframes/keyframe_rotation.cpp: -------------------------------------------------------------------------------- 1 | #include "flare/animation/keyframes/keyframe_rotation.hpp" 2 | #include "flare/actor_node.hpp" 3 | 4 | using namespace flare; 5 | 6 | void KeyFrameRotation::setValue(ActorComponent* component, float value, float mix) 7 | { 8 | ActorNode* node = reinterpret_cast(component); 9 | node->rotation(node->rotation() * (1.0f - mix) + value * mix); 10 | } -------------------------------------------------------------------------------- /flare/include/flare/animation/keyframes/keyframe_pos_x.hpp: -------------------------------------------------------------------------------- 1 | #ifndef _FLARE_KEYFRAMEPOSX_HPP_ 2 | #define _FLARE_KEYFRAMEPOSX_HPP_ 3 | 4 | #include "keyframe_numeric.hpp" 5 | 6 | namespace flare 7 | { 8 | class ActorComponent; 9 | 10 | class KeyFramePosX : public KeyFrameNumeric 11 | { 12 | protected: 13 | void setValue(ActorComponent* component, float value, float mix) override; 14 | }; 15 | } 16 | 17 | #endif -------------------------------------------------------------------------------- /flare/include/flare/animation/keyframes/keyframe_pos_y.hpp: -------------------------------------------------------------------------------- 1 | #ifndef _FLARE_KEYFRAMEPOSY_HPP_ 2 | #define _FLARE_KEYFRAMEPOSY_HPP_ 3 | 4 | #include "keyframe_numeric.hpp" 5 | 6 | namespace flare 7 | { 8 | class ActorComponent; 9 | 10 | class KeyFramePosY : public KeyFrameNumeric 11 | { 12 | protected: 13 | void setValue(ActorComponent* component, float value, float mix) override; 14 | }; 15 | } 16 | 17 | #endif -------------------------------------------------------------------------------- /flare/include/flare/animation/keyframes/keyframe_length.hpp: -------------------------------------------------------------------------------- 1 | #ifndef _FLARE_KEYFRAMELENGTH_HPP_ 2 | #define _FLARE_KEYFRAMELENGTH_HPP_ 3 | 4 | #include "keyframe_numeric.hpp" 5 | 6 | namespace flare 7 | { 8 | class ActorNode; 9 | 10 | class KeyFrameLength : public KeyFrameNumeric 11 | { 12 | protected: 13 | void setValue(ActorComponent* component, float value, float mix) override; 14 | }; 15 | } 16 | 17 | #endif -------------------------------------------------------------------------------- /flare/include/flare/animation/keyframes/keyframe_scale_x.hpp: -------------------------------------------------------------------------------- 1 | #ifndef _FLARE_KEYFRAMESCALEX_HPP_ 2 | #define _FLARE_KEYFRAMESCALEX_HPP_ 3 | 4 | #include "keyframe_numeric.hpp" 5 | 6 | namespace flare 7 | { 8 | class ActorComponent; 9 | 10 | class KeyFrameScaleX : public KeyFrameNumeric 11 | { 12 | protected: 13 | void setValue(ActorComponent* component, float value, float mix) override; 14 | }; 15 | } 16 | 17 | #endif -------------------------------------------------------------------------------- /flare/include/flare/animation/keyframes/keyframe_scale_y.hpp: -------------------------------------------------------------------------------- 1 | #ifndef _FLARE_KEYFRAMESCALEY_HPP_ 2 | #define _FLARE_KEYFRAMESCALEY_HPP_ 3 | 4 | #include "keyframe_numeric.hpp" 5 | 6 | namespace flare 7 | { 8 | class ActorComponent; 9 | 10 | class KeyFrameScaleY : public KeyFrameNumeric 11 | { 12 | protected: 13 | void setValue(ActorComponent* component, float value, float mix) override; 14 | }; 15 | } 16 | 17 | #endif -------------------------------------------------------------------------------- /flare/include/flare/animation/keyframes/keyframe_opacity.hpp: -------------------------------------------------------------------------------- 1 | #ifndef _FLARE_KEYFRAMEOPACITY_HPP_ 2 | #define _FLARE_KEYFRAMEOPACITY_HPP_ 3 | 4 | #include "keyframe_numeric.hpp" 5 | 6 | namespace flare 7 | { 8 | class ActorComponent; 9 | 10 | class KeyFrameOpacity : public KeyFrameNumeric 11 | { 12 | protected: 13 | void setValue(ActorComponent* component, float value, float mix) override; 14 | }; 15 | } 16 | 17 | #endif -------------------------------------------------------------------------------- /flare/include/flare/animation/keyframes/keyframe_rotation.hpp: -------------------------------------------------------------------------------- 1 | #ifndef _FLARE_KEYFRAMEROTATION_HPP_ 2 | #define _FLARE_KEYFRAMEROTATION_HPP_ 3 | 4 | #include "keyframe_numeric.hpp" 5 | 6 | namespace flare 7 | { 8 | class ActorComponent; 9 | 10 | class KeyFrameRotation : public KeyFrameNumeric 11 | { 12 | protected: 13 | void setValue(ActorComponent* component, float value, float mix) override; 14 | }; 15 | } 16 | 17 | #endif -------------------------------------------------------------------------------- /flare/include/flare/animation/keyframes/keyframe_stroke_end.hpp: -------------------------------------------------------------------------------- 1 | #ifndef _FLARE_KEYFRAME_STROKE_END_HPP_ 2 | #define _FLARE_KEYFRAME_STROKE_END_HPP_ 3 | 4 | #include "keyframe_numeric.hpp" 5 | 6 | namespace flare 7 | { 8 | class ActorNode; 9 | 10 | class KeyFrameStrokeEnd : public KeyFrameNumeric 11 | { 12 | protected: 13 | void setValue(ActorComponent* component, float value, float mix) override; 14 | }; 15 | } 16 | 17 | #endif -------------------------------------------------------------------------------- /flare/include/flare/animation/keyframes/keyframe_shape_width.hpp: -------------------------------------------------------------------------------- 1 | #ifndef _FLARE_KEYFRAME_SHAPE_WIDTH_HPP_ 2 | #define _FLARE_KEYFRAME_SHAPE_WIDTH_HPP_ 3 | 4 | #include "keyframe_numeric.hpp" 5 | 6 | namespace flare 7 | { 8 | class ActorNode; 9 | 10 | class KeyFrameShapeWidth : public KeyFrameNumeric 11 | { 12 | protected: 13 | void setValue(ActorComponent* component, float value, float mix) override; 14 | }; 15 | } 16 | 17 | #endif -------------------------------------------------------------------------------- /flare/src/animation/keyframes/keyframe_length.cpp: -------------------------------------------------------------------------------- 1 | #include "flare/animation/keyframes/keyframe_length.hpp" 2 | #include "flare/actor_bone.hpp" 3 | 4 | using namespace flare; 5 | 6 | void KeyFrameLength::setValue(ActorComponent* component, float value, float mix) 7 | { 8 | // Hard assumption this is a bone. 9 | ActorBone* bone = reinterpret_cast(component); 10 | bone->length(bone->length() * (1.0f - mix) + value * mix); 11 | } -------------------------------------------------------------------------------- /flare/include/flare/animation/keyframes/keyframe_inner_radius.hpp: -------------------------------------------------------------------------------- 1 | #ifndef _FLARE_KEYFRAME_INNER_RADIUS_HPP_ 2 | #define _FLARE_KEYFRAME_INNER_RADIUS_HPP_ 3 | 4 | #include "keyframe_numeric.hpp" 5 | 6 | namespace flare 7 | { 8 | class ActorNode; 9 | 10 | class KeyFrameInnerRadius : public KeyFrameNumeric 11 | { 12 | protected: 13 | void setValue(ActorComponent* component, float value, float mix) override; 14 | }; 15 | } 16 | 17 | #endif -------------------------------------------------------------------------------- /flare/include/flare/animation/keyframes/keyframe_shape_height.hpp: -------------------------------------------------------------------------------- 1 | #ifndef _FLARE_KEYFRAME_SHAPE_HEIGHT_HPP_ 2 | #define _FLARE_KEYFRAME_SHAPE_HEIGHT_HPP_ 3 | 4 | #include "keyframe_numeric.hpp" 5 | 6 | namespace flare 7 | { 8 | class ActorNode; 9 | 10 | class KeyFrameShapeHeight : public KeyFrameNumeric 11 | { 12 | protected: 13 | void setValue(ActorComponent* component, float value, float mix) override; 14 | }; 15 | } 16 | 17 | #endif -------------------------------------------------------------------------------- /flare/include/flare/animation/keyframes/keyframe_stroke_start.hpp: -------------------------------------------------------------------------------- 1 | #ifndef _FLARE_KEYFRAME_STROKE_START_HPP_ 2 | #define _FLARE_KEYFRAME_STROKE_START_HPP_ 3 | 4 | #include "keyframe_numeric.hpp" 5 | 6 | namespace flare 7 | { 8 | class ActorNode; 9 | 10 | class KeyFrameStrokeStart : public KeyFrameNumeric 11 | { 12 | protected: 13 | void setValue(ActorComponent* component, float value, float mix) override; 14 | }; 15 | } 16 | 17 | #endif -------------------------------------------------------------------------------- /flare/include/flare/animation/keyframes/keyframe_stroke_width.hpp: -------------------------------------------------------------------------------- 1 | #ifndef _FLARE_KEYFRAME_STROKE_WIDTH_HPP_ 2 | #define _FLARE_KEYFRAME_STROKE_WIDTH_HPP_ 3 | 4 | #include "keyframe_numeric.hpp" 5 | 6 | namespace flare 7 | { 8 | class ActorNode; 9 | 10 | class KeyFrameStrokeWidth : public KeyFrameNumeric 11 | { 12 | protected: 13 | void setValue(ActorComponent* component, float value, float mix) override; 14 | }; 15 | } 16 | 17 | #endif -------------------------------------------------------------------------------- /flare/include/flare/animation/keyframes/keyframe_corner_radius.hpp: -------------------------------------------------------------------------------- 1 | #ifndef _FLARE_KEYFRAME_CORNER_RADIUS_HPP_ 2 | #define _FLARE_KEYFRAME_CORNER_RADIUS_HPP_ 3 | 4 | #include "keyframe_numeric.hpp" 5 | 6 | namespace flare 7 | { 8 | class ActorNode; 9 | 10 | class KeyFrameCornerRadius : public KeyFrameNumeric 11 | { 12 | protected: 13 | void setValue(ActorComponent* component, float value, float mix) override; 14 | }; 15 | } 16 | 17 | #endif -------------------------------------------------------------------------------- /flare/include/flare/animation/keyframes/keyframe_paint_opacity.hpp: -------------------------------------------------------------------------------- 1 | #ifndef _FLARE_KEYFRAME_PAINT_OPACITY_HPP_ 2 | #define _FLARE_KEYFRAME_PAINT_OPACITY_HPP_ 3 | 4 | #include "keyframe_numeric.hpp" 5 | 6 | namespace flare 7 | { 8 | class ActorNode; 9 | 10 | class KeyFramePaintOpacity : public KeyFrameNumeric 11 | { 12 | protected: 13 | void setValue(ActorComponent* component, float value, float mix) override; 14 | }; 15 | } 16 | 17 | #endif -------------------------------------------------------------------------------- /flare/include/flare/animation/keyframes/keyframe_stroke_offset.hpp: -------------------------------------------------------------------------------- 1 | #ifndef _FLARE_KEYFRAME_STROKE_OFFSET_HPP_ 2 | #define _FLARE_KEYFRAME_STROKE_OFFSET_HPP_ 3 | 4 | #include "keyframe_numeric.hpp" 5 | 6 | namespace flare 7 | { 8 | class ActorNode; 9 | 10 | class KeyFrameStrokeOffset : public KeyFrameNumeric 11 | { 12 | protected: 13 | void setValue(ActorComponent* component, float value, float mix) override; 14 | }; 15 | } 16 | 17 | #endif -------------------------------------------------------------------------------- /flare_skia/src/skr_color_fill.cpp: -------------------------------------------------------------------------------- 1 | #include "flare_skia/skr_color_fill.hpp" 2 | #include "flare/actor_shape.hpp" 3 | #include "flare_skia/to_skia.hpp" 4 | 5 | using namespace flare; 6 | 7 | void SkrColorFill::updatePaint() 8 | { 9 | m_Paint.setBlendMode(ToSkia::convert(m_Shape->blendMode())); 10 | SkColor4f color{m_Color[0], m_Color[1], m_Color[2], m_Color[3] * m_RenderOpacity}; 11 | m_Paint.setColor4f(color, nullptr); 12 | onPaintUpdated(); 13 | } -------------------------------------------------------------------------------- /flare/src/animation/keyframes/keyframe_constraint_strength.cpp: -------------------------------------------------------------------------------- 1 | #include "flare/animation/keyframes/keyframe_constraint_strength.hpp" 2 | #include "flare/actor_constraint.hpp" 3 | 4 | using namespace flare; 5 | 6 | void KeyFrameConstraintStrength::setValue(ActorComponent* component, float value, float mix) 7 | { 8 | ActorConstraint* constraint = static_cast(component); 9 | constraint->strength(constraint->strength() * (1.0f - mix) + value * mix); 10 | } -------------------------------------------------------------------------------- /flare/include/flare/animation/keyframes/keyframe_constraint_strength.hpp: -------------------------------------------------------------------------------- 1 | #ifndef _FLARE_KEYFRAMECONSTRAINTSTRENGTH_HPP_ 2 | #define _FLARE_KEYFRAMECONSTRAINTSTRENGTH_HPP_ 3 | 4 | #include "keyframe_numeric.hpp" 5 | 6 | namespace flare 7 | { 8 | class ActorComponent; 9 | 10 | class KeyFrameConstraintStrength : public KeyFrameNumeric 11 | { 12 | protected: 13 | void setValue(ActorComponent* component, float value, float mix) override; 14 | }; 15 | } 16 | 17 | #endif -------------------------------------------------------------------------------- /flare_skia/include/flare_skia/skr_actor_path.hpp: -------------------------------------------------------------------------------- 1 | #ifndef _SKR_ACTOR_PATH_HPP_ 2 | #define _SKR_ACTOR_PATH_HPP_ 3 | 4 | #include "flare/path/actor_path.hpp" 5 | #include "skr_actor_base_path.hpp" 6 | 7 | namespace flare 8 | { 9 | 10 | class SkrActorPath : public ActorPath, public SkrActorBasePath 11 | { 12 | typedef ActorPath Base; 13 | 14 | public: 15 | SkrActorPath(); 16 | 17 | void invalidateDrawable() override; 18 | }; 19 | } // namespace flare 20 | 21 | #endif -------------------------------------------------------------------------------- /flare_skia/include/flare_skia/skr_actor_star.hpp: -------------------------------------------------------------------------------- 1 | #ifndef _SKR_ACTOR_STAR_HPP_ 2 | #define _SKR_ACTOR_STAR_HPP_ 3 | 4 | #include "flare/path/actor_star.hpp" 5 | #include "skr_actor_base_path.hpp" 6 | 7 | namespace flare 8 | { 9 | 10 | class SkrActorStar : public ActorStar, public SkrActorBasePath 11 | { 12 | typedef ActorStar Base; 13 | 14 | public: 15 | SkrActorStar(); 16 | 17 | void invalidateDrawable() override; 18 | }; 19 | } // namespace flare 20 | 21 | #endif -------------------------------------------------------------------------------- /flare/include/flare/actor_drawable_proxy.hpp: -------------------------------------------------------------------------------- 1 | #ifndef _FLARE_ACTOR_DRAWABLE_PROXY_HPP_ 2 | #define _FLARE_ACTOR_DRAWABLE_PROXY_HPP_ 3 | 4 | namespace flare 5 | { 6 | class ActorDrawable; 7 | class ActorDrawableProxy 8 | { 9 | private: 10 | ActorDrawable* m_Drawable; 11 | 12 | public: 13 | ActorDrawableProxy(ActorDrawable* drawable); 14 | virtual ~ActorDrawableProxy() {} 15 | ActorDrawable* drawable() const { return m_Drawable; } 16 | }; 17 | } // namespace flare 18 | #endif -------------------------------------------------------------------------------- /flare/include/flare/animation/keyframes/keyframe_sequence.hpp: -------------------------------------------------------------------------------- 1 | #ifndef _FLARE_KEYFRAMESEQUENCE_HPP_ 2 | #define _FLARE_KEYFRAMESEQUENCE_HPP_ 3 | 4 | #include "keyframe_numeric.hpp" 5 | 6 | namespace flare 7 | { 8 | class KeyFrameSequence : public KeyFrameNumeric 9 | { 10 | public: 11 | bool read(BlockReader* reader, ActorComponent* component) override; 12 | void setValue(ActorComponent* component, float value, float mix) override; 13 | }; 14 | } 15 | 16 | #endif -------------------------------------------------------------------------------- /flare_skia/include/flare_skia/skr_actor_ellipse.hpp: -------------------------------------------------------------------------------- 1 | #ifndef _SKR_ACTOR_ELLIPSE_HPP_ 2 | #define _SKR_ACTOR_ELLIPSE_HPP_ 3 | 4 | #include "flare/path/actor_ellipse.hpp" 5 | #include "skr_actor_base_path.hpp" 6 | 7 | namespace flare 8 | { 9 | 10 | class SkrActorEllipse : public ActorEllipse, public SkrActorBasePath 11 | { 12 | typedef ActorEllipse Base; 13 | 14 | public: 15 | SkrActorEllipse(); 16 | 17 | void invalidateDrawable() override; 18 | }; 19 | } // namespace flare 20 | 21 | #endif -------------------------------------------------------------------------------- /flare_skia/include/flare_skia/skr_actor_polygon.hpp: -------------------------------------------------------------------------------- 1 | #ifndef _SKR_ACTOR_POLYGON_HPP_ 2 | #define _SKR_ACTOR_POLYGON_HPP_ 3 | 4 | #include "flare/path/actor_polygon.hpp" 5 | #include "skr_actor_base_path.hpp" 6 | 7 | namespace flare 8 | { 9 | 10 | class SkrActorPolygon : public ActorPolygon, public SkrActorBasePath 11 | { 12 | typedef ActorPolygon Base; 13 | 14 | public: 15 | SkrActorPolygon(); 16 | 17 | void invalidateDrawable() override; 18 | }; 19 | } // namespace flare 20 | 21 | #endif -------------------------------------------------------------------------------- /flare_skia/include/flare_skia/skr_actor_artboard.hpp: -------------------------------------------------------------------------------- 1 | #ifndef _SKR_ACTOR_ARTBOARD_HPP_ 2 | #define _SKR_ACTOR_ARTBOARD_HPP_ 3 | 4 | #include "flare/actor_artboard.hpp" 5 | 6 | class SkCanvas; 7 | 8 | namespace flare 9 | { 10 | class SkrActor; 11 | class SkrActorArtboard : public ActorArtboard 12 | { 13 | typedef Actor Base; 14 | public: 15 | SkrActorArtboard(SkrActor* actor); 16 | void initializeGraphics(); 17 | void draw(SkCanvas* canvas); 18 | }; 19 | } // namespace flare 20 | #endif -------------------------------------------------------------------------------- /flare_skia/include/flare_skia/skr_actor_triangle.hpp: -------------------------------------------------------------------------------- 1 | #ifndef _SKR_ACTOR_TRIANGLE_HPP_ 2 | #define _SKR_ACTOR_TRIANGLE_HPP_ 3 | 4 | #include "flare/path/actor_triangle.hpp" 5 | #include "skr_actor_base_path.hpp" 6 | 7 | namespace flare 8 | { 9 | 10 | class SkrActorTriangle : public ActorTriangle, public SkrActorBasePath 11 | { 12 | typedef ActorTriangle Base; 13 | 14 | public: 15 | SkrActorTriangle(); 16 | 17 | void invalidateDrawable() override; 18 | }; 19 | } // namespace flare 20 | 21 | #endif -------------------------------------------------------------------------------- /flare_skia/include/flare_skia/skr_actor_rectangle.hpp: -------------------------------------------------------------------------------- 1 | #ifndef _SKR_ACTOR_RECTANGLE_HPP_ 2 | #define _SKR_ACTOR_RECTANGLE_HPP_ 3 | 4 | #include "flare/path/actor_rectangle.hpp" 5 | #include "skr_actor_base_path.hpp" 6 | 7 | namespace flare 8 | { 9 | 10 | class SkrActorRectangle : public ActorRectangle, public SkrActorBasePath 11 | { 12 | typedef ActorRectangle Base; 13 | 14 | public: 15 | SkrActorRectangle(); 16 | 17 | void invalidateDrawable() override; 18 | }; 19 | } // namespace flare 20 | 21 | #endif -------------------------------------------------------------------------------- /flare_skia/include/flare_skia/skr_color_fill.hpp: -------------------------------------------------------------------------------- 1 | #ifndef _SKR_COLOR_FILL_HPP_ 2 | #define _SKR_COLOR_FILL_HPP_ 3 | 4 | #include "flare/paint/actor_color_fill.hpp" 5 | #include "skr_fill.hpp" 6 | 7 | namespace flare 8 | { 9 | class SkrColorFill : public ActorColorFill, public SkrFill 10 | { 11 | typedef ActorColorFill Base; 12 | 13 | public: 14 | void initializeGraphics() override { SkrFill::initializeGraphics(); } 15 | void updatePaint() override; 16 | }; 17 | 18 | } // namespace flare 19 | 20 | #endif -------------------------------------------------------------------------------- /flare_skia/src/skr_color_stroke.cpp: -------------------------------------------------------------------------------- 1 | #include "flare_skia/skr_color_stroke.hpp" 2 | #include "flare/actor_shape.hpp" 3 | #include "flare_skia/to_skia.hpp" 4 | 5 | using namespace flare; 6 | 7 | void SkrColorStroke::updatePaint() 8 | { 9 | m_Paint.setBlendMode(ToSkia::convert(m_Shape->blendMode())); 10 | SkrStroke::updatePaint(); 11 | SkColor4f color{m_Color[0], m_Color[1], m_Color[2], m_Color[3] * m_RenderOpacity}; 12 | m_Paint.setColor4f(color, nullptr); 13 | 14 | 15 | onPaintUpdated(); 16 | } -------------------------------------------------------------------------------- /flare/include/flare/path/actor_ellipse.hpp: -------------------------------------------------------------------------------- 1 | #ifndef _FLARE_ACTORELLIPSE_HPP_ 2 | #define _FLARE_ACTORELLIPSE_HPP_ 3 | 4 | #include "actor_procedural_path.hpp" 5 | #include 6 | 7 | namespace flare 8 | { 9 | class ActorEllipse : public ActorProceduralPath 10 | { 11 | typedef ActorProceduralPath Base; 12 | 13 | public: 14 | ActorEllipse(); 15 | 16 | ActorComponent* makeInstance(ActorArtboard* artboard) const override; 17 | void makePoints() override; 18 | }; 19 | } // namespace flare 20 | #endif -------------------------------------------------------------------------------- /flare/include/flare/path/actor_triangle.hpp: -------------------------------------------------------------------------------- 1 | #ifndef _FLARE_ACTORTRIANGLE_HPP_ 2 | #define _FLARE_ACTORTRIANGLE_HPP_ 3 | 4 | #include "actor_procedural_path.hpp" 5 | #include 6 | 7 | namespace flare 8 | { 9 | class ActorTriangle : public ActorProceduralPath 10 | { 11 | typedef ActorProceduralPath Base; 12 | 13 | public: 14 | ActorTriangle(); 15 | 16 | ActorComponent* makeInstance(ActorArtboard* artboard) const override; 17 | void makePoints() override; 18 | }; 19 | } // namespace flare 20 | #endif -------------------------------------------------------------------------------- /flare/src/animation/keyframes/keyframe.cpp: -------------------------------------------------------------------------------- 1 | #include "flare/animation/keyframes/keyframe.hpp" 2 | #include "flare/block_reader.hpp" 3 | 4 | using namespace flare; 5 | 6 | KeyFrame::KeyFrame() : 7 | m_Time(0.0f) 8 | { 9 | 10 | } 11 | 12 | KeyFrame::~KeyFrame() 13 | { 14 | 15 | } 16 | 17 | float KeyFrame::time() const 18 | { 19 | return m_Time; 20 | } 21 | 22 | bool KeyFrame::read(BlockReader* reader, ActorComponent* component) 23 | { 24 | m_Time = (float)reader->readFloat64(); 25 | 26 | return true; 27 | } 28 | 29 | -------------------------------------------------------------------------------- /flare/src/animation/keyframes/keyframe_inner_radius.cpp: -------------------------------------------------------------------------------- 1 | #include "flare/animation/keyframes/keyframe_inner_radius.hpp" 2 | #include "flare/actor_component.hpp" 3 | #include "flare/path/actor_star.hpp" 4 | 5 | using namespace flare; 6 | 7 | void KeyFrameInnerRadius::setValue(ActorComponent* component, float value, float mix) 8 | { 9 | ActorStar* star = dynamic_cast(component); 10 | if (star == nullptr) 11 | { 12 | return; 13 | } 14 | star->innerRadius(star->innerRadius() * (1.0f - mix) + value * mix); 15 | } -------------------------------------------------------------------------------- /flare/src/animation/keyframes/keyframe_stroke_end.cpp: -------------------------------------------------------------------------------- 1 | #include "flare/animation/keyframes/keyframe_stroke_end.hpp" 2 | #include "flare/actor_component.hpp" 3 | #include "flare/paint/actor_stroke.hpp" 4 | 5 | using namespace flare; 6 | 7 | void KeyFrameStrokeEnd::setValue(ActorComponent* component, float value, float mix) 8 | { 9 | ActorStroke* stroke = dynamic_cast(component); 10 | if (stroke == nullptr) 11 | { 12 | return; 13 | } 14 | stroke->trimEnd(stroke->trimEnd() * (1.0f - mix) + value * mix); 15 | } -------------------------------------------------------------------------------- /flare/include/flare/exceptions/overflow_exception.hpp: -------------------------------------------------------------------------------- 1 | #ifndef _FLARE_OVERFLOWEXCEPTION_HPP_ 2 | #define _FLARE_OVERFLOWEXCEPTION_HPP_ 3 | 4 | #include 5 | #include 6 | 7 | namespace flare 8 | { 9 | class OverflowException : public std::exception 10 | { 11 | std::string m_Message; 12 | 13 | public: 14 | OverflowException(std::string msg) : m_Message(msg) 15 | { 16 | 17 | } 18 | 19 | const std::string message() const 20 | { 21 | return m_Message; 22 | } 23 | }; 24 | } 25 | #endif -------------------------------------------------------------------------------- /flare/src/animation/keyframes/keyframe_paint_opacity.cpp: -------------------------------------------------------------------------------- 1 | #include "flare/animation/keyframes/keyframe_paint_opacity.hpp" 2 | #include "flare/actor_component.hpp" 3 | #include "flare/paint/actor_paint.hpp" 4 | 5 | using namespace flare; 6 | 7 | void KeyFramePaintOpacity::setValue(ActorComponent* component, float value, float mix) 8 | { 9 | ActorPaint* stroke = dynamic_cast(component); 10 | if (stroke == nullptr) 11 | { 12 | return; 13 | } 14 | stroke->opacity(stroke->opacity() * (1.0f - mix) + value * mix); 15 | } -------------------------------------------------------------------------------- /flare/src/animation/keyframes/keyframe_stroke_width.cpp: -------------------------------------------------------------------------------- 1 | #include "flare/animation/keyframes/keyframe_stroke_width.hpp" 2 | #include "flare/actor_component.hpp" 3 | #include "flare/paint/actor_stroke.hpp" 4 | 5 | using namespace flare; 6 | 7 | void KeyFrameStrokeWidth::setValue(ActorComponent* component, float value, float mix) 8 | { 9 | ActorStroke* stroke = dynamic_cast(component); 10 | if (stroke == nullptr) 11 | { 12 | return; 13 | } 14 | stroke->width(stroke->width() * (1.0f - mix) + value * mix); 15 | } -------------------------------------------------------------------------------- /flare/src/animation/keyframes/keyframe_stroke_start.cpp: -------------------------------------------------------------------------------- 1 | #include "flare/animation/keyframes/keyframe_stroke_start.hpp" 2 | #include "flare/actor_component.hpp" 3 | #include "flare/paint/actor_stroke.hpp" 4 | 5 | using namespace flare; 6 | 7 | void KeyFrameStrokeStart::setValue(ActorComponent* component, float value, float mix) 8 | { 9 | ActorStroke* stroke = dynamic_cast(component); 10 | if (stroke == nullptr) 11 | { 12 | return; 13 | } 14 | stroke->trimStart(stroke->trimStart() * (1.0f - mix) + value * mix); 15 | } -------------------------------------------------------------------------------- /flare_skia/include/flare_skia/skr_color_stroke.hpp: -------------------------------------------------------------------------------- 1 | #ifndef _SKR_COLOR_STROKE_HPP_ 2 | #define _SKR_COLOR_STROKE_HPP_ 3 | 4 | #include "flare/paint/actor_color_stroke.hpp" 5 | #include "skr_stroke.hpp" 6 | 7 | namespace flare 8 | { 9 | class SkrColorStroke : public ActorColorStroke, public SkrStroke 10 | { 11 | typedef ActorColorStroke Base; 12 | 13 | public: 14 | void initializeGraphics() override { SkrStroke::initializeGraphics(); } 15 | void updatePaint() override; 16 | }; 17 | 18 | } // namespace flare 19 | 20 | #endif -------------------------------------------------------------------------------- /flare.code-workspace: -------------------------------------------------------------------------------- 1 | { 2 | "folders": [ 3 | { 4 | "path": "flare_skia" 5 | }, 6 | { 7 | "path": "flare" 8 | }, 9 | { 10 | "path": "flare_math" 11 | }, 12 | { 13 | "path": "test" 14 | }, 15 | { 16 | "path": "example" 17 | }, 18 | { 19 | "path": "." 20 | } 21 | ], 22 | "settings": { 23 | "cquery.cacheDirectory": "${workspaceFolder}/.vscode/cquery_cached_index/", 24 | "files.exclude": { 25 | "**/cquery_cached_index": true, 26 | "**/*.d": true, 27 | "**/*.o": true 28 | } 29 | } 30 | } -------------------------------------------------------------------------------- /flare/src/animation/keyframes/keyframe_shape_width.cpp: -------------------------------------------------------------------------------- 1 | #include "flare/animation/keyframes/keyframe_shape_width.hpp" 2 | #include "flare/actor_component.hpp" 3 | #include "flare/path/actor_procedural_path.hpp" 4 | 5 | using namespace flare; 6 | 7 | void KeyFrameShapeWidth::setValue(ActorComponent* component, float value, float mix) 8 | { 9 | ActorProceduralPath* path = dynamic_cast(component); 10 | if (path == nullptr) 11 | { 12 | return; 13 | } 14 | path->width(path->width() * (1.0f - mix) + value * mix); 15 | } -------------------------------------------------------------------------------- /flare/src/animation/keyframes/keyframe_stroke_offset.cpp: -------------------------------------------------------------------------------- 1 | #include "flare/animation/keyframes/keyframe_stroke_offset.hpp" 2 | #include "flare/actor_component.hpp" 3 | #include "flare/paint/actor_stroke.hpp" 4 | 5 | using namespace flare; 6 | 7 | void KeyFrameStrokeOffset::setValue(ActorComponent* component, float value, float mix) 8 | { 9 | ActorStroke* stroke = dynamic_cast(component); 10 | if (stroke == nullptr) 11 | { 12 | return; 13 | } 14 | stroke->trimOffset(stroke->trimOffset() * (1.0f - mix) + value * mix); 15 | } -------------------------------------------------------------------------------- /flare/src/animation/keyframes/keyframe_shape_height.cpp: -------------------------------------------------------------------------------- 1 | #include "flare/animation/keyframes/keyframe_shape_height.hpp" 2 | #include "flare/actor_component.hpp" 3 | #include "flare/path/actor_procedural_path.hpp" 4 | 5 | using namespace flare; 6 | 7 | void KeyFrameShapeHeight::setValue(ActorComponent* component, float value, float mix) 8 | { 9 | ActorProceduralPath* path = dynamic_cast(component); 10 | if (path == nullptr) 11 | { 12 | return; 13 | } 14 | path->height(path->height() * (1.0f - mix) + value * mix); 15 | } -------------------------------------------------------------------------------- /flare/src/animation/interpolators/cubic_interpolator.cpp: -------------------------------------------------------------------------------- 1 | #include "flare/animation/interpolators/cubic_interpolator.hpp" 2 | 3 | using namespace flare; 4 | 5 | bool CubicInterpolator::read(BlockReader* reader) 6 | { 7 | float x1 = reader->readFloat32(); 8 | float y1 = reader->readFloat32(); 9 | float x2 = reader->readFloat32(); 10 | float y2 = reader->readFloat32(); 11 | if(x1 == y1 && x2 == y2) 12 | { 13 | // we're linear 14 | return false; 15 | } 16 | initialize(x1, y1, x2, y2); 17 | return true; 18 | } -------------------------------------------------------------------------------- /flare/src/animation/keyframes/keyframe_corner_radius.cpp: -------------------------------------------------------------------------------- 1 | #include "flare/animation/keyframes/keyframe_corner_radius.hpp" 2 | #include "flare/actor_component.hpp" 3 | #include "flare/path/actor_rectangle.hpp" 4 | 5 | using namespace flare; 6 | 7 | void KeyFrameCornerRadius::setValue(ActorComponent* component, float value, float mix) 8 | { 9 | ActorRectangle* rectangle = dynamic_cast(component); 10 | if (rectangle == nullptr) 11 | { 12 | return; 13 | } 14 | rectangle->radius(rectangle->radius() * (1.0f - mix) + value * mix); 15 | } -------------------------------------------------------------------------------- /flare_skia/include/flare_skia/skr_fill.hpp: -------------------------------------------------------------------------------- 1 | #ifndef _SKR_FILL_HPP_ 2 | #define _SKR_FILL_HPP_ 3 | 4 | #include "SkCanvas.h" 5 | #include "SkPaint.h" 6 | #include "SkPath.h" 7 | #include "flare/paint/actor_fill.hpp" 8 | 9 | namespace flare 10 | { 11 | class SkrFill 12 | { 13 | protected: 14 | SkPaint m_Paint; 15 | ActorFill* m_ActorFill; 16 | 17 | public: 18 | void initializeGraphics(); 19 | virtual void onPaintUpdated() {} 20 | void updatePaint(); 21 | void paint(SkCanvas* canvas, SkPath& path); 22 | }; 23 | } // namespace flare 24 | #endif -------------------------------------------------------------------------------- /flare/include/flare/animation/interpolators/cubic_interpolator.hpp: -------------------------------------------------------------------------------- 1 | #ifndef _FLARE_CUBIC_INTERPOLATOR_HPP_ 2 | #define _FLARE_CUBIC_INTERPOLATOR_HPP_ 3 | 4 | #include "keyframe_interpolator.hpp" 5 | #include "flare/block_reader.hpp" 6 | #include "cubic_ease.hpp" 7 | 8 | namespace flare 9 | { 10 | class CubicInterpolator : public KeyFrameInterpolator, public CubicEase 11 | { 12 | public: 13 | float getEasedMix(float mix) const override { return ease(mix); } 14 | bool read(BlockReader* reader); 15 | }; 16 | } // namespace flare 17 | 18 | #endif 19 | -------------------------------------------------------------------------------- /flare_math/build/flare_math.lua: -------------------------------------------------------------------------------- 1 | project "flare_math" 2 | kind "StaticLib" 3 | language "C++" 4 | 5 | configuration { "Debug" } 6 | targetdir "./debug/lib" 7 | objdir "./debug/obj" 8 | 9 | configuration { "Release" } 10 | targetdir "./release/lib" 11 | objdir "./release/obj" 12 | 13 | configuration { } 14 | 15 | includedirs 16 | { 17 | "../include" 18 | } 19 | 20 | buildoptions_cpp 21 | { 22 | "-std=c++11", 23 | "-fembed-bitcode" 24 | } 25 | 26 | files 27 | { 28 | "../src/**.cpp" 29 | } 30 | 31 | targetname "flare_math" -------------------------------------------------------------------------------- /flare_skia/include/flare_skia/skr_drawable_proxy.hpp: -------------------------------------------------------------------------------- 1 | #ifndef _SKR_DRAWABLE_PROXY_HPP_ 2 | #define _SKR_DRAWABLE_PROXY_HPP_ 3 | 4 | #include "flare/actor_drawable_proxy.hpp" 5 | 6 | namespace flare 7 | { 8 | class SkrDrawable; 9 | 10 | class SkrDrawableProxy : public ActorDrawableProxy 11 | { 12 | typedef ActorDrawableProxy Base; 13 | 14 | SkrDrawable* m_SkrDrawable; 15 | public: 16 | SkrDrawableProxy(ActorDrawable* drawable); 17 | SkrDrawable* skrDrawable() const { return m_SkrDrawable; } 18 | }; 19 | } // namespace flare 20 | #endif -------------------------------------------------------------------------------- /flare/build/flare.lua: -------------------------------------------------------------------------------- 1 | project "flare" 2 | kind "StaticLib" 3 | language "C++" 4 | 5 | configuration { "Debug" } 6 | targetdir "./debug/lib" 7 | objdir "./debug/obj" 8 | 9 | configuration { "Release" } 10 | targetdir "./release/lib" 11 | objdir "./release/obj" 12 | 13 | configuration { } 14 | 15 | includedirs 16 | { 17 | "../include", 18 | "../../flare_math/include" 19 | } 20 | 21 | buildoptions_cpp 22 | { 23 | "-std=c++11", 24 | "-fembed-bitcode" 25 | } 26 | 27 | files 28 | { 29 | "../src/**.cpp" 30 | } 31 | 32 | targetname "flare" -------------------------------------------------------------------------------- /flare/src/paint/actor_fill.cpp: -------------------------------------------------------------------------------- 1 | #include "flare/paint/actor_fill.hpp" 2 | #include "flare/actor_artboard.hpp" 3 | #include "flare/block_reader.hpp" 4 | 5 | using namespace flare; 6 | 7 | ActorFill::ActorFill() : m_FillRule(FillRule::EvenOdd) {} 8 | 9 | void ActorFill::copy(const ActorFill* fill, ActorArtboard* artboard) 10 | { 11 | m_FillRule = fill->m_FillRule; 12 | } 13 | 14 | ActorFill* ActorFill::read(ActorArtboard* artboard, BlockReader* reader, ActorFill* component) 15 | { 16 | component->m_FillRule = (FillRule)reader->readUint8(); 17 | return component; 18 | } -------------------------------------------------------------------------------- /flare_skia/include/flare_skia/skr_drawable.hpp: -------------------------------------------------------------------------------- 1 | #ifndef _SKR_DRAWABLE_HPP_ 2 | #define _SKR_DRAWABLE_HPP_ 3 | 4 | class SkCanvas; 5 | 6 | #include 7 | 8 | namespace flare 9 | { 10 | class ActorNode; 11 | class SkrActorShape; 12 | class SkrDrawable 13 | { 14 | std::vector> m_ClippingShapes; 15 | 16 | public: 17 | virtual void draw(SkCanvas* canvas) = 0; 18 | void updateClips(ActorNode* node); 19 | 20 | const std::vector>& clippingShapes() const { return m_ClippingShapes; } 21 | }; 22 | } // namespace flare 23 | #endif -------------------------------------------------------------------------------- /flare/include/flare/actor_jelly_bone.hpp: -------------------------------------------------------------------------------- 1 | #ifndef _FLARE_ACTORJELLYBONE_HPP_ 2 | #define _FLARE_ACTORJELLYBONE_HPP_ 3 | 4 | #include "actor_bone_base.hpp" 5 | 6 | namespace flare 7 | { 8 | class Actor; 9 | class BlockReader; 10 | 11 | class ActorJellyBone : public ActorBoneBase 12 | { 13 | typedef ActorBoneBase Base; 14 | 15 | public: 16 | ActorJellyBone(); 17 | ActorComponent* makeInstance(ActorArtboard* artboard) const override; 18 | static ActorJellyBone* read(ActorArtboard* artboard, BlockReader* reader, ActorJellyBone* node = nullptr); 19 | }; 20 | } // namespace flare 21 | #endif -------------------------------------------------------------------------------- /flare/src/nested_actor_asset.cpp: -------------------------------------------------------------------------------- 1 | #include "flare/nested_actor_asset.hpp" 2 | #include "flare/block_reader.hpp" 3 | 4 | using namespace flare; 5 | 6 | NestedActorAsset::NestedActorAsset() {} 7 | 8 | NestedActorAsset::~NestedActorAsset() {} 9 | 10 | const std::string& NestedActorAsset::name() const { return m_Name; } 11 | 12 | const std::string& NestedActorAsset::id() const { return m_Id; } 13 | 14 | void NestedActorAsset::read(BlockReader* reader) 15 | { 16 | m_Name = reader->readString(); 17 | m_Id = reader->readString(); 18 | } 19 | 20 | Actor* NestedActorAsset::actor() { return nullptr; } -------------------------------------------------------------------------------- /flare_skia/include/flare_skia/skr_gradient_fill.hpp: -------------------------------------------------------------------------------- 1 | #ifndef _SKR_GRADIENT_FILL_HPP_ 2 | #define _SKR_GRADIENT_FILL_HPP_ 3 | 4 | #include "flare/paint/actor_gradient_fill.hpp" 5 | #include "skr_fill.hpp" 6 | 7 | namespace flare 8 | { 9 | class BlockReader; 10 | class ActorArtboard; 11 | 12 | class SkrGradientFill : public ActorGradientFill, public SkrFill 13 | { 14 | typedef ActorGradientFill Base; 15 | 16 | public: 17 | void initializeGraphics() override { SkrFill::initializeGraphics(); } 18 | void updatePaint() override; 19 | }; 20 | } // namespace flare 21 | 22 | #endif -------------------------------------------------------------------------------- /flare_skia/include/flare_skia/skr_gradient_stroke.hpp: -------------------------------------------------------------------------------- 1 | #ifndef _SKR_GRADIENT_STROKE_HPP_ 2 | #define _SKR_GRADIENT_STROKE_HPP_ 3 | 4 | #include "flare/paint/actor_gradient_stroke.hpp" 5 | #include "skr_stroke.hpp" 6 | 7 | namespace flare 8 | { 9 | class BlockReader; 10 | class ActorArtboard; 11 | 12 | class SkrGradientStroke : public ActorGradientStroke, public SkrStroke 13 | { 14 | typedef ActorGradientStroke Base; 15 | 16 | public: 17 | void initializeGraphics() override { SkrStroke::initializeGraphics(); } 18 | void updatePaint() override; 19 | }; 20 | } // namespace flare 21 | 22 | #endif -------------------------------------------------------------------------------- /flare_skia/include/flare_skia/skr_stroke.hpp: -------------------------------------------------------------------------------- 1 | #ifndef _SKR_STROKE_HPP_ 2 | #define _SKR_STROKE_HPP_ 3 | 4 | #include "SkCanvas.h" 5 | #include "SkPaint.h" 6 | #include "SkPath.h" 7 | #include "flare/paint/actor_stroke.hpp" 8 | 9 | namespace flare 10 | { 11 | class SkrStroke 12 | { 13 | protected: 14 | SkPaint m_Paint; 15 | SkPath* m_EffectPath; 16 | ActorStroke* m_ActorStroke; 17 | 18 | public: 19 | void initializeGraphics(); 20 | virtual void onPaintUpdated() {} 21 | void updatePaint(); 22 | void paint(SkCanvas* canvas, SkPath& path); 23 | }; 24 | } // namespace flare 25 | #endif -------------------------------------------------------------------------------- /flare/include/flare/dependency_sorter.hpp: -------------------------------------------------------------------------------- 1 | #ifndef _FLARE_DEPENDENCYSORTER_HPP_ 2 | #define _FLARE_DEPENDENCYSORTER_HPP_ 3 | 4 | #include "actor_component.hpp" 5 | #include 6 | #include 7 | 8 | namespace flare 9 | { 10 | class DependencySorter 11 | { 12 | private: 13 | std::unordered_set m_Perm; 14 | std::unordered_set m_Temp; 15 | 16 | public: 17 | void sort(ActorComponent* root, std::vector& order); 18 | bool visit(ActorComponent* component, std::vector& order); 19 | }; 20 | } // namespace flare 21 | 22 | #endif -------------------------------------------------------------------------------- /flare/include/flare/actor_event.hpp: -------------------------------------------------------------------------------- 1 | #ifndef _FLARE_ACTOREVENT_HPP_ 2 | #define _FLARE_ACTOREVENT_HPP_ 3 | 4 | #include "actor_component.hpp" 5 | #include 6 | 7 | namespace flare 8 | { 9 | class ActorEvent : public ActorComponent 10 | { 11 | typedef ActorComponent Base; 12 | 13 | public: 14 | ActorEvent(); 15 | ActorComponent* makeInstance(ActorArtboard* artboard) const override; 16 | void copy(const ActorComponent* node, ActorArtboard* artboard); 17 | 18 | static ActorEvent* read(ActorArtboard* artboard, BlockReader* reader, ActorEvent* component = NULL); 19 | }; 20 | } // namespace flare 21 | #endif -------------------------------------------------------------------------------- /flare/include/flare/actor_root_bone.hpp: -------------------------------------------------------------------------------- 1 | #ifndef _FLARE_ACTORROOTBONE_HPP_ 2 | #define _FLARE_ACTORROOTBONE_HPP_ 3 | 4 | #include "actor_node.hpp" 5 | 6 | namespace flare 7 | { 8 | class Actor; 9 | class BlockReader; 10 | class ActorNode; 11 | 12 | class ActorRootBone : public ActorNode 13 | { 14 | public: 15 | ActorRootBone(); 16 | ActorNode* makeInstance(ActorArtboard* artboard) const; 17 | void copy(const ActorRootBone* node, ActorArtboard* artboard); 18 | 19 | static ActorRootBone* read(ActorArtboard* artboard, BlockReader* reader, ActorRootBone* node = NULL); 20 | }; 21 | } // namespace flare 22 | #endif -------------------------------------------------------------------------------- /flare/include/flare/animation/interpolators/hold_interpolator.hpp: -------------------------------------------------------------------------------- 1 | #ifndef _FLARE_HOLD_INTERPOLATOR_HPP_ 2 | #define _FLARE_HOLD_INTERPOLATOR_HPP_ 3 | 4 | #include "keyframe_interpolator.hpp" 5 | 6 | namespace flare 7 | { 8 | class HoldInterpolator : public KeyFrameInterpolator 9 | { 10 | public: 11 | float getEasedMix(float mix) const override { 12 | return 0.0; 13 | } 14 | static const HoldInterpolator* instance() 15 | { 16 | static HoldInterpolator interpolator; 17 | return &interpolator; 18 | } 19 | }; 20 | } // namespace flare 21 | 22 | #endif 23 | -------------------------------------------------------------------------------- /flare_skia/include/flare_skia/skr_radial_gradient_fill.hpp: -------------------------------------------------------------------------------- 1 | #ifndef _SKR_RADIAL_GRADIENT_FILL_HPP_ 2 | #define _SKR_RADIAL_GRADIENT_FILL_HPP_ 3 | 4 | #include "flare/paint/actor_radial_gradient_fill.hpp" 5 | #include "skr_fill.hpp" 6 | 7 | namespace flare 8 | { 9 | class BlockReader; 10 | class ActorArtboard; 11 | 12 | class SkrRadialGradientFill : public ActorRadialGradientFill, public SkrFill 13 | { 14 | typedef ActorRadialGradientFill Base; 15 | 16 | public: 17 | void initializeGraphics() override { SkrFill::initializeGraphics(); } 18 | void updatePaint() override; 19 | }; 20 | } // namespace flare 21 | 22 | #endif -------------------------------------------------------------------------------- /flare/include/flare/animation/interpolators/linear_interpolator.hpp: -------------------------------------------------------------------------------- 1 | #ifndef _FLARE_LINEAR_INTERPOLATOR_HPP_ 2 | #define _FLARE_LINEAR_INTERPOLATOR_HPP_ 3 | 4 | #include "keyframe_interpolator.hpp" 5 | 6 | namespace flare 7 | { 8 | class LinearInterpolator : public KeyFrameInterpolator 9 | { 10 | public: 11 | float getEasedMix(float mix) const override { 12 | return mix; 13 | } 14 | static const LinearInterpolator* instance() 15 | { 16 | static LinearInterpolator interpolator; 17 | return &interpolator; 18 | } 19 | }; 20 | } // namespace flare 21 | 22 | #endif 23 | -------------------------------------------------------------------------------- /flare_skia/include/flare_skia/skr_actor_base_path.hpp: -------------------------------------------------------------------------------- 1 | #ifndef _SKR_ACTOR_BASE_PATH_HPP_ 2 | #define _SKR_ACTOR_BASE_PATH_HPP_ 3 | 4 | #include "SkPath.h" 5 | 6 | class SkPath; 7 | 8 | namespace flare 9 | { 10 | class ActorBasePath; 11 | 12 | class SkrActorBasePath 13 | { 14 | SkPath m_Path; 15 | ActorBasePath* m_BasePath; 16 | 17 | protected: 18 | bool m_IsPathValid; 19 | 20 | private: 21 | void updatePath(); 22 | 23 | protected: 24 | SkrActorBasePath(ActorBasePath* path); 25 | 26 | public: 27 | const SkPath& path(); 28 | ActorBasePath* basePath() const { return m_BasePath; } 29 | }; 30 | } // namespace flare 31 | 32 | #endif -------------------------------------------------------------------------------- /flare/include/flare/nested_actor_asset.hpp: -------------------------------------------------------------------------------- 1 | #ifndef _FLARE_NESTEDACTORASSET_HPP_ 2 | #define _FLARE_NESTEDACTORASSET_HPP_ 3 | 4 | #include 5 | #include 6 | #include 7 | 8 | namespace flare 9 | { 10 | class BlockReader; 11 | class Actor; 12 | 13 | class NestedActorAsset 14 | { 15 | protected: 16 | std::string m_Name; 17 | std::string m_Id; 18 | 19 | public: 20 | NestedActorAsset(); 21 | virtual ~NestedActorAsset(); 22 | 23 | const std::string& name() const; 24 | const std::string& id() const; 25 | 26 | virtual Actor* actor(); 27 | void read(BlockReader* reader); 28 | }; 29 | } //namespace flare 30 | #endif -------------------------------------------------------------------------------- /flare_skia/include/flare_skia/skr_radial_gradient_stroke.hpp: -------------------------------------------------------------------------------- 1 | #ifndef _SKR_RADIAL_GRADIENT_STROKE_HPP_ 2 | #define _SKR_RADIAL_GRADIENT_STROKE_HPP_ 3 | 4 | #include "flare/paint/actor_radial_gradient_stroke.hpp" 5 | #include "skr_stroke.hpp" 6 | 7 | namespace flare 8 | { 9 | class BlockReader; 10 | class ActorArtboard; 11 | 12 | class SkrRadialGradientStroke : public ActorRadialGradientStroke, public SkrStroke 13 | { 14 | typedef ActorRadialGradientStroke Base; 15 | 16 | public: 17 | void initializeGraphics() override { SkrStroke::initializeGraphics(); } 18 | void updatePaint() override; 19 | }; 20 | } // namespace flare 21 | 22 | #endif -------------------------------------------------------------------------------- /test/src/main.cpp: -------------------------------------------------------------------------------- 1 | #include "flare/actor.hpp" 2 | #include "flare/exceptions/overflow_exception.hpp" 3 | #include "flare/exceptions/unsupported_version_exception.hpp" 4 | #include 5 | 6 | int main() 7 | { 8 | flare::Actor* actor = new flare::Actor(); 9 | 10 | try 11 | { 12 | actor->load("assets/Filip.flr"); 13 | } 14 | catch (flare::OverflowException ex) 15 | { 16 | printf("Bad data, got an overflow. %s\n", ex.message().c_str()); 17 | } 18 | catch (flare::UnsupportedVersionException ex) 19 | { 20 | printf("Unsupported version. %d %d\n", ex.versionFound(), ex.versionRequired()); 21 | } 22 | printf("Loaded ok.\n"); 23 | return 0; 24 | } -------------------------------------------------------------------------------- /flare/include/flare/animation/interpolators/cubic_solver.hpp: -------------------------------------------------------------------------------- 1 | #ifndef _FLARE_CUBICSOLVER_HPP_ 2 | #define _FLARE_CUBICSOLVER_HPP_ 3 | 4 | namespace flare 5 | { 6 | class BlockReader; 7 | class ActorNode; 8 | 9 | class CubicSolver 10 | { 11 | private: 12 | float m_X0; 13 | float m_Y0; 14 | 15 | float m_X1; 16 | float m_Y1; 17 | 18 | float m_X2; 19 | float m_Y2; 20 | 21 | float m_X3; 22 | float m_Y3; 23 | 24 | float m_E; 25 | float m_F; 26 | float m_G; 27 | float m_H; 28 | 29 | public: 30 | CubicSolver(); 31 | void set(float x0, float y0, float x1, float y1, float x2, float y2, float x3, float y3); 32 | float get(float x); 33 | 34 | }; 35 | } 36 | #endif -------------------------------------------------------------------------------- /flare/include/flare/exceptions/missing_file_exception.hpp: -------------------------------------------------------------------------------- 1 | #ifndef _FLARE_MISSINGFILEEXCEPTION_HPP_ 2 | #define _FLARE_MISSINGFILEEXCEPTION_HPP_ 3 | 4 | #include 5 | #include 6 | 7 | namespace flare 8 | { 9 | class MissingFileException : public std::exception 10 | { 11 | std::string m_Message; 12 | std::string m_Filename; 13 | public: 14 | MissingFileException(const std::string& msg, const std::string& filename) : m_Message(msg), m_Filename(filename) 15 | { 16 | 17 | } 18 | 19 | const std::string& message() const 20 | { 21 | return m_Message; 22 | } 23 | 24 | const std::string& filename() const 25 | { 26 | return m_Filename; 27 | } 28 | }; 29 | } 30 | #endif -------------------------------------------------------------------------------- /flare/include/flare/animation/keyframes/keyframe_trigger.hpp: -------------------------------------------------------------------------------- 1 | #ifndef _FLARE_KEYFRAMETRIGGER_HPP_ 2 | #define _FLARE_KEYFRAMETRIGGER_HPP_ 3 | 4 | #include "keyframe.hpp" 5 | 6 | namespace flare 7 | { 8 | class ActorComponent; 9 | 10 | class KeyFrameTrigger : public KeyFrame 11 | { 12 | typedef KeyFrame Base; 13 | 14 | public: 15 | KeyFrameTrigger(); 16 | virtual ~KeyFrameTrigger(); 17 | 18 | bool read(BlockReader* reader, ActorComponent* component) override; 19 | void setNext(KeyFrame* frame) override; 20 | void apply(ActorComponent* component, float mix) override; 21 | void applyInterpolation(ActorComponent* component, float time, KeyFrame* toFrame, float mix) override; 22 | }; 23 | } 24 | 25 | #endif -------------------------------------------------------------------------------- /flare_skia/src/skr_actor_artboard.cpp: -------------------------------------------------------------------------------- 1 | #include "flare_skia/skr_actor_artboard.hpp" 2 | #include "flare_skia/skr_actor.hpp" 3 | #include "flare_skia/skr_drawable.hpp" 4 | #include "flare_skia/skr_drawable_proxy.hpp" 5 | 6 | using namespace flare; 7 | 8 | SkrActorArtboard::SkrActorArtboard(SkrActor* actor) : ActorArtboard(actor) {} 9 | 10 | void SkrActorArtboard::initializeGraphics() 11 | { 12 | for (int i = 0; i < m_DrawableCount; i++) 13 | { 14 | m_Drawables[i]->drawable()->initializeGraphics(); 15 | } 16 | } 17 | 18 | void SkrActorArtboard::draw(SkCanvas* canvas) 19 | { 20 | for (int i = 0; i < m_DrawableCount; i++) 21 | { 22 | reinterpret_cast(m_Drawables[i])->skrDrawable()->draw(canvas); 23 | } 24 | } -------------------------------------------------------------------------------- /example/.vscode/c_cpp_properties.json: -------------------------------------------------------------------------------- 1 | { 2 | "configurations": [ 3 | { 4 | "name": "Mac", 5 | "includePath": [ 6 | "${workspaceFolder}/**" 7 | ], 8 | "defines": [], 9 | "macFrameworkPath": [ 10 | "/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.14.sdk/System/Library/Frameworks" 11 | ], 12 | "compilerPath": "/usr/bin/clang", 13 | "cStandard": "c11", 14 | "cppStandard": "c++17", 15 | "intelliSenseMode": "clang-x64", 16 | "compileCommands": "${workspaceFolder}/compile_commands.json" 17 | } 18 | ], 19 | "version": 4 20 | } -------------------------------------------------------------------------------- /flare/.vscode/c_cpp_properties.json: -------------------------------------------------------------------------------- 1 | { 2 | "configurations": [ 3 | { 4 | "name": "Mac", 5 | "includePath": [ 6 | "${workspaceFolder}/**" 7 | ], 8 | "defines": [], 9 | "macFrameworkPath": [ 10 | "/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.14.sdk/System/Library/Frameworks" 11 | ], 12 | "compilerPath": "/usr/bin/clang", 13 | "cStandard": "c11", 14 | "cppStandard": "c++17", 15 | "intelliSenseMode": "clang-x64", 16 | "compileCommands": "${workspaceFolder}/compile_commands.json" 17 | } 18 | ], 19 | "version": 4 20 | } -------------------------------------------------------------------------------- /test/.vscode/c_cpp_properties.json: -------------------------------------------------------------------------------- 1 | { 2 | "configurations": [ 3 | { 4 | "name": "Mac", 5 | "includePath": [ 6 | "${workspaceFolder}/**" 7 | ], 8 | "defines": [], 9 | "macFrameworkPath": [ 10 | "/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.14.sdk/System/Library/Frameworks" 11 | ], 12 | "compilerPath": "/usr/bin/clang", 13 | "cStandard": "c11", 14 | "cppStandard": "c++17", 15 | "intelliSenseMode": "clang-x64", 16 | "compileCommands": "${workspaceFolder}/compile_commands.json" 17 | } 18 | ], 19 | "version": 4 20 | } -------------------------------------------------------------------------------- /flare/include/flare/actor_bone.hpp: -------------------------------------------------------------------------------- 1 | #ifndef _FLARE_ACTORBONE_HPP_ 2 | #define _FLARE_ACTORBONE_HPP_ 3 | 4 | #include "actor_bone_base.hpp" 5 | 6 | namespace flare 7 | { 8 | class Actor; 9 | class BlockReader; 10 | class JellyComponent; 11 | 12 | class ActorBone : public ActorBoneBase 13 | { 14 | typedef ActorBoneBase Base; 15 | friend class JellyComponent; 16 | 17 | protected: 18 | ActorBone* m_FirstBone; 19 | JellyComponent* m_Jelly; 20 | 21 | public: 22 | ActorBone(); 23 | ActorComponent* makeInstance(ActorArtboard* artboard) const override; 24 | void completeResolve() override; 25 | static ActorBone* read(ActorArtboard* artboard, BlockReader* reader, ActorBone* node = nullptr); 26 | }; 27 | } // namespace flare 28 | #endif -------------------------------------------------------------------------------- /flare_math/.vscode/c_cpp_properties.json: -------------------------------------------------------------------------------- 1 | { 2 | "configurations": [ 3 | { 4 | "name": "Mac", 5 | "includePath": [ 6 | "${workspaceFolder}/**" 7 | ], 8 | "defines": [], 9 | "macFrameworkPath": [ 10 | "/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.14.sdk/System/Library/Frameworks" 11 | ], 12 | "compilerPath": "/usr/bin/clang", 13 | "cStandard": "c11", 14 | "cppStandard": "c++17", 15 | "intelliSenseMode": "clang-x64", 16 | "compileCommands": "${workspaceFolder}/compile_commands.json" 17 | } 18 | ], 19 | "version": 4 20 | } -------------------------------------------------------------------------------- /flare/include/flare/actor_translation_constraint.hpp: -------------------------------------------------------------------------------- 1 | #ifndef _FLARE_ACTORTRANSLATIONCONSTRAINT_HPP_ 2 | #define _FLARE_ACTORTRANSLATIONCONSTRAINT_HPP_ 3 | 4 | #include "actor_axis_constraint.hpp" 5 | 6 | namespace flare 7 | { 8 | class ActorTranslationConstraint : public ActorAxisConstraint 9 | { 10 | typedef ActorAxisConstraint Base; 11 | 12 | public: 13 | ActorTranslationConstraint(); 14 | ActorComponent* makeInstance(ActorArtboard* resetActor) const override; 15 | static ActorTranslationConstraint* read(ActorArtboard* actor, BlockReader* reader, 16 | ActorTranslationConstraint* constraint = nullptr); 17 | void constrain(ActorNode* node) override; 18 | }; 19 | } //namespace flare 20 | 21 | #endif -------------------------------------------------------------------------------- /flare_skia/src/skr_fill.cpp: -------------------------------------------------------------------------------- 1 | #include "flare_skia/skr_fill.hpp" 2 | 3 | using namespace flare; 4 | 5 | void SkrFill::initializeGraphics() 6 | { 7 | m_ActorFill = dynamic_cast(this); 8 | assert(m_ActorFill != nullptr); 9 | 10 | m_Paint.setStyle(SkPaint::Style::kFill_Style); 11 | m_Paint.setAntiAlias(true); 12 | onPaintUpdated(); 13 | } 14 | 15 | void SkrFill::paint(SkCanvas* canvas, SkPath& path) 16 | { 17 | m_ActorFill->validatePaint(); 18 | switch (m_ActorFill->fillRule()) 19 | { 20 | case FillRule::EvenOdd: 21 | path.setFillType(SkPath::FillType::kEvenOdd_FillType); 22 | break; 23 | case FillRule::NonZero: 24 | path.setFillType(SkPath::FillType::kWinding_FillType); 25 | break; 26 | } 27 | canvas->drawPath(path, m_Paint); 28 | } -------------------------------------------------------------------------------- /flare/include/flare/paint/actor_fill.hpp: -------------------------------------------------------------------------------- 1 | #ifndef _FLARE_ACTOR_FILL_HPP_ 2 | #define _FLARE_ACTOR_FILL_HPP_ 3 | 4 | #include "flare/paint/fill_rule.hpp" 5 | 6 | namespace flare 7 | { 8 | class BlockReader; 9 | class ActorArtboard; 10 | 11 | class ActorFill 12 | { 13 | private: 14 | FillRule m_FillRule; 15 | 16 | protected: 17 | ActorFill(); 18 | 19 | public: 20 | FillRule fillRule() const { return m_FillRule; } 21 | void copy(const ActorFill* fill, ActorArtboard* artboard); 22 | static ActorFill* read(ActorArtboard* artboard, BlockReader* reader, ActorFill* component); 23 | 24 | virtual void initializeGraphics() = 0; 25 | virtual void markPaintDirty() = 0; 26 | virtual void validatePaint() = 0; 27 | }; 28 | } // namespace flare 29 | 30 | #endif -------------------------------------------------------------------------------- /flare/include/flare/animation/keyframes/keyframe_is_collision_enabled.hpp: -------------------------------------------------------------------------------- 1 | #ifndef _FLARE_KEYFRAMEISCOLLISIONENABLED_HPP_ 2 | #define _FLARE_KEYFRAMEISCOLLISIONENABLED_HPP_ 3 | 4 | #include "keyframe_numeric.hpp" 5 | #include 6 | 7 | namespace flare 8 | { 9 | class ActorComponent; 10 | 11 | class KeyFrameIsCollisionEnabled : public KeyFrame 12 | { 13 | typedef KeyFrame Base; 14 | private: 15 | bool m_Value; 16 | 17 | public: 18 | bool read(BlockReader* reader, ActorComponent* component) override; 19 | void setNext(KeyFrame* frame) override; 20 | void apply(ActorComponent* component, float mix) override; 21 | void applyInterpolation(ActorComponent* component, float time, KeyFrame* toFrame, float mix) override; 22 | }; 23 | } 24 | 25 | #endif -------------------------------------------------------------------------------- /flare/include/flare/blend_mode.hpp: -------------------------------------------------------------------------------- 1 | #ifndef _FLARE_BLENDMODE_HPP_ 2 | #define _FLARE_BLENDMODE_HPP_ 3 | 4 | namespace flare 5 | { 6 | enum class BlendMode : signed int 7 | { 8 | Clear = 0, 9 | Src = 1, 10 | Dst = 2, 11 | SrcOver = 3, 12 | DstOver = 4, 13 | SrcIn = 5, 14 | DstIn = 6, 15 | SrcOut = 7, 16 | DstOut = 8, 17 | SrcATop = 9, 18 | DstATop = 10, 19 | Xor = 11, 20 | Plus = 12, 21 | Modulate = 13, 22 | Screen = 14, 23 | Overlay = 15, 24 | Darken = 16, 25 | Lighten = 17, 26 | ColorDodge = 18, 27 | ColorBurn = 19, 28 | HardLight = 20, 29 | SoftLight = 21, 30 | Difference = 22, 31 | Exclusion = 23, 32 | Multiply = 24, 33 | Hue = 25, 34 | Saturation = 26, 35 | Color = 27, 36 | Luminosity = 28 37 | }; 38 | } 39 | 40 | #endif -------------------------------------------------------------------------------- /flare/include/flare/animation/keyframes/keyframe_color.hpp: -------------------------------------------------------------------------------- 1 | #ifndef _FLARE_KEYFRAMECOLOR_HPP_ 2 | #define _FLARE_KEYFRAMECOLOR_HPP_ 3 | 4 | #include "keyframe_with_interpolation.hpp" 5 | 6 | namespace flare 7 | { 8 | class ActorComponent; 9 | 10 | class KeyFrameColor : public KeyFrameWithInterpolation 11 | { 12 | typedef KeyFrameWithInterpolation Base; 13 | 14 | private: 15 | float m_Value[4]; 16 | 17 | public: 18 | KeyFrameColor(); 19 | const float* value() const { return m_Value; } 20 | bool read(BlockReader* reader, ActorComponent* component) override; 21 | void apply(ActorComponent* component, float mix) override; 22 | void applyInterpolation(ActorComponent* component, float time, KeyFrame* toFrame, float mix) override; 23 | }; 24 | } // namespace flare 25 | 26 | #endif -------------------------------------------------------------------------------- /flare/src/actor_root_bone.cpp: -------------------------------------------------------------------------------- 1 | #include "flare/actor_root_bone.hpp" 2 | 3 | using namespace flare; 4 | 5 | ActorRootBone::ActorRootBone() : ActorNode(ComponentType::ActorRootBone) {} 6 | 7 | ActorNode* ActorRootBone::makeInstance(ActorArtboard* artboard) const 8 | { 9 | ActorRootBone* instanceNode = new ActorRootBone(); 10 | instanceNode->copy(this, artboard); 11 | return instanceNode; 12 | } 13 | 14 | void ActorRootBone::copy(const ActorRootBone* node, ActorArtboard* artboard) { ActorNode::copy(node, artboard); } 15 | 16 | ActorRootBone* ActorRootBone::read(ActorArtboard* artboard, BlockReader* reader, ActorRootBone* node) 17 | { 18 | if (node == nullptr) 19 | { 20 | node = new ActorRootBone(); 21 | } 22 | 23 | ActorNode::read(artboard, reader, node); 24 | 25 | return node; 26 | } -------------------------------------------------------------------------------- /test/.vscode/launch.json: -------------------------------------------------------------------------------- 1 | { 2 | // Use IntelliSense to learn about possible attributes. 3 | // Hover to view descriptions of existing attributes. 4 | // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387 5 | "version": "0.2.0", 6 | "configurations": [ 7 | { 8 | "preLaunchTask":"build", 9 | "name": "(lldb) Launch", 10 | "type": "cppdbg", 11 | "request": "launch", 12 | "program": "${workspaceFolder}/../test/build/debug/bin/test", 13 | "args": [], 14 | "stopAtEntry": false, 15 | "cwd": "${workspaceFolder}/../test/", 16 | "environment": [], 17 | "externalConsole": true, 18 | "MIMode": "lldb" 19 | } 20 | ] 21 | } -------------------------------------------------------------------------------- /flare/src/paint/actor_color.cpp: -------------------------------------------------------------------------------- 1 | #include "flare/paint/actor_color.hpp" 2 | #include "flare/actor_artboard.hpp" 3 | #include "flare/block_reader.hpp" 4 | 5 | using namespace flare; 6 | 7 | ActorColor::ActorColor(ComponentType type) : Base(type) {} 8 | 9 | void ActorColor::color(const Color& value) 10 | { 11 | if (value == m_Color) 12 | { 13 | return; 14 | } 15 | m_Color = value; 16 | markPaintDirty(); 17 | } 18 | 19 | void ActorColor::copy(const ActorColor* paint, ActorArtboard* artboard) 20 | { 21 | Base::copy(paint, artboard); 22 | m_Color = paint->m_Color; 23 | } 24 | 25 | ActorColor* ActorColor::read(ActorArtboard* artboard, BlockReader* reader, ActorColor* component) 26 | { 27 | Base::read(artboard, reader, component); 28 | reader->read(component->m_Color); 29 | return component; 30 | } -------------------------------------------------------------------------------- /example/.vscode/launch.json: -------------------------------------------------------------------------------- 1 | { 2 | // Use IntelliSense to learn about possible attributes. 3 | // Hover to view descriptions of existing attributes. 4 | // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387 5 | "version": "0.2.0", 6 | "configurations": [ 7 | { 8 | "preLaunchTask":"build", 9 | "name": "(lldb) Launch", 10 | "type": "cppdbg", 11 | "request": "launch", 12 | "program": "${workspaceFolder}/../example/build/debug/bin/example", 13 | "args": [], 14 | "stopAtEntry": false, 15 | "cwd": "${workspaceFolder}/../example/", 16 | "environment": [], 17 | "externalConsole": true, 18 | "MIMode": "lldb" 19 | } 20 | ] 21 | } -------------------------------------------------------------------------------- /flare/include/flare/actor_scale_constraint.hpp: -------------------------------------------------------------------------------- 1 | #ifndef _FLARE_ACTORSCALECONSTRAINT_HPP_ 2 | #define _FLARE_ACTORSCALECONSTRAINT_HPP_ 3 | 4 | #include "actor_axis_constraint.hpp" 5 | 6 | namespace flare 7 | { 8 | class ActorScaleConstraint : public ActorAxisConstraint 9 | { 10 | typedef ActorAxisConstraint Base; 11 | 12 | private: 13 | TransformComponents m_ComponentsA; 14 | TransformComponents m_ComponentsB; 15 | 16 | public: 17 | ActorScaleConstraint(); 18 | ActorComponent* makeInstance(ActorArtboard* artboard) const override; 19 | static ActorScaleConstraint* read(ActorArtboard* artboard, BlockReader* reader, 20 | ActorScaleConstraint* constraint = nullptr); 21 | void constrain(ActorNode* node) override; 22 | }; 23 | } //namespace flare 24 | 25 | #endif -------------------------------------------------------------------------------- /flare/include/flare/paint/actor_color.hpp: -------------------------------------------------------------------------------- 1 | #ifndef _FLARE_ACTOR_COLOR_HPP_ 2 | #define _FLARE_ACTOR_COLOR_HPP_ 3 | 4 | #include "flare/paint/actor_paint.hpp" 5 | #include "flare_math/color.hpp" 6 | 7 | namespace flare 8 | { 9 | class BlockReader; 10 | class ActorArtboard; 11 | 12 | class ActorColor : public ActorPaint 13 | { 14 | typedef ActorPaint Base; 15 | 16 | protected: 17 | Color m_Color; 18 | 19 | public: 20 | ActorColor(ComponentType type); 21 | const Color& color() const { return m_Color; } 22 | void color(const Color& value); 23 | void copy(const ActorColor* color, ActorArtboard* artboard); 24 | static ActorColor* read(ActorArtboard* artboard, BlockReader* reader, ActorColor* component); 25 | }; 26 | } // namespace flare 27 | 28 | #endif -------------------------------------------------------------------------------- /flare/src/actor_event.cpp: -------------------------------------------------------------------------------- 1 | #include "flare/actor_event.hpp" 2 | #include "flare/block_reader.hpp" 3 | using namespace flare; 4 | 5 | ActorEvent::ActorEvent() : ActorComponent(ComponentType::ActorEvent) {} 6 | 7 | ActorComponent* ActorEvent::makeInstance(ActorArtboard* artboard) const 8 | { 9 | ActorEvent* eventInstance = new ActorEvent(); 10 | eventInstance->copy(this, artboard); 11 | return eventInstance; 12 | } 13 | 14 | void ActorEvent::copy(const ActorComponent* node, ActorArtboard* artboard) { Base::copy(node, artboard); } 15 | 16 | ActorEvent* ActorEvent::read(ActorArtboard* artboard, BlockReader* reader, ActorEvent* component) 17 | { 18 | if (component == nullptr) 19 | { 20 | component = new ActorEvent(); 21 | } 22 | 23 | Base::read(artboard, reader, component); 24 | 25 | return component; 26 | } -------------------------------------------------------------------------------- /flare/include/flare/animation/interpolators/cubic_ease.hpp: -------------------------------------------------------------------------------- 1 | #ifndef _FLARE_CUBIC_EASE_HPP_ 2 | #define _FLARE_CUBIC_EASE_HPP_ 3 | 4 | namespace flare 5 | { 6 | // Implements https://github.com/gre/bezier-easing/blob/master/src/index.js 7 | class CubicEase 8 | { 9 | private: 10 | static constexpr int SplineTableSize = 11; 11 | static constexpr float SampleStepSize = 1.0f / (SplineTableSize-1.0f); 12 | float m_X1, m_Y1, m_X2, m_Y2; 13 | float m_Values[SplineTableSize]; 14 | 15 | public: 16 | CubicEase(); 17 | CubicEase(float x1, float y1, float x2, float y2); 18 | void initialize(float x1, float y1, float x2, float y2); 19 | float ease(float t) const; 20 | private: 21 | float getT(float x) const; 22 | }; 23 | } // namespace flare 24 | 25 | #endif 26 | -------------------------------------------------------------------------------- /flare/include/flare/animation/keyframes/keyframe_active_child.hpp: -------------------------------------------------------------------------------- 1 | #ifndef _FLARE_KEYFRAMEACTIVECHILD_HPP_ 2 | #define _FLARE_KEYFRAMEACTIVECHILD_HPP_ 3 | 4 | #include "keyframe.hpp" 5 | 6 | namespace flare 7 | { 8 | class ActorComponent; 9 | 10 | class KeyFrameActiveChild : public KeyFrame 11 | { 12 | typedef KeyFrame Base; 13 | 14 | private: 15 | unsigned m_Value; 16 | 17 | protected: 18 | void setValue(ActorComponent* component, float value, float mix); 19 | 20 | public: 21 | bool read(BlockReader* reader, ActorComponent* component) override; 22 | void setNext(KeyFrame* frame) override; 23 | void apply(ActorComponent* component, float mix) override; 24 | void applyInterpolation(ActorComponent* component, float time, KeyFrame* toFrame, float mix) override; 25 | 26 | }; 27 | } 28 | 29 | #endif -------------------------------------------------------------------------------- /flare/include/flare/animation/keyframes/keyframe_gradient.hpp: -------------------------------------------------------------------------------- 1 | #ifndef _FLARE_KEYFRAMEGRADIENT_HPP_ 2 | #define _FLARE_KEYFRAMEGRADIENT_HPP_ 3 | 4 | #include "keyframe_with_interpolation.hpp" 5 | #include 6 | 7 | namespace flare 8 | { 9 | class ActorComponent; 10 | 11 | class KeyFrameGradient : public KeyFrameWithInterpolation 12 | { 13 | typedef KeyFrameWithInterpolation Base; 14 | 15 | private: 16 | std::vector m_Value; 17 | 18 | public: 19 | const std::vector& value() const { return m_Value; } 20 | bool read(BlockReader* reader, ActorComponent* component) override; 21 | void apply(ActorComponent* component, float mix) override; 22 | void applyInterpolation(ActorComponent* component, float time, KeyFrame* toFrame, float mix) override; 23 | }; 24 | } // namespace flare 25 | 26 | #endif -------------------------------------------------------------------------------- /flare/include/flare/path/actor_polygon.hpp: -------------------------------------------------------------------------------- 1 | #ifndef _FLARE_ACTORPOLYGON_HPP_ 2 | #define _FLARE_ACTORPOLYGON_HPP_ 3 | 4 | #include "actor_procedural_path.hpp" 5 | #include 6 | 7 | namespace flare 8 | { 9 | class ActorPolygon : public ActorProceduralPath 10 | { 11 | typedef ActorProceduralPath Base; 12 | 13 | private: 14 | int m_NumSides; 15 | 16 | public: 17 | ActorPolygon(); 18 | 19 | int numSides() const { return m_NumSides; } 20 | void numSides(int value); 21 | 22 | void copy(const ActorPolygon* star, ActorArtboard* artboard); 23 | ActorComponent* makeInstance(ActorArtboard* artboard) const override; 24 | void makePoints() override; 25 | static ActorPolygon* read(ActorArtboard* artboard, BlockReader* reader, ActorPolygon* component); 26 | }; 27 | } // namespace flare 28 | #endif -------------------------------------------------------------------------------- /flare/include/flare/animation/keyframes/keyframe_with_interpolation.hpp: -------------------------------------------------------------------------------- 1 | #ifndef _FLARE_KEYFRAMEWITHINTERPOLATION_HPP_ 2 | #define _FLARE_KEYFRAMEWITHINTERPOLATION_HPP_ 3 | 4 | #include "keyframe.hpp" 5 | #include "../interpolators/keyframe_interpolator.hpp" 6 | 7 | namespace flare 8 | { 9 | class KeyFrameWithInterpolation : public KeyFrame 10 | { 11 | typedef KeyFrame Base; 12 | 13 | protected: 14 | const KeyFrameInterpolator* m_Interpolator; 15 | 16 | public: 17 | KeyFrameWithInterpolation(); 18 | virtual ~KeyFrameWithInterpolation(); 19 | const KeyFrameInterpolator* interpolator() const; 20 | InterpolationType interpolationType() const; 21 | 22 | bool read(BlockReader* reader, ActorComponent* component) override; 23 | void setNext(KeyFrame* frame) override; 24 | }; 25 | } // namespace flare 26 | 27 | #endif -------------------------------------------------------------------------------- /flare/src/path/actor_triangle.cpp: -------------------------------------------------------------------------------- 1 | #include "flare/path/actor_triangle.hpp" 2 | #include "flare/actor_shape.hpp" 3 | #include "flare/block_reader.hpp" 4 | #include 5 | 6 | using namespace flare; 7 | 8 | ActorTriangle::ActorTriangle() : Base(ComponentType::ActorTriangle) {} 9 | 10 | void ActorTriangle::makePoints() 11 | { 12 | float radiusX = width() / 2.0f; 13 | float radiusY = height() / 2.0f; 14 | 15 | m_Points.push_back(new StraightPathPoint(Vec2D(0.0f, -radiusY))); 16 | m_Points.push_back(new StraightPathPoint(Vec2D(radiusX, radiusY))); 17 | m_Points.push_back(new StraightPathPoint(Vec2D(-radiusX, radiusY))); 18 | } 19 | 20 | ActorComponent* ActorTriangle::makeInstance(ActorArtboard* artboard) const 21 | { 22 | ActorTriangle* instance = new ActorTriangle(); 23 | instance->copy(this, artboard); 24 | return instance; 25 | } -------------------------------------------------------------------------------- /flare_skia/build/flare_skia.lua: -------------------------------------------------------------------------------- 1 | project "flare_skia" 2 | kind "StaticLib" 3 | language "C++" 4 | 5 | configuration { "Debug" } 6 | targetdir "./debug/lib" 7 | objdir "./debug/obj" 8 | 9 | configuration { "Release" } 10 | targetdir "./release/lib" 11 | objdir "./release/obj" 12 | 13 | configuration { } 14 | 15 | includedirs 16 | { 17 | "../include", 18 | "../../flare_math/include", 19 | "../../flare/include", 20 | "../../dependencies/skia", 21 | "../../dependencies/skia/include/core", 22 | "../../dependencies/skia/include/effects", 23 | "../../dependencies/skia/include/gpu", 24 | "../../dependencies/skia/include/config" 25 | } 26 | 27 | buildoptions_cpp 28 | { 29 | "-std=c++11", 30 | "-fembed-bitcode" 31 | } 32 | 33 | files 34 | { 35 | "../src/**.cpp" 36 | } 37 | 38 | targetname "flare_skia" -------------------------------------------------------------------------------- /flare/include/flare/actor_node_solo.hpp: -------------------------------------------------------------------------------- 1 | #ifndef _FLARE_ACTORNODESOLO_HPP_ 2 | #define _FLARE_ACTORNODESOLO_HPP_ 3 | 4 | #include "actor_node.hpp" 5 | #include 6 | 7 | namespace flare 8 | { 9 | class ActorNodeSolo : public ActorNode 10 | { 11 | typedef ActorNode Base; 12 | 13 | private: 14 | int m_ActiveChildIndex; 15 | 16 | public: 17 | ActorNodeSolo(); 18 | int activeChildIndex() const; 19 | void activeChildIndex(int index); 20 | void setActiveChildIndex(int index); 21 | 22 | ActorComponent* makeInstance(ActorArtboard* artboard) const override; 23 | void copy(const ActorNodeSolo* node, ActorArtboard* artboard); 24 | void completeResolve() override; 25 | 26 | static ActorNodeSolo* read(ActorArtboard* artboard, BlockReader* reader, ActorNodeSolo* node = NULL); 27 | }; 28 | } // namespace flare 29 | 30 | #endif -------------------------------------------------------------------------------- /flare/include/flare/animation/keyframes/keyframe_path_vertices.hpp: -------------------------------------------------------------------------------- 1 | #ifndef _FLARE_KEYFRAMEPATHVERTICES_HPP_ 2 | #define _FLARE_KEYFRAMEPATHVERTICES_HPP_ 3 | 4 | #include "keyframe_with_interpolation.hpp" 5 | 6 | namespace flare 7 | { 8 | class ActorComponent; 9 | 10 | class KeyFramePathVertices : public KeyFrameWithInterpolation 11 | { 12 | typedef KeyFrameWithInterpolation Base; 13 | private: 14 | float* m_Vertices; 15 | unsigned int m_VerticesLength; 16 | 17 | public: 18 | KeyFramePathVertices(); 19 | virtual ~KeyFramePathVertices(); 20 | 21 | bool read(BlockReader* reader, ActorComponent* component) override; 22 | void apply(ActorComponent* component, float mix) override; 23 | void applyInterpolation(ActorComponent* component, float time, KeyFrame* toFrame, float mix) override; 24 | }; 25 | } 26 | 27 | #endif -------------------------------------------------------------------------------- /.clang-format: -------------------------------------------------------------------------------- 1 | BasedOnStyle: LLVM 2 | IndentWidth: 4 3 | UseTab: ForIndentation 4 | TabWidth: 4 5 | BreakBeforeBraces: Allman 6 | IndentCaseLabels: true 7 | Language: Cpp 8 | # Force pointers to the type for C++. 9 | DerivePointerAlignment: false 10 | PointerAlignment: Left 11 | NamespaceIndentation: All 12 | AccessModifierOffset: -4 13 | BreakConstructorInitializers: AfterColon 14 | ConstructorInitializerAllOnOneLineOrOnePerLine: true 15 | ColumnLimit: 140 16 | BreakBeforeBraces: Custom 17 | BraceWrapping: 18 | AfterEnum: true 19 | AfterClass: true 20 | AfterControlStatement: true 21 | AfterNamespace: true 22 | AfterFunction: true 23 | AfterStruct: true 24 | SplitEmptyFunction: true 25 | AfterObjCDeclaration: true 26 | AfterStruct: true 27 | AfterUnion: true 28 | AfterExternBlock: true 29 | BeforeCatch: true 30 | BeforeElse: true -------------------------------------------------------------------------------- /flare/include/flare/animation/keyframes/keyframe.hpp: -------------------------------------------------------------------------------- 1 | #ifndef _FLARE_KEYFRAME_HPP_ 2 | #define _FLARE_KEYFRAME_HPP_ 3 | 4 | namespace flare 5 | { 6 | class BlockReader; 7 | class ActorComponent; 8 | 9 | enum class InterpolationType 10 | { 11 | Hold = 0, 12 | Linear = 1, 13 | Cubic = 2, 14 | Max 15 | }; 16 | 17 | class KeyFrame 18 | { 19 | public: 20 | 21 | protected: 22 | float m_Time; 23 | 24 | public: 25 | KeyFrame(); 26 | virtual ~KeyFrame(); 27 | 28 | float time() const; 29 | 30 | virtual bool read(BlockReader* reader, ActorComponent* component); 31 | virtual void setNext(KeyFrame* frame) = 0; 32 | virtual void apply(ActorComponent* component, float mix) = 0; 33 | virtual void applyInterpolation(ActorComponent* component, float time, KeyFrame* toFrame, float mix) = 0; 34 | }; 35 | } 36 | 37 | #endif -------------------------------------------------------------------------------- /flare/include/flare/animation/keyframes/keyframe_image_vertices.hpp: -------------------------------------------------------------------------------- 1 | #ifndef _FLARE_KEYFRAMEIMAGEVERTICES_HPP_ 2 | #define _FLARE_KEYFRAMEIMAGEVERTICES_HPP_ 3 | 4 | #include "keyframe_with_interpolation.hpp" 5 | 6 | namespace flare 7 | { 8 | class ActorComponent; 9 | 10 | class KeyFrameImageVertices : public KeyFrameWithInterpolation 11 | { 12 | typedef KeyFrameWithInterpolation Base; 13 | private: 14 | float* m_Vertices; 15 | unsigned int m_VerticesCount; 16 | 17 | public: 18 | KeyFrameImageVertices(); 19 | virtual ~KeyFrameImageVertices(); 20 | 21 | bool read(BlockReader* reader, ActorComponent* component) override; 22 | void apply(ActorComponent* component, float mix) override; 23 | void applyInterpolation(ActorComponent* component, float time, KeyFrame* toFrame, float mix) override; 24 | }; 25 | } 26 | 27 | #endif -------------------------------------------------------------------------------- /flare/include/flare/animation/keyframes/keyframe_radial_gradient.hpp: -------------------------------------------------------------------------------- 1 | #ifndef _FLARE_KEYFRAMERADIALGRADIENT_HPP_ 2 | #define _FLARE_KEYFRAMERADIALGRADIENT_HPP_ 3 | 4 | #include "keyframe_with_interpolation.hpp" 5 | #include 6 | 7 | namespace flare 8 | { 9 | class ActorComponent; 10 | 11 | class KeyFrameRadialGradient : public KeyFrameWithInterpolation 12 | { 13 | typedef KeyFrameWithInterpolation Base; 14 | 15 | private: 16 | std::vector m_Value; 17 | 18 | public: 19 | const std::vector& value() const { return m_Value; } 20 | bool read(BlockReader* reader, ActorComponent* component) override; 21 | void apply(ActorComponent* component, float mix) override; 22 | void applyInterpolation(ActorComponent* component, float time, KeyFrame* toFrame, float mix) override; 23 | }; 24 | } // namespace flare 25 | 26 | #endif -------------------------------------------------------------------------------- /flare/include/flare/path/actor_rectangle.hpp: -------------------------------------------------------------------------------- 1 | #ifndef _FLARE_ACTORRECTANGLE_HPP_ 2 | #define _FLARE_ACTORRECTANGLE_HPP_ 3 | 4 | #include "actor_procedural_path.hpp" 5 | #include 6 | 7 | namespace flare 8 | { 9 | class ActorRectangle : public ActorProceduralPath 10 | { 11 | typedef ActorProceduralPath Base; 12 | private: 13 | float m_Radius; 14 | 15 | public: 16 | ActorRectangle(); 17 | 18 | void copy(const ActorRectangle* rectangle, ActorArtboard* artboard); 19 | ActorComponent* makeInstance(ActorArtboard* artboard) const override; 20 | void makePoints() override; 21 | static ActorRectangle* read(ActorArtboard* artboard, BlockReader* reader, ActorRectangle* component = NULL); 22 | 23 | float radius() const { return m_Radius; } 24 | bool radius(float value); 25 | }; 26 | } // namespace flare 27 | #endif -------------------------------------------------------------------------------- /flare/include/flare/path/actor_star.hpp: -------------------------------------------------------------------------------- 1 | #ifndef _FLARE_ACTORSTAR_HPP_ 2 | #define _FLARE_ACTORSTAR_HPP_ 3 | 4 | #include "flare/path/actor_procedural_path.hpp" 5 | #include 6 | 7 | namespace flare 8 | { 9 | class ActorStar : public ActorProceduralPath 10 | { 11 | typedef ActorProceduralPath Base; 12 | 13 | private: 14 | int m_NumPoints; 15 | float m_InnerRadius; 16 | 17 | public: 18 | ActorStar(); 19 | 20 | void copy(const ActorStar* star, ActorArtboard* artboard); 21 | ActorComponent* makeInstance(ActorArtboard* artboard) const override; 22 | void makePoints() override; 23 | static ActorStar* read(ActorArtboard* artboard, BlockReader* reader, ActorStar* component = nullptr); 24 | 25 | float innerRadius() const { return m_InnerRadius; } 26 | bool innerRadius(float value); 27 | }; 28 | } // namespace flare 29 | #endif -------------------------------------------------------------------------------- /flare/src/animation/keyframes/keyframe_sequence.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include "flare/animation/keyframes/keyframe_sequence.hpp" 4 | #include "flare/actor_image.hpp" 5 | 6 | using namespace flare; 7 | 8 | bool KeyFrameSequence::read(BlockReader* reader, ActorComponent* component) 9 | { 10 | if(KeyFrameNumeric::read(reader, component)) 11 | { 12 | return true; 13 | } 14 | 15 | return false; 16 | } 17 | 18 | void KeyFrameSequence::setValue(ActorComponent* component, float value, float mix) 19 | { 20 | ActorImage* node = static_cast(component); 21 | int v = floor(value); 22 | int c = node->sequenceFramesCount(); 23 | int frameIdx = v % c; 24 | if(frameIdx < 0) 25 | { 26 | frameIdx += node->sequenceFramesCount(); 27 | } 28 | node->sequenceFrame(frameIdx); 29 | } -------------------------------------------------------------------------------- /flare/.vscode/tasks.json: -------------------------------------------------------------------------------- 1 | { 2 | // See https://go.microsoft.com/fwlink/?LinkId=733558 3 | // for the documentation about the tasks.json format 4 | "version": "2.0.0", 5 | "tasks": [ 6 | { 7 | "label": "build", 8 | "type": "shell", 9 | "command": "cd build && genie ninja && make", 10 | "problemMatcher": [ 11 | "$gcc" 12 | ], 13 | "group": { 14 | "kind": "build", 15 | "isDefault": true 16 | } 17 | }, 18 | { 19 | "label": "generate compile commands", 20 | "type": "shell", 21 | "command": "cd build && genie ninja && ninja -C debug -t compdb cxx > ../compile_commands.json", 22 | "problemMatcher": [ 23 | "$gcc" 24 | ] 25 | } 26 | ] 27 | } -------------------------------------------------------------------------------- /flare/include/flare/block_reader.hpp: -------------------------------------------------------------------------------- 1 | #ifndef _FLARE_BLOCKREADER_HPP_ 2 | #define _FLARE_BLOCKREADER_HPP_ 3 | 4 | #include "binary_reader.hpp" 5 | #include 6 | 7 | namespace flare 8 | { 9 | class Mat2D; 10 | class Vec2D; 11 | class Color; 12 | 13 | class BlockReader; 14 | 15 | class BlockReader : public BinaryReader 16 | { 17 | private: 18 | int m_BlockType; 19 | 20 | public: 21 | BlockReader(unsigned char* data, unsigned int length); 22 | BlockReader(int type, unsigned char* data, unsigned int length); 23 | BlockReader* readNextBlock(); 24 | 25 | template T blockType() const { return static_cast(m_BlockType); } 26 | int blockType() const { return m_BlockType; } 27 | void read(Mat2D& mat); 28 | void read(Vec2D& vec); 29 | void read(Color& vec); 30 | void close() { delete this; } 31 | }; 32 | 33 | } //namespace flare 34 | #endif -------------------------------------------------------------------------------- /test/.vscode/tasks.json: -------------------------------------------------------------------------------- 1 | { 2 | // See https://go.microsoft.com/fwlink/?LinkId=733558 3 | // for the documentation about the tasks.json format 4 | "version": "2.0.0", 5 | "tasks": [ 6 | { 7 | "label": "build", 8 | "type": "shell", 9 | "command": "cd build && genie ninja && make", 10 | "problemMatcher": [ 11 | "$gcc" 12 | ], 13 | "group": { 14 | "kind": "build", 15 | "isDefault": true 16 | } 17 | }, 18 | { 19 | "label": "generate compile commands", 20 | "type": "shell", 21 | "command": "cd build && genie ninja && ninja -C debug -t compdb cxx > ../compile_commands.json", 22 | "problemMatcher": [ 23 | "$gcc" 24 | ] 25 | } 26 | ] 27 | } -------------------------------------------------------------------------------- /example/.vscode/tasks.json: -------------------------------------------------------------------------------- 1 | { 2 | // See https://go.microsoft.com/fwlink/?LinkId=733558 3 | // for the documentation about the tasks.json format 4 | "version": "2.0.0", 5 | "tasks": [ 6 | { 7 | "label": "build", 8 | "type": "shell", 9 | "command": "cd build && genie ninja && make", 10 | "problemMatcher": [ 11 | "$gcc" 12 | ], 13 | "group": { 14 | "kind": "build", 15 | "isDefault": true 16 | } 17 | }, 18 | { 19 | "label": "generate compile commands", 20 | "type": "shell", 21 | "command": "cd build && genie ninja && ninja -C debug -t compdb cxx > ../compile_commands.json", 22 | "problemMatcher": [ 23 | "$gcc" 24 | ] 25 | } 26 | ] 27 | } -------------------------------------------------------------------------------- /flare_skia/.vscode/tasks.json: -------------------------------------------------------------------------------- 1 | { 2 | // See https://go.microsoft.com/fwlink/?LinkId=733558 3 | // for the documentation about the tasks.json format 4 | "version": "2.0.0", 5 | "tasks": [ 6 | { 7 | "label": "build", 8 | "type": "shell", 9 | "command": "cd build && genie ninja && make", 10 | "problemMatcher": [ 11 | "$gcc" 12 | ], 13 | "group": { 14 | "kind": "build", 15 | "isDefault": true 16 | } 17 | }, 18 | { 19 | "label": "generate compile commands", 20 | "type": "shell", 21 | "command": "cd build && genie ninja && ninja -C debug -t compdb cxx > ../compile_commands.json", 22 | "problemMatcher": [ 23 | "$gcc" 24 | ] 25 | } 26 | ] 27 | } -------------------------------------------------------------------------------- /flare/include/flare/actor_skin.hpp: -------------------------------------------------------------------------------- 1 | #ifndef _FLARE_ACTORSKIN_HPP_ 2 | #define _FLARE_ACTORSKIN_HPP_ 3 | 4 | #include "actor_component.hpp" 5 | #include "blend_mode.hpp" 6 | 7 | namespace flare 8 | { 9 | class Actor; 10 | class BlockReader; 11 | class ActorSkinnable; 12 | 13 | class ActorSkin : public ActorComponent 14 | { 15 | typedef ActorComponent Base; 16 | 17 | private: 18 | float* m_BoneMatrices; 19 | int m_BoneMatricesLength; 20 | ActorSkinnable* m_SkinnableParent; 21 | 22 | public: 23 | ActorSkin(); 24 | ~ActorSkin(); 25 | const float* boneMatrices() const; 26 | void update(DirtyFlags dirt) override; 27 | void completeResolve() override; 28 | ActorComponent* makeInstance(ActorArtboard* artboard) const override; 29 | 30 | protected: 31 | void onParentChanged(ActorNode* from, ActorNode* to) override; 32 | }; 33 | } // namespace flare 34 | #endif -------------------------------------------------------------------------------- /flare/src/dependency_sorter.cpp: -------------------------------------------------------------------------------- 1 | #include "flare/dependency_sorter.hpp" 2 | 3 | using namespace flare; 4 | 5 | void DependencySorter::sort(ActorComponent* root, std::vector& order) 6 | { 7 | order.clear(); 8 | visit(root, order); 9 | } 10 | 11 | bool DependencySorter::visit(ActorComponent* component, std::vector& order) 12 | { 13 | if (m_Perm.find(component) != m_Perm.end()) 14 | { 15 | return true; 16 | } 17 | if (m_Temp.find(component) != m_Temp.end()) 18 | { 19 | fprintf(stderr, "Dependency cycle!\n"); 20 | return false; 21 | } 22 | 23 | m_Temp.emplace(component); 24 | 25 | auto dependents = component->dependents(); 26 | for (auto dependent : dependents) 27 | { 28 | if (!visit(dependent, order)) 29 | { 30 | return false; 31 | } 32 | } 33 | m_Perm.emplace(component); 34 | order.insert(order.begin(), component); 35 | 36 | return true; 37 | } 38 | -------------------------------------------------------------------------------- /flare/include/flare/exceptions/unsupported_version_exception.hpp: -------------------------------------------------------------------------------- 1 | #ifndef _FLARE_UNSUPPORTEDVERSIONEXCEPTION_HPP_ 2 | #define _FLARE_UNSUPPORTEDVERSIONEXCEPTION_HPP_ 3 | 4 | #include 5 | #include 6 | 7 | namespace flare 8 | { 9 | class UnsupportedVersionException : public std::exception 10 | { 11 | std::string m_Message; 12 | int m_VersionFound; 13 | int m_VersionRequired; 14 | 15 | 16 | public: 17 | UnsupportedVersionException(std::string msg, int version, int versionRequired) : m_Message(msg), m_VersionFound(version), m_VersionRequired(versionRequired) 18 | { 19 | 20 | } 21 | 22 | const std::string message() const 23 | { 24 | return m_Message; 25 | } 26 | 27 | int versionFound() const 28 | { 29 | return m_VersionFound; 30 | } 31 | 32 | int versionRequired() const 33 | { 34 | return m_VersionRequired; 35 | } 36 | }; 37 | } 38 | #endif -------------------------------------------------------------------------------- /flare/include/flare/paint/actor_radial_gradient.hpp: -------------------------------------------------------------------------------- 1 | #ifndef _FLARE_ACTOR_RADIAL_GRADIENT_HPP_ 2 | #define _FLARE_ACTOR_RADIAL_GRADIENT_HPP_ 3 | 4 | #include "flare/paint/actor_gradient_color.hpp" 5 | 6 | namespace flare 7 | { 8 | class BlockReader; 9 | class ActorArtboard; 10 | class KeyFrameRadialGradient; 11 | 12 | class ActorRadialGradient : public ActorGradientColor 13 | { 14 | friend class KeyFrameRadialGradient; 15 | typedef ActorGradientColor Base; 16 | 17 | private: 18 | float m_SecondaryRadiusScale; 19 | 20 | public: 21 | ActorRadialGradient(ComponentType type); 22 | float secondaryRadiusScale() const; 23 | void secondaryRadiusScale(float value); 24 | void copy(const ActorRadialGradient* stroke, ActorArtboard* artboard); 25 | static ActorRadialGradient* read(ActorArtboard* artboard, BlockReader* reader, ActorRadialGradient* component); 26 | }; 27 | } // namespace flare 28 | 29 | #endif -------------------------------------------------------------------------------- /flare/include/flare/animation/component_animation.hpp: -------------------------------------------------------------------------------- 1 | #ifndef _FLARE_COMPONENTANIMATION_HPP_ 2 | #define _FLARE_COMPONENTANIMATION_HPP_ 3 | 4 | #include 5 | #include 6 | #include "property_animation.hpp" 7 | 8 | namespace flare 9 | { 10 | class BlockReader; 11 | class ActorComponent; 12 | class ActorArtboard; 13 | struct ActorAnimationEvent; 14 | 15 | class ComponentAnimation 16 | { 17 | private: 18 | unsigned short m_ComponentIndex; 19 | std::vector m_Properties; 20 | 21 | public: 22 | ComponentAnimation(); 23 | ~ComponentAnimation(); 24 | int componentIndex() const; 25 | 26 | void read(BlockReader* reader, ActorComponent** components); 27 | void apply(float time, ActorArtboard* artboard, float mix); 28 | void triggerEvents(ActorArtboard* artboard, float fromTime, float toTime, std::vector& events); 29 | 30 | }; 31 | } 32 | #endif -------------------------------------------------------------------------------- /flare/include/flare/animation/keyframes/keyframe_draw_order.hpp: -------------------------------------------------------------------------------- 1 | #ifndef _FLARE_KEYFRAMEDRAWORDER_HPP_ 2 | #define _FLARE_KEYFRAMEDRAWORDER_HPP_ 3 | 4 | #include "keyframe.hpp" 5 | 6 | namespace flare 7 | { 8 | class ActorComponent; 9 | 10 | class KeyFrameDrawOrder : public KeyFrame 11 | { 12 | typedef KeyFrame Base; 13 | private: 14 | struct DrawOrderIndex 15 | { 16 | unsigned short nodeIdx; 17 | unsigned short order; 18 | }; 19 | DrawOrderIndex* m_OrderedNodes; 20 | int m_OrderedNodesCount; 21 | 22 | public: 23 | KeyFrameDrawOrder(); 24 | virtual ~KeyFrameDrawOrder(); 25 | 26 | bool read(BlockReader* reader, ActorComponent* component) override; 27 | void setNext(KeyFrame* frame) override; 28 | void apply(ActorComponent* component, float mix) override; 29 | void applyInterpolation(ActorComponent* component, float time, KeyFrame* toFrame, float mix) override; 30 | }; 31 | } 32 | 33 | #endif -------------------------------------------------------------------------------- /flare/include/flare/actor_bone_base.hpp: -------------------------------------------------------------------------------- 1 | #ifndef _FLARE_ACTORBONEBASE_HPP_ 2 | #define _FLARE_ACTORBONEBASE_HPP_ 3 | 4 | #include "flare/actor_node.hpp" 5 | #include "flare_math/vec2d.hpp" 6 | 7 | namespace flare 8 | { 9 | class Actor; 10 | class BlockReader; 11 | class ActorNode; 12 | 13 | class ActorBoneBase : public ActorNode 14 | { 15 | typedef ActorNode Base; 16 | 17 | protected: 18 | float m_Length; 19 | bool m_IsConnectedToImage; 20 | 21 | public: 22 | ActorBoneBase(ComponentType type); 23 | float length() const; 24 | void length(float l); 25 | bool isConnectedToImage() const; 26 | void isConnectedToImage(bool isIt); 27 | void tipWorldTranslation(Vec2D& result); 28 | Vec2D tipWorldTranslation(); 29 | void copy(const ActorBoneBase* node, ActorArtboard* artboard); 30 | static ActorBoneBase* read(ActorArtboard* artboard, BlockReader* reader, ActorBoneBase* node = NULL); 31 | }; 32 | } // namespace flare 33 | #endif -------------------------------------------------------------------------------- /flare/include/flare/actor_shape.hpp: -------------------------------------------------------------------------------- 1 | #ifndef _FLARE_ACTORSHAPE_HPP_ 2 | #define _FLARE_ACTORSHAPE_HPP_ 3 | 4 | #include "actor_drawable.hpp" 5 | #include 6 | 7 | namespace flare 8 | { 9 | class ActorStroke; 10 | class ActorFill; 11 | 12 | class ActorShape : public ActorDrawable 13 | { 14 | typedef ActorDrawable Base; 15 | 16 | protected: 17 | std::vector m_Strokes; 18 | std::vector m_Fills; 19 | 20 | public: 21 | ActorShape(); 22 | ~ActorShape(); 23 | virtual void invalidateDrawable(); 24 | void update(DirtyFlags dirt) override; 25 | void initializeGraphics() override; 26 | 27 | void addStroke(ActorStroke* stroke); 28 | void addFill(ActorFill* fill); 29 | 30 | void removeStroke(ActorStroke* stroke); 31 | void removeFill(ActorFill* fill); 32 | 33 | protected: 34 | virtual void onStrokesChanged() {} 35 | virtual void onFillsChanged() {} 36 | }; 37 | } // namespace flare 38 | #endif -------------------------------------------------------------------------------- /flare/include/flare/paint/actor_color_fill.hpp: -------------------------------------------------------------------------------- 1 | #ifndef _FLARE_ACTOR_COLOR_FILL_HPP_ 2 | #define _FLARE_ACTOR_COLOR_FILL_HPP_ 3 | 4 | #include "flare/paint/actor_color.hpp" 5 | #include "flare/paint/actor_fill.hpp" 6 | 7 | namespace flare 8 | { 9 | class BlockReader; 10 | class ActorArtboard; 11 | 12 | class ActorColorFill : public ActorColor, public ActorFill 13 | { 14 | public: 15 | ActorColorFill(); 16 | void copy(const ActorColorFill* fill, ActorArtboard* artboard); 17 | static ActorColorFill* read(ActorArtboard* artboard, BlockReader* reader, ActorColorFill* component); 18 | void onShapeChanged(ActorShape* from, ActorShape* to) override; 19 | void initializeGraphics() override; 20 | void markPaintDirty() override { ActorColor::markPaintDirty(); } 21 | void validatePaint() override { ActorColor::validatePaint(); } 22 | ActorComponent* makeInstance(ActorArtboard* artboard) const override; 23 | }; 24 | } // namespace flare 25 | 26 | #endif -------------------------------------------------------------------------------- /flare/src/animation/keyframes/keyframe_trigger.cpp: -------------------------------------------------------------------------------- 1 | #include "flare/animation/keyframes/keyframe_trigger.hpp" 2 | #include "flare/actor.hpp" 3 | #include "flare/actor_image.hpp" 4 | #include "flare/block_reader.hpp" 5 | 6 | using namespace flare; 7 | 8 | 9 | KeyFrameTrigger::KeyFrameTrigger() 10 | { 11 | 12 | } 13 | 14 | KeyFrameTrigger::~KeyFrameTrigger() 15 | { 16 | } 17 | 18 | 19 | bool KeyFrameTrigger::read(BlockReader* reader, ActorComponent* component) 20 | { 21 | if(!Base::read(reader, component)) 22 | { 23 | return false; 24 | } 25 | 26 | return true; 27 | } 28 | 29 | void KeyFrameTrigger::setNext(KeyFrame* frame) 30 | { 31 | // Do nothing, we don't interpolate. 32 | } 33 | 34 | void KeyFrameTrigger::apply(ActorComponent* component, float mix) 35 | { 36 | // Intentionally blank. 37 | } 38 | 39 | void KeyFrameTrigger::applyInterpolation(ActorComponent* node, float time, KeyFrame* toFrame, float mix) 40 | { 41 | // Do nothing, we don't interpolate. 42 | } -------------------------------------------------------------------------------- /flare/include/flare/actor_distance_constraint.hpp: -------------------------------------------------------------------------------- 1 | #ifndef _FLARE_ACTORDISTANCECONSTRAINT_HPP_ 2 | #define _FLARE_ACTORDISTANCECONSTRAINT_HPP_ 3 | 4 | #include "actor_targeted_constraint.hpp" 5 | 6 | namespace flare 7 | { 8 | class ActorDistanceConstraint : public ActorTargetedConstraint 9 | { 10 | typedef ActorTargetedConstraint Base; 11 | 12 | private: 13 | enum class Mode 14 | { 15 | Closer = 0, 16 | Further = 1, 17 | Exact = 2 18 | }; 19 | Mode m_Mode; 20 | float m_Distance; 21 | 22 | public: 23 | ActorDistanceConstraint(); 24 | void copy(const ActorDistanceConstraint* node, ActorArtboard* artboard); 25 | ActorComponent* makeInstance(ActorArtboard* artboard) const override; 26 | static ActorDistanceConstraint* read(ActorArtboard* artboard, BlockReader* reader, 27 | ActorDistanceConstraint* constraint = nullptr); 28 | void constrain(ActorNode* node) override; 29 | }; 30 | } // namespace flare 31 | 32 | #endif -------------------------------------------------------------------------------- /flare/include/flare/actor_constraint.hpp: -------------------------------------------------------------------------------- 1 | #ifndef _FLARE_ACTORCONSTRAINT_HPP_ 2 | #define _FLARE_ACTORCONSTRAINT_HPP_ 3 | 4 | #include "actor_component.hpp" 5 | 6 | namespace flare 7 | { 8 | class ActorConstraint : public ActorComponent 9 | { 10 | typedef ActorComponent Base; 11 | 12 | protected: 13 | bool m_IsEnabled; 14 | float m_Strength; 15 | 16 | protected: 17 | ActorConstraint(ActorArtboard* artboard, ComponentType type); 18 | 19 | public: 20 | bool isEnabled() const; 21 | float strength() const; 22 | void strength(float value); 23 | 24 | void onDirty(DirtyFlags dirt) override; 25 | virtual void constrain(ActorNode* node) = 0; 26 | void resolveComponentIndices(ActorComponent** components, int numComponents) override; 27 | void copy(const ActorConstraint* constraint, ActorArtboard* artboard); 28 | static ActorConstraint* read(ActorArtboard* artboard, BlockReader* reader, ActorConstraint* constraint = nullptr); 29 | }; 30 | } // namespace flare 31 | 32 | #endif -------------------------------------------------------------------------------- /flare/include/flare/actor_targeted_constraint.hpp: -------------------------------------------------------------------------------- 1 | #ifndef _FLARE_ACTORTARGETEDCONSTRAINT_HPP_ 2 | #define _FLARE_ACTORTARGETEDCONSTRAINT_HPP_ 3 | 4 | #include "actor_constraint.hpp" 5 | 6 | namespace flare 7 | { 8 | class ActorTargetedConstraint : public ActorConstraint 9 | { 10 | typedef ActorConstraint Base; 11 | 12 | protected: 13 | union { 14 | unsigned short m_TargetIdx; 15 | ActorComponent* m_Target; 16 | }; 17 | ActorTargetedConstraint(ActorArtboard* artboard, ComponentType type); 18 | 19 | public: 20 | ActorComponent* target() const { return m_Target; } 21 | 22 | void resolveComponentIndices(ActorComponent** components, int numComponents) override; 23 | void copy(const ActorTargetedConstraint* constraint, ActorArtboard* artboard); 24 | static ActorTargetedConstraint* read(ActorArtboard* artboard, BlockReader* reader, 25 | ActorTargetedConstraint* constraint = nullptr); 26 | }; 27 | } // namespace flare 28 | 29 | #endif -------------------------------------------------------------------------------- /flare/src/animation/keyframes/keyframe_active_child.cpp: -------------------------------------------------------------------------------- 1 | #include "flare/animation/keyframes/keyframe_active_child.hpp" 2 | #include "flare/block_reader.hpp" 3 | #include "flare/actor_node_solo.hpp" 4 | 5 | using namespace flare; 6 | 7 | bool KeyFrameActiveChild::read(BlockReader* reader, ActorComponent* component) 8 | { 9 | if(!Base::read(reader, component)) 10 | { 11 | return false; 12 | } 13 | 14 | m_Value = reader->readFloat32(); 15 | return true; 16 | } 17 | 18 | void KeyFrameActiveChild::setNext(KeyFrame* frame) 19 | { 20 | // Blank, no interpolation here 21 | } 22 | 23 | void KeyFrameActiveChild::apply(ActorComponent* component, float mix) 24 | { 25 | // printf("APPLY KeyFrameActiveChild %d\n", m_Value); 26 | ActorNodeSolo* node = reinterpret_cast(component); 27 | node->activeChildIndex(m_Value); 28 | } 29 | 30 | void KeyFrameActiveChild::applyInterpolation(ActorComponent* component, float time, KeyFrame* toFrame, float mix) 31 | { 32 | apply(component, mix); 33 | } -------------------------------------------------------------------------------- /flare/src/animation/keyframes/keyframe_is_collision_enabled.cpp: -------------------------------------------------------------------------------- 1 | #include "flare/animation/keyframes/keyframe_is_collision_enabled.hpp" 2 | #include "flare/block_reader.hpp" 3 | #include "flare/actor_collider.hpp" 4 | 5 | using namespace flare; 6 | 7 | bool KeyFrameIsCollisionEnabled::read(BlockReader* reader, ActorComponent* component) 8 | { 9 | if(!Base::read(reader, component)) 10 | { 11 | return false; 12 | } 13 | m_Value = reader->readUint8() == 1; 14 | return true; 15 | } 16 | 17 | void KeyFrameIsCollisionEnabled::setNext(KeyFrame* frame) 18 | { 19 | // Intentionally blank, we do not interpolate. 20 | } 21 | 22 | void KeyFrameIsCollisionEnabled::apply(ActorComponent* component, float mix) 23 | { 24 | ActorCollider* collider = reinterpret_cast(component); 25 | collider->isCollisionEnabled(m_Value); 26 | } 27 | 28 | void KeyFrameIsCollisionEnabled::applyInterpolation(ActorComponent* component, float time, KeyFrame* toFrame, float mix) 29 | { 30 | apply(component, mix); 31 | } -------------------------------------------------------------------------------- /flare_skia/src/skr_stroke.cpp: -------------------------------------------------------------------------------- 1 | #include "flare_skia/skr_stroke.hpp" 2 | #include "flare/paint/actor_stroke.hpp" 3 | #include "flare_skia/to_skia.hpp" 4 | 5 | using namespace flare; 6 | 7 | void SkrStroke::initializeGraphics() 8 | { 9 | m_ActorStroke = dynamic_cast(this); 10 | m_Paint.setStyle(SkPaint::Style::kStroke_Style); 11 | m_Paint.setAntiAlias(true); 12 | assert(m_ActorStroke != nullptr); 13 | } 14 | 15 | void SkrStroke::updatePaint() 16 | { 17 | m_Paint.setStrokeWidth(m_ActorStroke->width()); 18 | m_Paint.setStrokeCap(ToSkia::convert(m_ActorStroke->cap())); 19 | m_Paint.setStrokeJoin(ToSkia::convert(m_ActorStroke->join())); 20 | } 21 | 22 | void SkrStroke::paint(SkCanvas* canvas, SkPath& path) 23 | { 24 | if(m_ActorStroke->width() == 0) 25 | { 26 | return; 27 | } 28 | m_ActorStroke->validatePaint(); 29 | if(m_ActorStroke->trimPath() != TrimPath::Off) 30 | { 31 | // TODO: Trim Path 32 | } 33 | canvas->drawPath(path, m_Paint); 34 | } -------------------------------------------------------------------------------- /flare/include/flare/paint/actor_color_stroke.hpp: -------------------------------------------------------------------------------- 1 | #ifndef _FLARE_ACTOR_COLOR_STROKE_HPP_ 2 | #define _FLARE_ACTOR_COLOR_STROKE_HPP_ 3 | 4 | #include "flare/paint/actor_color.hpp" 5 | #include "flare/paint/actor_stroke.hpp" 6 | 7 | namespace flare 8 | { 9 | class BlockReader; 10 | class ActorArtboard; 11 | 12 | class ActorColorStroke : public ActorColor, public ActorStroke 13 | { 14 | public: 15 | ActorColorStroke(); 16 | void copy(const ActorColorStroke* stroke, ActorArtboard* artboard); 17 | static ActorColorStroke* read(ActorArtboard* artboard, BlockReader* reader, ActorColorStroke* component); 18 | void onShapeChanged(ActorShape* from, ActorShape* to) override; 19 | void initializeGraphics() override; 20 | void markPathEffectsDirty() override; 21 | void markPaintDirty() override { ActorColor::markPaintDirty(); } 22 | void validatePaint() override { ActorColor::validatePaint(); } 23 | ActorComponent* makeInstance(ActorArtboard* artboard) const override; 24 | }; 25 | } // namespace flare 26 | 27 | #endif -------------------------------------------------------------------------------- /flare_skia/src/skr_drawable.cpp: -------------------------------------------------------------------------------- 1 | #include "flare_skia/skr_drawable.hpp" 2 | #include "flare/actor_node.hpp" 3 | #include "flare_skia/skr_actor_shape.hpp" 4 | 5 | using namespace flare; 6 | 7 | void SkrDrawable::updateClips(ActorNode* node) 8 | { 9 | m_ClippingShapes.clear(); 10 | 11 | ActorNode* clipSearch = node; 12 | while (clipSearch != nullptr) 13 | { 14 | const std::vector& clips = clipSearch->clips(); 15 | 16 | if (clips.size() > 0) 17 | { 18 | std::vector clippingLevel; 19 | for (const ActorNodeClip& clip : clips) 20 | { 21 | clip.node->all([&](ActorNode* child) { 22 | if (child->type() == ComponentType::ActorShape) 23 | { 24 | SkrActorShape* shape = static_cast(child); 25 | if (shape != nullptr) 26 | { 27 | clippingLevel.push_back(shape); 28 | } 29 | } 30 | 31 | return true; 32 | }); 33 | } 34 | m_ClippingShapes.emplace_back(clippingLevel); 35 | } 36 | clipSearch = clipSearch->parent(); 37 | } 38 | } -------------------------------------------------------------------------------- /flare/src/actor_bone.cpp: -------------------------------------------------------------------------------- 1 | #include "flare/actor_bone.hpp" 2 | #include "flare/block_reader.hpp" 3 | 4 | using namespace flare; 5 | 6 | ActorBone::ActorBone() : Base(ComponentType::ActorBone), m_FirstBone(nullptr), m_Jelly(nullptr) {} 7 | 8 | ActorBone* ActorBone::read(ActorArtboard* artboard, BlockReader* reader, ActorBone* node) 9 | { 10 | if (node == nullptr) 11 | { 12 | node = new ActorBone(); 13 | } 14 | 15 | Base::read(artboard, reader, node); 16 | 17 | return node; 18 | } 19 | 20 | ActorComponent* ActorBone::makeInstance(ActorArtboard* artboard) const 21 | { 22 | ActorBone* instanceNode = new ActorBone(); 23 | instanceNode->copy(this, artboard); 24 | return instanceNode; 25 | } 26 | 27 | void ActorBone::completeResolve() 28 | { 29 | Base::completeResolve(); 30 | for (ActorNode* node : m_Children) 31 | { 32 | if (node->type() == ComponentType::ActorBone) 33 | { 34 | ActorBone* bone = static_cast(node); 35 | if (bone != nullptr) 36 | { 37 | m_FirstBone = bone; 38 | break; 39 | } 40 | } 41 | } 42 | } -------------------------------------------------------------------------------- /flare/include/flare/binary_reader.hpp: -------------------------------------------------------------------------------- 1 | #ifndef _FLARE_BINARYREADER_HPP_ 2 | #define _FLARE_BINARYREADER_HPP_ 3 | 4 | #include 5 | 6 | namespace flare 7 | { 8 | class BinaryReader 9 | { 10 | public: 11 | enum Endian 12 | { 13 | BigEndian, 14 | LittleEndian 15 | }; 16 | 17 | protected: 18 | unsigned char* m_Data; 19 | unsigned int m_DataLength; 20 | unsigned int m_DataPosition; 21 | bool m_SwapEndianness; 22 | 23 | public: 24 | BinaryReader(unsigned char* data, unsigned int length, Endian endianness = LittleEndian); 25 | 26 | unsigned char readUint8(); 27 | unsigned int read(unsigned char* bytes, unsigned int length); 28 | void readFloat32Array(float* numbers, unsigned int length); 29 | void readUint16Array(unsigned short* numbers, unsigned int length); 30 | int readInt32(); 31 | unsigned int readUint32(); 32 | float readFloat32(); 33 | double readFloat64(); 34 | short readInt16(); 35 | unsigned short readUint16(); 36 | std::string readString(); 37 | unsigned long readUint64(); 38 | }; 39 | } //namespace flare 40 | #endif -------------------------------------------------------------------------------- /flare/include/flare/paint/actor_gradient_fill.hpp: -------------------------------------------------------------------------------- 1 | #ifndef _FLARE_ACTOR_GRADIENT_FILL_HPP_ 2 | #define _FLARE_ACTOR_GRADIENT_FILL_HPP_ 3 | 4 | #include "flare/paint/actor_fill.hpp" 5 | #include "flare/paint/actor_gradient_color.hpp" 6 | 7 | namespace flare 8 | { 9 | class BlockReader; 10 | class ActorArtboard; 11 | 12 | class ActorGradientFill : public ActorGradientColor, public ActorFill 13 | { 14 | typedef ActorGradientColor Base; 15 | 16 | public: 17 | ActorGradientFill(); 18 | void copy(const ActorGradientFill* gradientColor, ActorArtboard* artboard); 19 | static ActorGradientFill* read(ActorArtboard* artboard, BlockReader* reader, ActorGradientFill* component); 20 | void onShapeChanged(ActorShape* from, ActorShape* to) override; 21 | ActorComponent* makeInstance(ActorArtboard* artboard) const override; 22 | void initializeGraphics() override; 23 | void validatePaint() override { ActorGradientColor::validatePaint(); } 24 | void markPaintDirty() override { ActorGradientColor::markPaintDirty(); } 25 | }; 26 | } // namespace flare 27 | 28 | #endif -------------------------------------------------------------------------------- /flare/src/actor_jelly_bone.cpp: -------------------------------------------------------------------------------- 1 | #include "flare/actor_jelly_bone.hpp" 2 | #include "flare/block_reader.hpp" 3 | 4 | using namespace flare; 5 | 6 | ActorJellyBone::ActorJellyBone() : Base(ComponentType::ActorJellyBone) {} 7 | 8 | ActorComponent* ActorJellyBone::makeInstance(ActorArtboard* artboard) const 9 | { 10 | ActorJellyBone* instanceNode = new ActorJellyBone(); 11 | instanceNode->copy(this, artboard); 12 | return instanceNode; 13 | } 14 | 15 | ActorJellyBone* ActorJellyBone::read(ActorArtboard* artboard, BlockReader* reader, ActorJellyBone* node) 16 | { 17 | if (node == nullptr) 18 | { 19 | node = new ActorJellyBone(); 20 | } 21 | 22 | // The Jelly Bone has a specialized read that doesn't go down the typical node path, this is 23 | // because majority of the transform properties of the Jelly Bone are controlled by the Jelly 24 | // Controller and are unnecessary for serialization. 25 | ActorComponent::read(artboard, reader, node); 26 | node->m_Opacity = reader->readFloat32(); 27 | node->m_IsCollapsedVisibility = reader->readUint8() == 1; 28 | return node; 29 | } -------------------------------------------------------------------------------- /flare_skia/src/skr_gradient_fill.cpp: -------------------------------------------------------------------------------- 1 | #include "flare_skia/skr_gradient_fill.hpp" 2 | #include "flare/actor_shape.hpp" 3 | #include "flare_skia/to_skia.hpp" 4 | 5 | #include "SkGradientShader.h" 6 | #include "SkShader.h" 7 | #include 8 | 9 | using namespace flare; 10 | 11 | void SkrGradientFill::updatePaint() 12 | { 13 | m_Paint.setBlendMode(ToSkia::convert(m_Shape->blendMode())); 14 | 15 | const std::vector& stops = colorStops(); 16 | int numStops = stops.size() / 5; 17 | SkPoint points[2] = {ToSkia::convert(renderStart()), ToSkia::convert(renderEnd())}; 18 | SkColor colors[numStops]; 19 | SkScalar pos[numStops]; 20 | 21 | flare::Color color; 22 | int idx = 0; 23 | for (int i = 0; i < numStops; i++) 24 | { 25 | color[0] = stops[idx++]; 26 | color[1] = stops[idx++]; 27 | color[2] = stops[idx++]; 28 | color[3] = stops[idx++]; 29 | 30 | colors[i] = ToSkia::convert(color).toSkColor(); 31 | pos[i] = stops[idx++]; 32 | } 33 | 34 | m_Paint.setShader(SkGradientShader::MakeLinear(points, colors, pos, numStops, SkTileMode::kClamp, 0, nullptr)); 35 | onPaintUpdated(); 36 | } -------------------------------------------------------------------------------- /flare/include/flare/paint/actor_radial_gradient_fill.hpp: -------------------------------------------------------------------------------- 1 | #ifndef _FLARE_ACTOR_RADIAL_GRADIENT_FILL_HPP_ 2 | #define _FLARE_ACTOR_RADIAL_GRADIENT_FILL_HPP_ 3 | 4 | #include "flare/paint/actor_fill.hpp" 5 | #include "flare/paint/actor_radial_gradient.hpp" 6 | 7 | namespace flare 8 | { 9 | class BlockReader; 10 | class ActorArtboard; 11 | 12 | class ActorRadialGradientFill : public ActorRadialGradient, public ActorFill 13 | { 14 | typedef ActorRadialGradient Base; 15 | 16 | public: 17 | ActorRadialGradientFill(); 18 | void copy(const ActorRadialGradientFill* gradientColor, ActorArtboard* artboard); 19 | static ActorRadialGradientFill* read(ActorArtboard* artboard, BlockReader* reader, ActorRadialGradientFill* component); 20 | void onShapeChanged(ActorShape* from, ActorShape* to) override; 21 | ActorComponent* makeInstance(ActorArtboard* artboard) const override; 22 | void initializeGraphics() override; 23 | void validatePaint() override { ActorGradientColor::validatePaint(); } 24 | void markPaintDirty() override { ActorRadialGradient::markPaintDirty(); } 25 | }; 26 | } // namespace flare 27 | 28 | #endif -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | MIT License 2 | 3 | Copyright (c) 2018 2D, Inc 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy 6 | of this software and associated documentation files (the "Software"), to deal 7 | in the Software without restriction, including without limitation the rights 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | copies of the Software, and to permit persons to whom the Software is 10 | furnished to do so, subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in all 13 | copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 21 | SOFTWARE. 22 | -------------------------------------------------------------------------------- /flare/include/flare/paint/actor_gradient_stroke.hpp: -------------------------------------------------------------------------------- 1 | #ifndef _FLARE_ACTOR_GRADIENT_STROKE_HPP_ 2 | #define _FLARE_ACTOR_GRADIENT_STROKE_HPP_ 3 | 4 | #include "flare/paint/actor_stroke.hpp" 5 | #include "flare/paint/actor_gradient_color.hpp" 6 | 7 | namespace flare 8 | { 9 | class BlockReader; 10 | class ActorArtboard; 11 | 12 | class ActorGradientStroke : public ActorGradientColor, public ActorStroke 13 | { 14 | typedef ActorGradientColor Base; 15 | 16 | public: 17 | ActorGradientStroke(); 18 | void copy(const ActorGradientStroke* gradientColor, ActorArtboard* artboard); 19 | static ActorGradientStroke* read(ActorArtboard* artboard, BlockReader* reader, ActorGradientStroke* component); 20 | void onShapeChanged(ActorShape* from, ActorShape* to) override; 21 | ActorComponent* makeInstance(ActorArtboard* artboard) const override; 22 | void initializeGraphics() override; 23 | void markPaintDirty() override { ActorGradientColor::markPaintDirty(); } 24 | void markPathEffectsDirty() override; 25 | void validatePaint() override { ActorGradientColor::validatePaint(); } 26 | }; 27 | } // namespace flare 28 | 29 | #endif -------------------------------------------------------------------------------- /flare_skia/src/skr_gradient_stroke.cpp: -------------------------------------------------------------------------------- 1 | #include "flare_skia/skr_gradient_stroke.hpp" 2 | #include "flare/actor_shape.hpp" 3 | #include "flare_skia/to_skia.hpp" 4 | 5 | #include "SkGradientShader.h" 6 | #include "SkShader.h" 7 | #include 8 | 9 | using namespace flare; 10 | 11 | void SkrGradientStroke::updatePaint() 12 | { 13 | m_Paint.setBlendMode(ToSkia::convert(m_Shape->blendMode())); 14 | SkrStroke::updatePaint(); 15 | 16 | const std::vector& stops = colorStops(); 17 | int numStops = stops.size() / 5; 18 | SkPoint points[2] = {ToSkia::convert(renderStart()), ToSkia::convert(renderEnd())}; 19 | SkColor colors[numStops]; 20 | SkScalar pos[numStops]; 21 | 22 | flare::Color color; 23 | int idx = 0; 24 | for (int i = 0; i < numStops; i++) 25 | { 26 | color[0] = stops[idx++]; 27 | color[1] = stops[idx++]; 28 | color[2] = stops[idx++]; 29 | color[3] = stops[idx++]; 30 | 31 | colors[i] = ToSkia::convert(color).toSkColor(); 32 | pos[i] = stops[idx++]; 33 | } 34 | 35 | m_Paint.setShader(SkGradientShader::MakeLinear(points, colors, pos, numStops, SkTileMode::kClamp, 0, nullptr)); 36 | onPaintUpdated(); 37 | } -------------------------------------------------------------------------------- /flare/include/flare/nested_actor_node.hpp: -------------------------------------------------------------------------------- 1 | #ifndef _FLARE_NESTEDACTORNODE_HPP_ 2 | #define _FLARE_NESTEDACTORNODE_HPP_ 3 | 4 | #include "actor_drawable.hpp" 5 | 6 | namespace flare 7 | { 8 | class Actor; 9 | class BlockReader; 10 | class NestedActorAsset; 11 | 12 | class NestedActorNode : public ActorDrawable 13 | { 14 | typedef ActorDrawable Base; 15 | 16 | private: 17 | NestedActorAsset* m_Asset; 18 | ActorArtboard* m_ArtboardInstance; 19 | ActorArtboard* m_TransformArtboardInstance; 20 | 21 | protected: 22 | virtual void setArtboardInstance(ActorArtboard* instance); 23 | 24 | public: 25 | NestedActorNode(); 26 | virtual ~NestedActorNode(); 27 | 28 | ActorComponent* makeInstance(ActorArtboard* resetActor) const override; 29 | void updateWorldTransform() override; 30 | void copy(const NestedActorNode* node, ActorArtboard* resetActor); 31 | void advance(float elapsedSeconds); 32 | void transformNested(bool transformIt); 33 | void initializeGraphics() override; 34 | 35 | static NestedActorNode* read(ActorArtboard* actor, BlockReader* reader, NestedActorNode* node = NULL); 36 | }; 37 | } //namespace flare 38 | #endif -------------------------------------------------------------------------------- /flare/include/flare/actor_drawable.hpp: -------------------------------------------------------------------------------- 1 | #ifndef _FLARE_ACTORDRAWABLE_HPP_ 2 | #define _FLARE_ACTORDRAWABLE_HPP_ 3 | 4 | #include "actor_node.hpp" 5 | #include "blend_mode.hpp" 6 | 7 | namespace flare 8 | { 9 | class Actor; 10 | class BlockReader; 11 | class ActorNode; 12 | 13 | class ActorDrawable : public ActorNode 14 | { 15 | typedef ActorNode Base; 16 | 17 | protected: 18 | // TODO: implement clips. 19 | int m_DrawOrder; 20 | bool m_IsHidden; 21 | BlendMode m_BlendMode; 22 | virtual void onBlendModeChanged(BlendMode from, BlendMode to); 23 | 24 | public: 25 | ActorDrawable(ComponentType type); 26 | void copy(const ActorDrawable* node, ActorArtboard* artboard); 27 | int drawOrder() const; 28 | void drawOrder(int order); 29 | bool isHidden() const; 30 | void isHidden(bool value); 31 | BlendMode blendMode() const; 32 | void blendMode(BlendMode value); 33 | static ActorDrawable* read(ActorArtboard* artboard, BlockReader* reader, ActorDrawable* component); 34 | virtual void initializeGraphics() = 0; 35 | 36 | bool doesDraw() const { return !m_IsHidden && !renderCollapsed(); } 37 | }; 38 | } // namespace flare 39 | #endif -------------------------------------------------------------------------------- /flare_skia/include/flare_skia/skr_actor.hpp: -------------------------------------------------------------------------------- 1 | #ifndef _SKR_ACTOR_HPP_ 2 | #define _SKR_ACTOR_HPP_ 3 | 4 | #include "flare/actor.hpp" 5 | 6 | namespace flare 7 | { 8 | class SkrActor : public Actor 9 | { 10 | typedef Actor Base; 11 | 12 | public: 13 | ActorArtboard* makeArtboard() override; 14 | ActorImage* makeImageNode() override; 15 | ActorStaticMesh* makeStaticMeshNode() override; 16 | ActorShape* makeShape() override; 17 | ActorColorFill* makeColorFill() override; 18 | ActorColorStroke* makeColorStroke() override; 19 | ActorGradientFill* makeGradientFill() override; 20 | ActorGradientStroke* makeGradientStroke() override; 21 | ActorRadialGradientFill* makeRadialGradientFill() override; 22 | ActorRadialGradientStroke* makeRadialGradientStroke() override; 23 | ActorPath* makePath() override; 24 | ActorRectangle* makeRectangle() override; 25 | ActorTriangle* makeTriangle() override; 26 | ActorPolygon* makePolygon() override; 27 | ActorStar* makeStar() override; 28 | ActorEllipse* makeEllipse() override; 29 | ActorDrawableProxy* makeDrawableProxy(ActorDrawable* drawable) override; 30 | }; 31 | } // namespace flare 32 | #endif -------------------------------------------------------------------------------- /test/build/genie.lua: -------------------------------------------------------------------------------- 1 | BASE_DIR = path.getabsolute("../..") 2 | 3 | solution "test" 4 | 5 | configurations 6 | { 7 | "Debug", 8 | "Release" 9 | } 10 | 11 | configuration "Debug" 12 | flags 13 | { 14 | "Symbols" 15 | } 16 | 17 | location("./"); 18 | dofile(path.join(BASE_DIR, "flare_math/build/flare_math.lua")) 19 | location("./"); 20 | dofile(path.join(BASE_DIR, "flare/build/flare.lua")) 21 | 22 | project "test" 23 | kind "ConsoleApp" 24 | language "C++" 25 | 26 | configuration { "Debug" } 27 | targetdir "./debug/bin" 28 | objdir "./debug/bin/obj" 29 | 30 | configuration { "Release" } 31 | targetdir "./release/bin" 32 | objdir "./release/bin/obj" 33 | 34 | configuration "macosx" 35 | links { "Cocoa.framework", "IOKit.framework", "flare", "flare_math" } 36 | includedirs { "/usr/local/include" } 37 | libdirs { "/usr/local/lib" } 38 | 39 | configuration { } 40 | 41 | includedirs 42 | { 43 | "../../flare/include", 44 | "../../flare_math/include" 45 | } 46 | 47 | buildoptions_cpp 48 | { 49 | "-std=c++11", 50 | "-fembed-bitcode" 51 | } 52 | 53 | files 54 | { 55 | "../src/**.cpp" 56 | } 57 | 58 | targetname "test" -------------------------------------------------------------------------------- /flare/include/flare/actor_transform_constraint.hpp: -------------------------------------------------------------------------------- 1 | #ifndef _FLARE_ACTORTRANSFORMCONSTRAINT_HPP_ 2 | #define _FLARE_ACTORTRANSFORMCONSTRAINT_HPP_ 3 | 4 | #include "actor_targeted_constraint.hpp" 5 | #include "transform_space.hpp" 6 | #include "flare_math/mat2d.hpp" 7 | #include "flare_math/transform_components.hpp" 8 | #include 9 | 10 | namespace flare 11 | { 12 | class Actor; 13 | 14 | class ActorTransformConstraint : public ActorTargetedConstraint 15 | { 16 | typedef ActorTargetedConstraint Base; 17 | 18 | private: 19 | TransformSpace m_SourceSpace; 20 | TransformSpace m_DestSpace; 21 | TransformComponents m_ComponentsA; 22 | TransformComponents m_ComponentsB; 23 | 24 | public: 25 | ActorTransformConstraint(); 26 | 27 | ActorComponent* makeInstance(ActorArtboard* artboard) const override; 28 | void copy(const ActorTransformConstraint* node, ActorArtboard* artboard); 29 | void constrain(ActorNode* node) override; 30 | 31 | static ActorTransformConstraint* read(ActorArtboard* artboard, BlockReader* reader, 32 | ActorTransformConstraint* node = nullptr); 33 | }; 34 | } //namespace flare 35 | 36 | #endif -------------------------------------------------------------------------------- /flare/src/path/path_point.cpp: -------------------------------------------------------------------------------- 1 | #include "flare/path/path_point.hpp" 2 | #include "flare/block_reader.hpp" 3 | 4 | using namespace flare; 5 | 6 | PathPoint::PathPoint(PointType type) : m_Type(type) {} 7 | PathPoint::PathPoint(PointType type, Vec2D translation) : m_Type(type), m_Translation(translation) {} 8 | 9 | PathPoint::~PathPoint() {} 10 | 11 | PointType PathPoint::type() const { return m_Type; } 12 | 13 | void PathPoint::copy(const PathPoint* from) 14 | { 15 | m_Type = from->m_Type; 16 | Vec2D::copy(m_Translation, from->m_Translation); 17 | m_Weights = std::vector(from->m_Weights); 18 | } 19 | 20 | void PathPoint::setWeightCount(int count) { m_Weights.resize(count); } 21 | 22 | void PathPoint::read(BlockReader* reader, bool isConnectedToBones) 23 | { 24 | reader->read(m_Translation); 25 | readPoint(reader, isConnectedToBones); 26 | if (!m_Weights.empty()) 27 | { 28 | reader->readFloat32Array(&m_Weights[0], m_Weights.size()); 29 | } 30 | } 31 | 32 | PathPoint* PathPoint::transformed(const Mat2D& transform) 33 | { 34 | PathPoint* result = makeInstance(); 35 | Vec2D::transform(result->m_Translation, result->m_Translation, transform); 36 | return result; 37 | } -------------------------------------------------------------------------------- /flare/include/flare/animation/actor_animation_instance.hpp: -------------------------------------------------------------------------------- 1 | #ifndef _FLARE_ACTORANIMATIONINSTANCE_HPP_ 2 | #define _FLARE_ACTORANIMATIONINSTANCE_HPP_ 3 | 4 | #include 5 | #include 6 | #include "actor_animation.hpp" 7 | 8 | namespace flare 9 | { 10 | class ActorAnimationInstance 11 | { 12 | private: 13 | ActorArtboard* m_Artboard; 14 | ActorAnimation* m_Animation; 15 | float m_Time; 16 | float m_Min; 17 | float m_Max; 18 | float m_Range; 19 | bool m_Loop; 20 | std::vector m_Events; 21 | void* m_EventCallbackUserData; 22 | ActorAnimationEvent::Callback m_EventCallback; 23 | 24 | public: 25 | 26 | ActorAnimationInstance(ActorArtboard* artboard, ActorAnimation* animation); 27 | ~ActorAnimationInstance(); 28 | 29 | float duration() const; 30 | float min() const; 31 | float max() const; 32 | float time() const; 33 | void time(float value); 34 | bool isLooping() const; 35 | void isLooping(bool isIt); 36 | 37 | void advance(float seconds); 38 | void apply(float mix); 39 | 40 | void eventCallback(ActorAnimationEvent::Callback callback, void* userdata = nullptr); 41 | 42 | }; 43 | } 44 | #endif -------------------------------------------------------------------------------- /flare/include/flare/paint/actor_radial_gradient_stroke.hpp: -------------------------------------------------------------------------------- 1 | #ifndef _FLARE_ACTOR_RADIAL_GRADIENT_STROKE_HPP_ 2 | #define _FLARE_ACTOR_RADIAL_GRADIENT_STROKE_HPP_ 3 | 4 | #include "flare/paint/actor_stroke.hpp" 5 | #include "flare/paint/actor_radial_gradient.hpp" 6 | 7 | namespace flare 8 | { 9 | class BlockReader; 10 | class ActorArtboard; 11 | 12 | class ActorRadialGradientStroke : public ActorRadialGradient, public ActorStroke 13 | { 14 | typedef ActorRadialGradient Base; 15 | 16 | public: 17 | ActorRadialGradientStroke(); 18 | void copy(const ActorRadialGradientStroke* gradientColor, ActorArtboard* artboard); 19 | static ActorRadialGradientStroke* read(ActorArtboard* artboard, BlockReader* reader, ActorRadialGradientStroke* component); 20 | void onShapeChanged(ActorShape* from, ActorShape* to) override; 21 | ActorComponent* makeInstance(ActorArtboard* artboard) const override; 22 | void initializeGraphics() override; 23 | void markPathEffectsDirty() override; 24 | void markPaintDirty() override { ActorRadialGradient::markPaintDirty(); } 25 | void validatePaint() override { ActorRadialGradient::validatePaint(); } 26 | }; 27 | } // namespace flare 28 | 29 | #endif -------------------------------------------------------------------------------- /flare/include/flare/path/actor_base_path.hpp: -------------------------------------------------------------------------------- 1 | #ifndef _FLARE_ACTORBASEPATH_HPP_ 2 | #define _FLARE_ACTORBASEPATH_HPP_ 3 | 4 | #include "flare_math/mat2d.hpp" 5 | #include "flare_math/aabb.hpp" 6 | #include "flare/actor_drawable.hpp" 7 | #include "flare/path/path_point.hpp" 8 | #include "flare/actor_node.hpp" 9 | #include 10 | 11 | namespace flare 12 | { 13 | class ActorShape; 14 | class ActorBasePath : public ActorNode 15 | { 16 | typedef ActorNode Base; 17 | private: 18 | ActorShape* m_Shape; 19 | protected: 20 | void onParentChanged(ActorNode* from, ActorNode* to) override; 21 | 22 | public: 23 | ActorBasePath(ComponentType type); 24 | 25 | virtual bool isPathInWorldSpace() const = 0; 26 | const virtual Mat2D& pathTransform() const = 0; 27 | virtual const std::vector& points() = 0; 28 | virtual const std::vector& deformedPoints() = 0; 29 | virtual bool isClosed() = 0; 30 | 31 | AABB getPathAABB(); 32 | AABB getPathOBB(); 33 | virtual void invalidateDrawable(); 34 | ActorShape* shape() const { return m_Shape; } 35 | }; 36 | } // namespace flare 37 | #endif -------------------------------------------------------------------------------- /flare_skia/src/skr_radial_gradient_fill.cpp: -------------------------------------------------------------------------------- 1 | #include "flare_skia/skr_radial_gradient_fill.hpp" 2 | #include "flare/actor_shape.hpp" 3 | #include "flare_skia/to_skia.hpp" 4 | 5 | #include "SkGradientShader.h" 6 | #include "SkShader.h" 7 | #include 8 | 9 | using namespace flare; 10 | 11 | void SkrRadialGradientFill::updatePaint() 12 | { 13 | m_Paint.setBlendMode(ToSkia::convert(m_Shape->blendMode())); 14 | 15 | double radius = Vec2D::distance(renderStart(), renderEnd()); 16 | const std::vector& stops = colorStops(); 17 | int numStops = stops.size() / 5; 18 | SkPoint points[2] = {ToSkia::convert(renderStart()), ToSkia::convert(renderEnd())}; 19 | SkColor colors[numStops]; 20 | SkScalar pos[numStops]; 21 | 22 | flare::Color color; 23 | int idx = 0; 24 | for (int i = 0; i < numStops; i++) 25 | { 26 | color[0] = stops[idx++]; 27 | color[1] = stops[idx++]; 28 | color[2] = stops[idx++]; 29 | color[3] = stops[idx++]; 30 | 31 | colors[i] = ToSkia::convert(color).toSkColor(); 32 | pos[i] = stops[idx++]; 33 | } 34 | 35 | m_Paint.setShader(SkGradientShader::MakeRadial(ToSkia::convert(renderStart()), radius, colors, pos, numStops, SkTileMode::kClamp, 0, nullptr)); 36 | onPaintUpdated(); 37 | } -------------------------------------------------------------------------------- /flare/src/paint/actor_color_fill.cpp: -------------------------------------------------------------------------------- 1 | #include "flare/paint/actor_color_fill.hpp" 2 | #include "flare/actor_shape.hpp" 3 | #include "flare/actor_artboard.hpp" 4 | #include "flare/actor.hpp" 5 | 6 | using namespace flare; 7 | 8 | ActorColorFill::ActorColorFill() : ActorColor(ComponentType::ColorFill) {} 9 | 10 | void ActorColorFill::copy(const ActorColorFill* fill, ActorArtboard* artboard) 11 | { 12 | ActorColor::copy(fill, artboard); 13 | ActorFill::copy(fill, artboard); 14 | } 15 | 16 | ActorColorFill* ActorColorFill::read(ActorArtboard* artboard, BlockReader* reader, ActorColorFill* component) 17 | { 18 | ActorColor::read(artboard, reader, component); 19 | ActorFill::read(artboard, reader, component); 20 | return component; 21 | } 22 | 23 | void ActorColorFill::onShapeChanged(ActorShape* from, ActorShape* to) 24 | { 25 | if (from != nullptr) 26 | { 27 | from->removeFill(this); 28 | } 29 | if (to != nullptr) 30 | { 31 | to->addFill(this); 32 | } 33 | } 34 | 35 | ActorComponent* ActorColorFill::makeInstance(ActorArtboard* artboard) const 36 | { 37 | ActorColorFill* instanceNode = artboard->actor()->makeColorFill(); 38 | instanceNode->copy(this, artboard); 39 | return instanceNode; 40 | } 41 | 42 | void ActorColorFill::initializeGraphics() {} -------------------------------------------------------------------------------- /flare/include/flare/actor_rotation_constraint.hpp: -------------------------------------------------------------------------------- 1 | #ifndef _FLARE_ACTORROTATIONCONSTRAINT_HPP_ 2 | #define _FLARE_ACTORROTATIONCONSTRAINT_HPP_ 3 | 4 | #include "actor_targeted_constraint.hpp" 5 | #include "transform_space.hpp" 6 | #include "flare_math/transform_components.hpp" 7 | 8 | namespace flare 9 | { 10 | class ActorRotationConstraint : public ActorTargetedConstraint 11 | { 12 | typedef ActorTargetedConstraint Base; 13 | 14 | private: 15 | bool m_Copy; 16 | float m_Scale; 17 | bool m_EnableMin; 18 | bool m_EnableMax; 19 | float m_Min; 20 | float m_Max; 21 | bool m_Offset; 22 | TransformSpace m_SourceSpace; 23 | TransformSpace m_DestSpace; 24 | TransformSpace m_MinMaxSpace; 25 | TransformComponents m_ComponentsA; 26 | TransformComponents m_ComponentsB; 27 | 28 | public: 29 | ActorRotationConstraint(); 30 | void copy(const ActorRotationConstraint* node, ActorArtboard* artboard); 31 | ActorComponent* makeInstance(ActorArtboard* artboard) const override; 32 | static ActorRotationConstraint* read(ActorArtboard* artboard, BlockReader* reader, 33 | ActorRotationConstraint* constraint = nullptr); 34 | void constrain(ActorNode* node) override; 35 | }; 36 | } //namespace flare 37 | 38 | #endif -------------------------------------------------------------------------------- /flare_skia/src/skr_radial_gradient_stroke.cpp: -------------------------------------------------------------------------------- 1 | #include "flare_skia/skr_radial_gradient_stroke.hpp" 2 | #include "flare/actor_shape.hpp" 3 | #include "flare_skia/to_skia.hpp" 4 | 5 | #include "SkGradientShader.h" 6 | #include "SkShader.h" 7 | #include 8 | 9 | using namespace flare; 10 | 11 | void SkrRadialGradientStroke::updatePaint() 12 | { 13 | m_Paint.setBlendMode(ToSkia::convert(m_Shape->blendMode())); 14 | SkrStroke::updatePaint(); 15 | 16 | double radius = Vec2D::distance(renderStart(), renderEnd()); 17 | const std::vector& stops = colorStops(); 18 | int numStops = stops.size() / 5; 19 | SkPoint points[2] = {ToSkia::convert(renderStart()), ToSkia::convert(renderEnd())}; 20 | SkColor colors[numStops]; 21 | SkScalar pos[numStops]; 22 | 23 | flare::Color color; 24 | int idx = 0; 25 | for (int i = 0; i < numStops; i++) 26 | { 27 | color[0] = stops[idx++]; 28 | color[1] = stops[idx++]; 29 | color[2] = stops[idx++]; 30 | color[3] = stops[idx++]; 31 | 32 | colors[i] = ToSkia::convert(color).toSkColor(); 33 | pos[i] = stops[idx++]; 34 | } 35 | 36 | m_Paint.setShader(SkGradientShader::MakeRadial(ToSkia::convert(renderStart()), radius, colors, pos, numStops, SkTileMode::kClamp, 0, nullptr)); 37 | onPaintUpdated(); 38 | } -------------------------------------------------------------------------------- /flare/include/flare/actor_axis_constraint.hpp: -------------------------------------------------------------------------------- 1 | #ifndef _FLARE_ACTORAXISCONSTRAINT_HPP_ 2 | #define _FLARE_ACTORAXISCONSTRAINT_HPP_ 3 | 4 | #include "actor_bone.hpp" 5 | #include "actor_targeted_constraint.hpp" 6 | #include "transform_space.hpp" 7 | #include "flare_math/mat2d.hpp" 8 | #include "flare_math/transform_components.hpp" 9 | #include 10 | 11 | namespace flare 12 | { 13 | class Actor; 14 | 15 | class ActorAxisConstraint : public ActorTargetedConstraint 16 | { 17 | typedef ActorTargetedConstraint Base; 18 | 19 | protected: 20 | bool m_CopyX; 21 | bool m_CopyY; 22 | float m_ScaleX; 23 | float m_ScaleY; 24 | bool m_EnableMinX; 25 | bool m_EnableMinY; 26 | bool m_EnableMaxX; 27 | bool m_EnableMaxY; 28 | float m_MaxX; 29 | float m_MaxY; 30 | float m_MinX; 31 | float m_MinY; 32 | bool m_Offset; 33 | TransformSpace m_SourceSpace; 34 | TransformSpace m_DestSpace; 35 | TransformSpace m_MinMaxSpace; 36 | 37 | public: 38 | ActorAxisConstraint(ActorArtboard* artboard, ComponentType type); 39 | void copy(const ActorAxisConstraint* node, ActorArtboard* artboard); 40 | 41 | static ActorAxisConstraint* read(ActorArtboard* artboard, BlockReader* reader, ActorAxisConstraint* node); 42 | }; 43 | } // namespace flare 44 | 45 | #endif -------------------------------------------------------------------------------- /flare/include/flare/actor_skinnable.hpp: -------------------------------------------------------------------------------- 1 | #ifndef _FLARE_ACTORSKINNABLE_HPP_ 2 | #define _FLARE_ACTORSKINNABLE_HPP_ 3 | 4 | #include "actor_node.hpp" 5 | #include "blend_mode.hpp" 6 | #include 7 | 8 | namespace flare 9 | { 10 | class Actor; 11 | class BlockReader; 12 | class ActorNode; 13 | class ActorSkin; 14 | 15 | class ActorSkinnable 16 | { 17 | friend class ActorSkin; 18 | 19 | struct SkinnedBone 20 | { 21 | union { 22 | int boneIndex; 23 | ActorNode* node; 24 | }; 25 | Mat2D bind; 26 | Mat2D inverseBind; 27 | 28 | SkinnedBone(); 29 | }; 30 | 31 | private: 32 | ActorSkin* m_Skin; 33 | std::vector m_ConnectedBones; 34 | 35 | public: 36 | ActorSkinnable(); 37 | ActorSkin* skin() const; 38 | bool isConnectedToBones() const { return !m_ConnectedBones.empty(); } 39 | static ActorSkinnable* read(ActorArtboard* artboard, BlockReader* reader, ActorSkinnable* skinnable); 40 | void resolveSkinnable(ActorComponent** components, int numComponents); 41 | void copySkinnable(const ActorSkinnable* skinnable, ActorArtboard* artboard); 42 | 43 | virtual void invalidateDrawable() = 0; 44 | virtual void overrideWorldTransform(const Mat2D& transform) = 0; 45 | }; 46 | } // namespace flare 47 | #endif -------------------------------------------------------------------------------- /flare/src/paint/actor_gradient_fill.cpp: -------------------------------------------------------------------------------- 1 | #include "flare/paint/actor_gradient_fill.hpp" 2 | #include "flare/actor.hpp" 3 | #include "flare/actor_artboard.hpp" 4 | #include "flare/actor_shape.hpp" 5 | 6 | using namespace flare; 7 | 8 | ActorGradientFill::ActorGradientFill() : Base(ComponentType::GradientFill) {} 9 | 10 | void ActorGradientFill::copy(const ActorGradientFill* fill, ActorArtboard* artboard) 11 | { 12 | Base::copy(fill, artboard); 13 | ActorFill::copy(fill, artboard); 14 | } 15 | 16 | ActorGradientFill* ActorGradientFill::read(ActorArtboard* artboard, BlockReader* reader, ActorGradientFill* component) 17 | { 18 | Base::read(artboard, reader, component); 19 | ActorFill::read(artboard, reader, component); 20 | return component; 21 | } 22 | 23 | void ActorGradientFill::onShapeChanged(ActorShape* from, ActorShape* to) 24 | { 25 | if (from != nullptr) 26 | { 27 | from->removeFill(this); 28 | } 29 | if (to != nullptr) 30 | { 31 | to->addFill(this); 32 | } 33 | } 34 | 35 | ActorComponent* ActorGradientFill::makeInstance(ActorArtboard* artboard) const 36 | { 37 | ActorGradientFill* instanceNode = artboard->actor()->makeGradientFill(); 38 | instanceNode->copy(this, artboard); 39 | return instanceNode; 40 | } 41 | 42 | void ActorGradientFill::initializeGraphics() {} -------------------------------------------------------------------------------- /flare/src/actor_targeted_constraint.cpp: -------------------------------------------------------------------------------- 1 | #include "flare/actor_targeted_constraint.hpp" 2 | #include "flare/actor.hpp" 3 | #include "flare/block_reader.hpp" 4 | 5 | using namespace flare; 6 | 7 | ActorTargetedConstraint::ActorTargetedConstraint(ActorArtboard* artboard, ComponentType type) : 8 | Base(artboard, type), 9 | m_TargetIdx(0) 10 | { 11 | } 12 | 13 | void ActorTargetedConstraint::resolveComponentIndices(ActorComponent** components, int numComponents) 14 | { 15 | Base::resolveComponentIndices(components, numComponents); 16 | if (m_TargetIdx != 0) 17 | { 18 | m_Target = components[m_TargetIdx]; 19 | if (m_Target != nullptr) 20 | { 21 | m_Artboard->addDependency(m_Parent, m_Target); 22 | } 23 | } 24 | } 25 | 26 | void ActorTargetedConstraint::copy(const ActorTargetedConstraint* constraint, ActorArtboard* artboard) 27 | { 28 | Base::copy(constraint, artboard); 29 | 30 | m_TargetIdx = constraint->m_TargetIdx; 31 | } 32 | 33 | ActorTargetedConstraint* ActorTargetedConstraint::read(ActorArtboard* artboard, BlockReader* reader, 34 | ActorTargetedConstraint* constraint) 35 | { 36 | Base::read(artboard, reader, constraint); 37 | constraint->m_TargetIdx = reader->readUint16(); 38 | 39 | return constraint; 40 | } -------------------------------------------------------------------------------- /flare_skia/include/flare_skia/skr_actor_shape.hpp: -------------------------------------------------------------------------------- 1 | #ifndef _SKR_ACTOR_SHAPE_HPP_ 2 | #define _SKR_ACTOR_SHAPE_HPP_ 3 | 4 | #include "flare/actor_shape.hpp" 5 | #include "skr_drawable.hpp" 6 | #include "SkPath.h" 7 | #include 8 | 9 | namespace flare 10 | { 11 | class SkrActorBasePath; 12 | class SkrFill; 13 | class SkrStroke; 14 | 15 | class SkrActorShape : public ActorShape, public SkrDrawable 16 | { 17 | typedef ActorShape Base; 18 | 19 | private: 20 | bool m_IsValid; 21 | SkPath m_Path; 22 | std::vector m_SubPaths; 23 | 24 | // We currently only support rendering a single fill/stroke so we only 25 | // store these two concrete pointers. 26 | SkrStroke* m_Stroke; 27 | SkrFill* m_Fill; 28 | 29 | protected: 30 | void onBlendModeChanged(BlendMode from, BlendMode to) override; 31 | void onRenderOpacityChanged() override; 32 | void onChildrenChanged() override; 33 | 34 | public: 35 | SkrActorShape(); 36 | void invalidateDrawable() override; 37 | 38 | void draw(SkCanvas* canvas) override; 39 | SkPath& path(); 40 | 41 | protected: 42 | void onStrokesChanged() override; 43 | void onFillsChanged() override; 44 | void onClipsChanged() override { SkrDrawable::updateClips(this); } 45 | }; 46 | } // namespace flare 47 | 48 | #endif -------------------------------------------------------------------------------- /flare/src/paint/actor_color_stroke.cpp: -------------------------------------------------------------------------------- 1 | #include "flare/paint/actor_color_stroke.hpp" 2 | #include "flare/actor_shape.hpp" 3 | #include "flare/actor_artboard.hpp" 4 | #include "flare/actor.hpp" 5 | 6 | using namespace flare; 7 | 8 | ActorColorStroke::ActorColorStroke() : ActorColor(ComponentType::ColorStroke) {} 9 | 10 | void ActorColorStroke::copy(const ActorColorStroke* fill, ActorArtboard* artboard) 11 | { 12 | ActorColor::copy(fill, artboard); 13 | ActorStroke::copy(fill, artboard); 14 | } 15 | 16 | ActorColorStroke* ActorColorStroke::read(ActorArtboard* artboard, BlockReader* reader, ActorColorStroke* component) 17 | { 18 | ActorColor::read(artboard, reader, component); 19 | ActorStroke::read(artboard, reader, component); 20 | return component; 21 | } 22 | 23 | void ActorColorStroke::onShapeChanged(ActorShape* from, ActorShape* to) 24 | { 25 | if (from != nullptr) 26 | { 27 | from->removeStroke(this); 28 | } 29 | if (to != nullptr) 30 | { 31 | to->addStroke(this); 32 | } 33 | } 34 | 35 | ActorComponent* ActorColorStroke::makeInstance(ActorArtboard* artboard) const 36 | { 37 | ActorColorStroke* instanceNode = artboard->actor()->makeColorStroke(); 38 | instanceNode->copy(this, artboard); 39 | return instanceNode; 40 | } 41 | 42 | void ActorColorStroke::initializeGraphics() {} 43 | void ActorColorStroke::markPathEffectsDirty() {} -------------------------------------------------------------------------------- /flare/src/paint/actor_radial_gradient.cpp: -------------------------------------------------------------------------------- 1 | #include "flare/actor.hpp" 2 | #include "flare/actor_artboard.hpp" 3 | #include "flare/actor_shape.hpp" 4 | #include "flare/paint/actor_radial_gradient.hpp" 5 | 6 | using namespace flare; 7 | 8 | ActorRadialGradient::ActorRadialGradient(ComponentType type) : Base(type) {} 9 | 10 | void ActorRadialGradient::copy(const ActorRadialGradient* gradient, ActorArtboard* artboard) 11 | { 12 | Base::copy(gradient, artboard); 13 | m_SecondaryRadiusScale = gradient->m_SecondaryRadiusScale; 14 | } 15 | 16 | ActorRadialGradient* ActorRadialGradient::read(ActorArtboard* artboard, BlockReader* reader, 17 | ActorRadialGradient* component) 18 | { 19 | Base::read(artboard, reader, component); 20 | component->m_SecondaryRadiusScale = reader->readFloat32(); 21 | return component; 22 | } 23 | 24 | float ActorRadialGradient::secondaryRadiusScale() const 25 | { 26 | return m_SecondaryRadiusScale; 27 | } 28 | void ActorRadialGradient::secondaryRadiusScale(float value) 29 | { 30 | if(m_SecondaryRadiusScale == value) 31 | { 32 | return; 33 | } 34 | m_SecondaryRadiusScale = value; 35 | 36 | // TODO: support secondary radius 37 | // determine if we actually want to mark the paint dirty here to update any world values 38 | invalidatePaint(); 39 | } -------------------------------------------------------------------------------- /flare/src/paint/actor_radial_gradient_fill.cpp: -------------------------------------------------------------------------------- 1 | #include "flare/paint/actor_radial_gradient_fill.hpp" 2 | #include "flare/actor.hpp" 3 | #include "flare/actor_artboard.hpp" 4 | #include "flare/actor_shape.hpp" 5 | 6 | using namespace flare; 7 | 8 | ActorRadialGradientFill::ActorRadialGradientFill() : Base(ComponentType::RadialGradientFill) {} 9 | 10 | void ActorRadialGradientFill::copy(const ActorRadialGradientFill* fill, ActorArtboard* artboard) 11 | { 12 | Base::copy(fill, artboard); 13 | ActorFill::copy(fill, artboard); 14 | } 15 | 16 | ActorRadialGradientFill* ActorRadialGradientFill::read(ActorArtboard* artboard, BlockReader* reader, ActorRadialGradientFill* component) 17 | { 18 | Base::read(artboard, reader, component); 19 | ActorFill::read(artboard, reader, component); 20 | return component; 21 | } 22 | 23 | void ActorRadialGradientFill::onShapeChanged(ActorShape* from, ActorShape* to) 24 | { 25 | if (from != nullptr) 26 | { 27 | from->removeFill(this); 28 | } 29 | if (to != nullptr) 30 | { 31 | to->addFill(this); 32 | } 33 | } 34 | 35 | ActorComponent* ActorRadialGradientFill::makeInstance(ActorArtboard* artboard) const 36 | { 37 | ActorRadialGradientFill* instanceNode = artboard->actor()->makeRadialGradientFill(); 38 | instanceNode->copy(this, artboard); 39 | return instanceNode; 40 | } 41 | 42 | void ActorRadialGradientFill::initializeGraphics() {} -------------------------------------------------------------------------------- /flare_math/include/flare_math/aabb.hpp: -------------------------------------------------------------------------------- 1 | #ifndef _FLARE_AABB_HPP_ 2 | #define _FLARE_AABB_HPP_ 3 | 4 | #include "vec2d.hpp" 5 | #include "mat2d.hpp" 6 | #include 7 | 8 | namespace flare 9 | { 10 | class AABB 11 | { 12 | private: 13 | union { 14 | float m_Buffer[4]; 15 | struct 16 | { 17 | Vec2D m_Min, m_Max; 18 | }; 19 | }; 20 | 21 | public: 22 | AABB(); 23 | AABB(const AABB& copy); 24 | AABB(float minX, float minY, float maxX, float maxY); 25 | 26 | inline const float* values() const { return m_Buffer; } 27 | 28 | float& operator[](std::size_t idx) { return m_Buffer[idx]; } 29 | const float& operator[](std::size_t idx) const { return m_Buffer[idx]; } 30 | 31 | static void center(Vec2D& out, const AABB& a); 32 | static void size(Vec2D& out, const AABB& a); 33 | static void extents(Vec2D& out, const AABB& a); 34 | static void combine(AABB& out, const AABB& a, const AABB& b); 35 | static bool contains(const AABB& a, const AABB& b); 36 | static bool isValid(const AABB& a); 37 | static bool testOverlap(const AABB& a, const AABB& b); 38 | static bool areIdentical(const AABB& a, const AABB& b); 39 | static void transform(AABB& out, const AABB& a, const Mat2D& matrix); 40 | 41 | float width() const; 42 | float height() const; 43 | float perimeter() const; 44 | 45 | }; 46 | } // namespace flare 47 | #endif -------------------------------------------------------------------------------- /flare/include/flare/actor_flags.hpp: -------------------------------------------------------------------------------- 1 | #ifndef _FLARE_ACTOR_FLAGS_HPP_ 2 | #define _FLARE_ACTOR_FLAGS_HPP_ 3 | 4 | namespace flare 5 | { 6 | enum class ActorFlags : unsigned short 7 | { 8 | IsDrawOrderDirty = 1 << 0, 9 | IsInstance = 1 << 1, 10 | IsDirty = 1 << 2 11 | }; 12 | 13 | inline constexpr ActorFlags operator&(ActorFlags x, ActorFlags y) 14 | { 15 | return static_cast(static_cast(x) & static_cast(y)); 16 | } 17 | 18 | inline constexpr ActorFlags operator|(ActorFlags x, ActorFlags y) 19 | { 20 | return static_cast(static_cast(x) | static_cast(y)); 21 | } 22 | 23 | inline constexpr ActorFlags operator^(ActorFlags x, ActorFlags y) 24 | { 25 | return static_cast(static_cast(x) ^ static_cast(y)); 26 | } 27 | 28 | inline constexpr ActorFlags operator~(ActorFlags x) 29 | { 30 | return static_cast(~static_cast(x)); 31 | } 32 | 33 | inline ActorFlags& operator&=(ActorFlags& x, ActorFlags y) 34 | { 35 | x = x & y; 36 | return x; 37 | } 38 | 39 | inline ActorFlags& operator|=(ActorFlags& x, ActorFlags y) 40 | { 41 | x = x | y; 42 | return x; 43 | } 44 | 45 | inline ActorFlags& operator^=(ActorFlags& x, ActorFlags y) 46 | { 47 | x = x ^ y; 48 | return x; 49 | } 50 | } // namespace flare 51 | #endif -------------------------------------------------------------------------------- /flare/src/actor_shape.cpp: -------------------------------------------------------------------------------- 1 | #include "flare/actor_shape.hpp" 2 | #include "flare/paint/actor_fill.hpp" 3 | #include "flare/paint/actor_stroke.hpp" 4 | 5 | using namespace flare; 6 | 7 | ActorShape::ActorShape() : ActorDrawable(ComponentType::ActorShape) {} 8 | 9 | ActorShape::~ActorShape() {} 10 | 11 | void ActorShape::update(DirtyFlags dirt) 12 | { 13 | Base::update(dirt); 14 | invalidateDrawable(); 15 | } 16 | 17 | void ActorShape::invalidateDrawable() {} 18 | 19 | void ActorShape::addStroke(ActorStroke* stroke) { m_Strokes.push_back(stroke); onStrokesChanged(); } 20 | 21 | void ActorShape::addFill(ActorFill* fill) { m_Fills.push_back(fill); onFillsChanged(); } 22 | 23 | void ActorShape::removeStroke(ActorStroke* stroke) 24 | { 25 | auto iterator = std::find(m_Strokes.begin(), m_Strokes.end(), stroke); 26 | if (iterator != m_Strokes.end()) 27 | { 28 | m_Strokes.erase(iterator); 29 | onStrokesChanged(); 30 | } 31 | } 32 | 33 | void ActorShape::removeFill(ActorFill* fill) 34 | { 35 | auto iterator = std::find(m_Fills.begin(), m_Fills.end(), fill); 36 | if (iterator != m_Fills.end()) 37 | { 38 | m_Fills.erase(iterator); 39 | onFillsChanged(); 40 | } 41 | } 42 | 43 | void ActorShape::initializeGraphics() 44 | { 45 | for (ActorStroke* stroke : m_Strokes) 46 | { 47 | stroke->initializeGraphics(); 48 | } 49 | for (ActorFill* fill : m_Fills) 50 | { 51 | fill->initializeGraphics(); 52 | } 53 | } 54 | -------------------------------------------------------------------------------- /flare/src/path/actor_ellipse.cpp: -------------------------------------------------------------------------------- 1 | #include "flare/path/actor_ellipse.hpp" 2 | #include "flare/actor_shape.hpp" 3 | #include "flare/block_reader.hpp" 4 | #include 5 | 6 | using namespace flare; 7 | 8 | const float CircleConstant = 0.55f; 9 | 10 | ActorEllipse::ActorEllipse() : Base(ComponentType::ActorEllipse) {} 11 | 12 | void ActorEllipse::makePoints() 13 | { 14 | float radiusX = width() / 2.0f; 15 | float radiusY = height() / 2.0f; 16 | 17 | m_Points.push_back(new CubicPathPoint( 18 | Vec2D(0.0f, -radiusY), 19 | Vec2D(-radiusX * CircleConstant, -radiusY), 20 | Vec2D(radiusX * CircleConstant, -radiusY))); 21 | m_Points.push_back(new CubicPathPoint( 22 | Vec2D(radiusX, 0.0f), 23 | Vec2D(radiusX, CircleConstant * -radiusY), 24 | Vec2D(radiusX, CircleConstant * radiusY))); 25 | m_Points.push_back(new CubicPathPoint( 26 | Vec2D(0.0f, radiusY), 27 | Vec2D(radiusX * CircleConstant, radiusY), 28 | Vec2D(-radiusX * CircleConstant, radiusY))); 29 | m_Points.push_back(new CubicPathPoint( 30 | Vec2D(-radiusX, 0.0f), 31 | Vec2D(-radiusX, radiusY * CircleConstant), 32 | Vec2D(-radiusX, -radiusY * CircleConstant))); 33 | } 34 | 35 | ActorComponent* ActorEllipse::makeInstance(ActorArtboard* artboard) const 36 | { 37 | ActorEllipse* instance = new ActorEllipse(); 38 | instance->copy(this, artboard); 39 | return instance; 40 | } -------------------------------------------------------------------------------- /flare_math/include/flare_math/mat2d.hpp: -------------------------------------------------------------------------------- 1 | #ifndef _FLARE_MAT2D_HPP_ 2 | #define _FLARE_MAT2D_HPP_ 3 | 4 | #include 5 | 6 | namespace flare 7 | { 8 | class Vec2D; 9 | class TransformComponents; 10 | class Mat2D 11 | { 12 | private: 13 | float m_Buffer[6]; 14 | 15 | public: 16 | Mat2D(); 17 | Mat2D(const Mat2D& copy); 18 | 19 | inline const float* values() const { return m_Buffer; } 20 | 21 | float& operator[](std::size_t idx) { return m_Buffer[idx]; } 22 | const float& operator[](std::size_t idx) const { return m_Buffer[idx]; } 23 | 24 | static void identity(Mat2D& result) 25 | { 26 | result[0] = 1.0f; 27 | result[1] = 0.0f; 28 | result[2] = 0.0f; 29 | result[3] = 1.0f; 30 | result[4] = 0.0f; 31 | result[5] = 0.0f; 32 | } 33 | 34 | static void fromRotation(Mat2D& result, float rad); 35 | static void scale(Mat2D& result, const Mat2D& mat, const Vec2D& vec); 36 | static void multiply(Mat2D& result, const Mat2D& a, const Mat2D& b); 37 | static bool invert(Mat2D& result, const Mat2D& a); 38 | static void copy(Mat2D& result, const Mat2D& a); 39 | static void decompose(TransformComponents& result, const Mat2D& m); 40 | static void compose(Mat2D& result, const TransformComponents& components); 41 | }; 42 | 43 | inline Mat2D operator*(const Mat2D& a, const Mat2D& b) 44 | { 45 | Mat2D result; 46 | Mat2D::multiply(result, a, b); 47 | return result; 48 | } 49 | } // namespace flare 50 | #endif -------------------------------------------------------------------------------- /flare/src/paint/actor_gradient_stroke.cpp: -------------------------------------------------------------------------------- 1 | #include "flare/paint/actor_gradient_stroke.hpp" 2 | #include "flare/actor.hpp" 3 | #include "flare/actor_artboard.hpp" 4 | #include "flare/actor_shape.hpp" 5 | 6 | using namespace flare; 7 | 8 | ActorGradientStroke::ActorGradientStroke() : Base(ComponentType::GradientStroke) {} 9 | 10 | void ActorGradientStroke::copy(const ActorGradientStroke* Stroke, ActorArtboard* artboard) 11 | { 12 | ActorGradientColor::copy(Stroke, artboard); 13 | ActorStroke::copy(Stroke, artboard); 14 | } 15 | 16 | ActorGradientStroke* ActorGradientStroke::read(ActorArtboard* artboard, BlockReader* reader, 17 | ActorGradientStroke* component) 18 | { 19 | ActorGradientColor::read(artboard, reader, component); 20 | ActorStroke::read(artboard, reader, component); 21 | return component; 22 | } 23 | 24 | void ActorGradientStroke::onShapeChanged(ActorShape* from, ActorShape* to) 25 | { 26 | if (from != nullptr) 27 | { 28 | from->removeStroke(this); 29 | } 30 | if (to != nullptr) 31 | { 32 | to->addStroke(this); 33 | } 34 | } 35 | 36 | ActorComponent* ActorGradientStroke::makeInstance(ActorArtboard* artboard) const 37 | { 38 | ActorGradientStroke* instanceNode = artboard->actor()->makeGradientStroke(); 39 | instanceNode->copy(this, artboard); 40 | return instanceNode; 41 | } 42 | 43 | void ActorGradientStroke::initializeGraphics() {} 44 | void ActorGradientStroke::markPathEffectsDirty() {} -------------------------------------------------------------------------------- /flare/include/flare/paint/actor_paint.hpp: -------------------------------------------------------------------------------- 1 | #ifndef _FLARE_ACTOR_PAINT_HPP_ 2 | #define _FLARE_ACTOR_PAINT_HPP_ 3 | 4 | #include "flare/actor_component.hpp" 5 | 6 | namespace flare 7 | { 8 | class BlockReader; 9 | class ActorArtboard; 10 | class ActorShape; 11 | 12 | class ActorPaint : public ActorComponent 13 | { 14 | typedef ActorComponent Base; 15 | 16 | protected: 17 | float m_Opacity; 18 | float m_RenderOpacity; 19 | bool m_IsPaintInvalid; 20 | ActorShape* m_Shape; 21 | 22 | protected: 23 | void markPaintDirty(); 24 | void invalidatePaint(); 25 | void onParentChanged(ActorNode* from, ActorNode* to) override; 26 | virtual void onShapeChanged(ActorShape* from, ActorShape* to) = 0; 27 | 28 | public: 29 | ActorPaint(ComponentType type); 30 | float opacity() const { return m_Opacity; } 31 | float renderOpacity() const { return m_RenderOpacity; } 32 | void opacity(float value); 33 | ActorShape* shape() const { return m_Shape; } 34 | 35 | void copy(const ActorPaint* paint, ActorArtboard* artboard); 36 | static ActorPaint* read(ActorArtboard* artboard, BlockReader* reader, ActorPaint* component); 37 | void completeResolve() override; 38 | void update(DirtyFlags dirt) override; 39 | virtual void validatePaint(); 40 | virtual void updatePaint() {} 41 | 42 | }; 43 | } // namespace flare 44 | 45 | #endif -------------------------------------------------------------------------------- /flare/include/flare/paint/actor_gradient_color.hpp: -------------------------------------------------------------------------------- 1 | #ifndef _FLARE_ACTOR_GRADIENT_COLOR_HPP_ 2 | #define _FLARE_ACTOR_GRADIENT_COLOR_HPP_ 3 | 4 | #include "flare/paint/actor_paint.hpp" 5 | #include "flare_math/vec2d.hpp" 6 | 7 | namespace flare 8 | { 9 | class BlockReader; 10 | class ActorArtboard; 11 | class KeyFrameGradient; 12 | class KeyFrameRadialGradient; 13 | 14 | class ActorGradientColor : public ActorPaint 15 | { 16 | friend class KeyFrameGradient; 17 | friend class KeyFrameRadialGradient; 18 | 19 | typedef ActorPaint Base; 20 | 21 | private: 22 | std::vector m_ColorStops; 23 | Vec2D m_Start; 24 | Vec2D m_End; 25 | Vec2D m_RenderStart; 26 | Vec2D m_RenderEnd; 27 | 28 | public: 29 | const Vec2D& start() { return m_Start; } 30 | const Vec2D& end() { return m_End; } 31 | const Vec2D& renderStart() { return m_RenderStart; } 32 | const Vec2D& renderEnd() { return m_RenderEnd; } 33 | const std::vector& colorStops() { return m_ColorStops; } 34 | 35 | bool start(const Vec2D& value); 36 | bool end(const Vec2D& value); 37 | bool colorStops(const std::vector& value); 38 | 39 | ActorGradientColor(ComponentType type); 40 | void copy(const ActorGradientColor* gradientColor, ActorArtboard* artboard); 41 | static ActorGradientColor* read(ActorArtboard* artboard, BlockReader* reader, ActorGradientColor* component); 42 | void update(DirtyFlags dirt) override; 43 | }; 44 | } // namespace flare 45 | 46 | #endif -------------------------------------------------------------------------------- /flare/src/paint/actor_radial_gradient_stroke.cpp: -------------------------------------------------------------------------------- 1 | #include "flare/paint/actor_radial_gradient_stroke.hpp" 2 | #include "flare/actor.hpp" 3 | #include "flare/actor_artboard.hpp" 4 | #include "flare/actor_shape.hpp" 5 | 6 | using namespace flare; 7 | 8 | ActorRadialGradientStroke::ActorRadialGradientStroke() : Base(ComponentType::RadialGradientStroke) {} 9 | 10 | void ActorRadialGradientStroke::copy(const ActorRadialGradientStroke* stroke, ActorArtboard* artboard) 11 | { 12 | Base::copy(stroke, artboard); 13 | ActorStroke::copy(stroke, artboard); 14 | } 15 | 16 | ActorRadialGradientStroke* ActorRadialGradientStroke::read(ActorArtboard* artboard, BlockReader* reader, ActorRadialGradientStroke* component) 17 | { 18 | Base::read(artboard, reader, component); 19 | ActorStroke::read(artboard, reader, component); 20 | return component; 21 | } 22 | 23 | void ActorRadialGradientStroke::onShapeChanged(ActorShape* from, ActorShape* to) 24 | { 25 | if (from != nullptr) 26 | { 27 | from->removeStroke(this); 28 | } 29 | if (to != nullptr) 30 | { 31 | to->addStroke(this); 32 | } 33 | } 34 | 35 | ActorComponent* ActorRadialGradientStroke::makeInstance(ActorArtboard* artboard) const 36 | { 37 | ActorRadialGradientStroke* instanceNode = artboard->actor()->makeRadialGradientStroke(); 38 | instanceNode->copy(this, artboard); 39 | return instanceNode; 40 | } 41 | 42 | void ActorRadialGradientStroke::initializeGraphics() {} 43 | void ActorRadialGradientStroke::markPathEffectsDirty() {} -------------------------------------------------------------------------------- /flare/include/flare/animation/keyframes/keyframe_numeric.hpp: -------------------------------------------------------------------------------- 1 | #ifndef _FLARE_KEYFRAMENUMERIC_HPP_ 2 | #define _FLARE_KEYFRAMENUMERIC_HPP_ 3 | 4 | #include "keyframe_with_interpolation.hpp" 5 | 6 | namespace flare 7 | { 8 | class BlockReader; 9 | class ActorNode; 10 | 11 | class KeyFrameNumeric : public KeyFrameWithInterpolation 12 | { 13 | typedef KeyFrameWithInterpolation Base; 14 | private: 15 | float m_Value; 16 | 17 | public: 18 | KeyFrameNumeric(); 19 | float value() const; 20 | 21 | bool read(BlockReader* reader, ActorComponent* component) override; 22 | void apply(ActorComponent* component, float mix) override; 23 | void applyInterpolation(ActorComponent* component, float time, KeyFrame* toFrame, float mix) override; 24 | 25 | protected: 26 | virtual void setValue(ActorComponent* component, float value, float mix) = 0; 27 | }; 28 | 29 | class KeyFrameInt : public KeyFrameWithInterpolation 30 | { 31 | typedef KeyFrameWithInterpolation Base; 32 | private: 33 | int m_Value; 34 | 35 | public: 36 | KeyFrameInt(); 37 | int value() const; 38 | 39 | bool read(BlockReader* reader, ActorComponent* component) override; 40 | void apply(ActorComponent* component, float mix) override; 41 | void applyInterpolation(ActorComponent* component, float time, KeyFrame* toFrame, float mix) override; 42 | 43 | protected: 44 | virtual void setValue(ActorComponent* component, float value, float mix) = 0; 45 | }; 46 | } 47 | 48 | #endif -------------------------------------------------------------------------------- /flare/include/flare/actor_static_mesh.hpp: -------------------------------------------------------------------------------- 1 | #ifndef _FLARE_ACTORSTATICMESH_HPP_ 2 | #define _FLARE_ACTORSTATICMESH_HPP_ 3 | 4 | #include "actor_drawable.hpp" 5 | #include "blend_mode.hpp" 6 | 7 | namespace flare 8 | { 9 | class Actor; 10 | class BlockReader; 11 | class ActorNode; 12 | 13 | class ActorStaticMesh : public ActorDrawable 14 | { 15 | typedef ActorDrawable Base; 16 | 17 | private: 18 | bool m_IsInstance; 19 | BlendMode m_BlendMode; 20 | 21 | public: 22 | struct Surface 23 | { 24 | int textureIndex; 25 | unsigned int vertexCount; 26 | unsigned int triangleCount; 27 | float* vertices; 28 | unsigned short* triangles; 29 | 30 | Surface(); 31 | virtual ~Surface(); 32 | virtual void disposeGeometry(); 33 | }; 34 | 35 | protected: 36 | int m_NumSurfaces; 37 | Surface** m_Surfaces; 38 | 39 | virtual Surface* makeSurface(); 40 | 41 | public: 42 | ActorStaticMesh(); 43 | ~ActorStaticMesh(); 44 | ActorComponent* makeInstance(ActorArtboard* artboard) const override; 45 | void copy(const ActorStaticMesh* node, ActorArtboard* artboard); 46 | void resolveComponentIndices(ActorComponent** nodes, int numComponents) override; 47 | void initializeGraphics() override; 48 | virtual void disposeGeometry(); 49 | BlendMode blendMode() const; 50 | int numSurfaces() const; 51 | Surface* surface(int index); 52 | 53 | static ActorStaticMesh* read(ActorArtboard* artboard, BlockReader* reader, ActorStaticMesh* node = NULL); 54 | }; 55 | } //namespace flare 56 | #endif -------------------------------------------------------------------------------- /flare/src/path/actor_polygon.cpp: -------------------------------------------------------------------------------- 1 | #include "flare/path/actor_polygon.hpp" 2 | #include "flare/actor_shape.hpp" 3 | #include "flare/block_reader.hpp" 4 | #include 5 | 6 | using namespace flare; 7 | 8 | ActorPolygon::ActorPolygon() : Base(ComponentType::ActorPolygon), m_NumSides(5) {} 9 | 10 | void ActorPolygon::makePoints() 11 | { 12 | float radiusX = width() / 2.0f; 13 | float radiusY = height() / 2.0f; 14 | 15 | float angle = -M_PI / 2.0f; 16 | float inc = (M_PI * 2.0) / m_NumSides; 17 | 18 | for (int i = 0; i < m_NumSides; i++) { 19 | m_Points.push_back(new StraightPathPoint( 20 | Vec2D(cos(angle) * radiusX, sin(angle) * radiusY))); 21 | angle += inc; 22 | } 23 | } 24 | 25 | void ActorPolygon::numSides(int value) 26 | { 27 | if(m_NumSides == value) 28 | { 29 | return; 30 | } 31 | m_NumSides = value; 32 | invalidateDrawable(); 33 | } 34 | 35 | void ActorPolygon::copy(const ActorPolygon* star, ActorArtboard* artboard) 36 | { 37 | Base::copy(star, artboard); 38 | m_NumSides = star->m_NumSides; 39 | } 40 | 41 | ActorComponent* ActorPolygon::makeInstance(ActorArtboard* artboard) const 42 | { 43 | ActorPolygon* instance = new ActorPolygon(); 44 | instance->copy(this, artboard); 45 | return instance; 46 | } 47 | 48 | ActorPolygon* ActorPolygon::read(ActorArtboard* artboard, BlockReader* reader, ActorPolygon* component) 49 | { 50 | Base::read(artboard, reader, component); 51 | 52 | component->m_NumSides = reader->readUint32(); 53 | return component; 54 | } -------------------------------------------------------------------------------- /flare/include/flare/path/actor_procedural_path.hpp: -------------------------------------------------------------------------------- 1 | #ifndef _FLARE_ACTORPROCEDURALPATH_HPP_ 2 | #define _FLARE_ACTORPROCEDURALPATH_HPP_ 3 | 4 | #include "flare/actor_drawable.hpp" 5 | #include "flare/path/actor_base_path.hpp" 6 | #include "flare/path/path_point.hpp" 7 | #include "flare_math/aabb.hpp" 8 | #include "flare_math/mat2d.hpp" 9 | #include 10 | 11 | namespace flare 12 | { 13 | class ActorProceduralPath : public ActorBasePath 14 | { 15 | typedef ActorBasePath Base; 16 | 17 | private: 18 | float m_Width; 19 | float m_Height; 20 | 21 | protected: 22 | std::vector m_Points; 23 | 24 | public: 25 | ActorProceduralPath(ComponentType type); 26 | ~ActorProceduralPath(); 27 | 28 | float width() const { return m_Width; } 29 | float height() const { return m_Height; } 30 | 31 | void width(float value); 32 | void height(float value); 33 | 34 | bool isPathInWorldSpace() const override { return false; } 35 | const Mat2D& pathTransform() const override { return worldTransform(); } 36 | const std::vector& deformedPoints() override; 37 | const std::vector& points() override; 38 | void onDirty(DirtyFlags dirt) override; 39 | 40 | void copy(const ActorProceduralPath* path, ActorArtboard* resetActor); 41 | void invalidateDrawable() override; 42 | virtual void makePoints() = 0; 43 | bool isClosed() override { return true; } 44 | 45 | static ActorProceduralPath* read(ActorArtboard* artboard, BlockReader* reader, ActorProceduralPath* component); 46 | }; 47 | } // namespace flare 48 | #endif -------------------------------------------------------------------------------- /flare/include/flare/animation/keyframes/keyframe_custom_property.hpp: -------------------------------------------------------------------------------- 1 | #ifndef _FLARE_KEYFRAMEINTPROPERTY_HPP_ 2 | #define _FLARE_KEYFRAMEINTPROPERTY_HPP_ 3 | 4 | #include "keyframe_numeric.hpp" 5 | #include 6 | 7 | namespace flare 8 | { 9 | class ActorComponent; 10 | 11 | class KeyFrameIntProperty : public KeyFrameInt 12 | { 13 | protected: 14 | void setValue(ActorComponent* component, float value, float mix) override; 15 | }; 16 | 17 | class KeyFrameFloatProperty : public KeyFrameNumeric 18 | { 19 | protected: 20 | void setValue(ActorComponent* component, float value, float mix) override; 21 | }; 22 | 23 | class KeyFrameStringProperty : public KeyFrame 24 | { 25 | typedef KeyFrame Base; 26 | private: 27 | std::string m_Value; 28 | 29 | public: 30 | bool read(BlockReader* reader, ActorComponent* component) override; 31 | void setNext(KeyFrame* frame) override; 32 | void apply(ActorComponent* component, float mix) override; 33 | void applyInterpolation(ActorComponent* component, float time, KeyFrame* toFrame, float mix) override; 34 | }; 35 | 36 | class KeyFrameBooleanProperty : public KeyFrame 37 | { 38 | typedef KeyFrame Base; 39 | private: 40 | bool m_Value; 41 | 42 | public: 43 | bool read(BlockReader* reader, ActorComponent* component) override; 44 | void setNext(KeyFrame* frame) override; 45 | void apply(ActorComponent* component, float mix) override; 46 | void applyInterpolation(ActorComponent* component, float time, KeyFrame* toFrame, float mix) override; 47 | }; 48 | } 49 | 50 | #endif -------------------------------------------------------------------------------- /flare/include/flare/animation/actor_animation.hpp: -------------------------------------------------------------------------------- 1 | #ifndef _FLARE_ACTORANIMATION_HPP_ 2 | #define _FLARE_ACTORANIMATION_HPP_ 3 | 4 | #include 5 | #include 6 | #include 7 | #include "component_animation.hpp" 8 | 9 | namespace flare 10 | { 11 | class BlockReader; 12 | class ActorNode; 13 | class ActorEvent; 14 | 15 | struct ActorAnimationEvent 16 | { 17 | typedef std::function Callback; 18 | ActorEvent* actorEvent; 19 | float keyFrameTime; 20 | float elapsedTime; 21 | 22 | ActorAnimationEvent(ActorEvent* av, float time, float elapsed) : 23 | actorEvent(av), 24 | keyFrameTime(time), 25 | elapsedTime(elapsed) 26 | { 27 | 28 | } 29 | }; 30 | 31 | class ActorAnimation 32 | { 33 | private: 34 | std::string m_Name; 35 | int m_FPS; 36 | float m_Duration; 37 | bool m_IsLooping; 38 | std::vector m_AnimatedComponents; 39 | std::vector m_TriggerComponents; 40 | 41 | public: 42 | 43 | ActorAnimation(); 44 | ~ActorAnimation(); 45 | const std::string& name() const; 46 | float duration() const; 47 | bool isLooping() const; 48 | int fps() const; 49 | 50 | void read(BlockReader* reader, ActorComponent** components, int componentCount); 51 | 52 | void apply(float time, ActorArtboard* artboard, float mix); 53 | 54 | void triggerEvents(ActorArtboard* artboard, float fromTime, float toTime, std::vector& events); 55 | 56 | void fps(const int fps); 57 | void duration(const float duration); 58 | }; 59 | } 60 | #endif -------------------------------------------------------------------------------- /flare/src/path/actor_rectangle.cpp: -------------------------------------------------------------------------------- 1 | #include "flare/path/actor_rectangle.hpp" 2 | #include "flare/actor_shape.hpp" 3 | #include "flare/block_reader.hpp" 4 | #include 5 | 6 | using namespace flare; 7 | 8 | ActorRectangle::ActorRectangle() : Base(ComponentType::ActorRectangle), m_Radius(0.0f) {} 9 | 10 | void ActorRectangle::copy(const ActorRectangle* rectangle, ActorArtboard* artboard) 11 | { 12 | Base::copy(rectangle, artboard); 13 | m_Radius = rectangle->m_Radius; 14 | } 15 | 16 | void ActorRectangle::makePoints() 17 | { 18 | float halfWidth = width() / 2.0f; 19 | float halfHeight = height() / 2.0f; 20 | 21 | m_Points.push_back(new StraightPathPoint(Vec2D(-halfWidth, -halfHeight), m_Radius)); 22 | m_Points.push_back(new StraightPathPoint(Vec2D(halfWidth, -halfHeight), m_Radius)); 23 | m_Points.push_back(new StraightPathPoint(Vec2D(halfWidth, halfHeight), m_Radius)); 24 | m_Points.push_back(new StraightPathPoint(Vec2D(-halfWidth, halfHeight), m_Radius)); 25 | } 26 | 27 | ActorComponent* ActorRectangle::makeInstance(ActorArtboard* artboard) const 28 | { 29 | ActorRectangle* instance = new ActorRectangle(); 30 | instance->copy(this, artboard); 31 | return instance; 32 | } 33 | 34 | ActorRectangle* ActorRectangle::read(ActorArtboard* artboard, BlockReader* reader, ActorRectangle* component) 35 | { 36 | Base::read(artboard, reader, component); 37 | component->m_Radius = reader->readFloat32(); 38 | return component; 39 | } 40 | 41 | bool ActorRectangle::radius(float value) 42 | { 43 | if(m_Radius == value) 44 | { 45 | return false; 46 | } 47 | invalidateDrawable(); 48 | return true; 49 | } -------------------------------------------------------------------------------- /flare/include/flare/paint/actor_stroke.hpp: -------------------------------------------------------------------------------- 1 | #ifndef _FLARE_ACTOR_STROKE_HPP_ 2 | #define _FLARE_ACTOR_STROKE_HPP_ 3 | 4 | #include "flare/paint/stroke_cap.hpp" 5 | #include "flare/paint/stroke_join.hpp" 6 | #include "flare/paint/trim_path.hpp" 7 | 8 | namespace flare 9 | { 10 | class BlockReader; 11 | class ActorArtboard; 12 | 13 | class ActorStroke 14 | { 15 | private: 16 | float m_Width; 17 | StrokeCap m_Cap; 18 | StrokeJoin m_Join; 19 | TrimPath m_TrimPath; 20 | float m_TrimStart; 21 | float m_TrimEnd; 22 | float m_TrimOffset; 23 | 24 | protected: 25 | ActorStroke(); 26 | 27 | public: 28 | float width() const { return m_Width; } 29 | void width(float value); 30 | 31 | StrokeCap cap() const { return m_Cap; } 32 | void cap(StrokeCap value); 33 | 34 | StrokeJoin join() const { return m_Join; } 35 | void join(StrokeJoin value); 36 | 37 | TrimPath trimPath() const { return m_TrimPath; } 38 | void trimPath(TrimPath value); 39 | 40 | float trimStart() const { return m_TrimStart; } 41 | bool trimStart(float value); 42 | 43 | float trimEnd() const { return m_TrimEnd; } 44 | bool trimEnd(float value); 45 | 46 | float trimOffset() const { return m_TrimOffset; } 47 | bool trimOffset(float value); 48 | 49 | void copy(const ActorStroke* stroke, ActorArtboard* artboard); 50 | static ActorStroke* read(ActorArtboard* artboard, BlockReader* reader, ActorStroke* component); 51 | 52 | virtual void initializeGraphics() = 0; 53 | virtual void markPaintDirty() = 0; 54 | virtual void markPathEffectsDirty() = 0; 55 | virtual void validatePaint() = 0; 56 | }; 57 | } // namespace flare 58 | 59 | #endif -------------------------------------------------------------------------------- /flare/include/flare/block_types.hpp: -------------------------------------------------------------------------------- 1 | #ifndef _FLARE_BLOCKTYPE_HPP_ 2 | #define _FLARE_BLOCKTYPE_HPP_ 3 | namespace flare 4 | { 5 | enum class BlockType 6 | { 7 | Unknown = 0, 8 | Components = 1, 9 | ActorNode = 2, 10 | ActorBone = 3, 11 | ActorRootBone = 4, 12 | ActorImage = 5, 13 | View = 6, 14 | Animation = 7, 15 | Animations = 8, 16 | Atlases = 9, 17 | Atlas = 10, 18 | ActorIKTarget = 11, 19 | ActorEvent = 12, 20 | CustomIntProperty = 13, 21 | CustomFloatProperty = 14, 22 | CustomStringProperty = 15, 23 | CustomBooleanProperty = 16, 24 | ColliderRectangle = 17, // TODO 25 | ColliderTriangle = 18, // TODO 26 | ColliderCircle = 19, // TODO 27 | ColliderPolygon = 20, // TODO 28 | ColliderLine = 21, // TODO 29 | ActorImageSequence = 22, // TODO 30 | ActorNodeSolo = 23, 31 | NestedActorNode = 24, 32 | NestedActorAssets = 25, 33 | NestedActorAsset = 26, 34 | ActorStaticMesh = 27, 35 | JellyComponent = 28, 36 | ActorJellyBone = 29, 37 | ActorIKConstraint = 30, 38 | ActorDistanceConstraint = 31, 39 | ActorTranslationConstraint = 32, 40 | ActorRotationConstraint = 33, 41 | ActorScaleConstraint = 34, 42 | ActorTransformConstraint = 35, 43 | ActorShape = 100, 44 | ActorPath = 101, 45 | ColorFill = 102, 46 | ColorStroke = 103, 47 | GradientFill = 104, 48 | GradientStroke = 105, 49 | RadialGradientFill = 106, 50 | RadialGradientStroke = 107, 51 | ActorEllipse = 108, 52 | ActorRectangle = 109, 53 | ActorTriangle = 110, 54 | ActorStar = 111, 55 | ActorPolygon = 112, 56 | ActorSkin = 113, 57 | ActorArtboard = 114, 58 | Artboards = 115 59 | }; 60 | } 61 | #endif -------------------------------------------------------------------------------- /flare/src/actor_drawable.cpp: -------------------------------------------------------------------------------- 1 | #include "flare/actor_drawable.hpp" 2 | #include "flare/actor.hpp" 3 | 4 | using namespace flare; 5 | 6 | ActorDrawable::ActorDrawable(ComponentType type) : ActorNode(type), m_DrawOrder(0) {} 7 | 8 | void ActorDrawable::copy(const ActorDrawable* node, ActorArtboard* artboard) 9 | { 10 | Base::copy(node, artboard); 11 | 12 | m_DrawOrder = node->m_DrawOrder; 13 | m_BlendMode = node->m_BlendMode; 14 | m_IsHidden = node->m_IsHidden; 15 | } 16 | 17 | int ActorDrawable::drawOrder() const { return m_DrawOrder; } 18 | 19 | void ActorDrawable::drawOrder(int order) 20 | { 21 | if (m_DrawOrder != order) 22 | { 23 | m_DrawOrder = order; 24 | if (m_Artboard != nullptr) 25 | { 26 | m_Artboard->markDrawOrderDirty(); 27 | } 28 | } 29 | } 30 | 31 | bool ActorDrawable::isHidden() const { return m_IsHidden; } 32 | void ActorDrawable::isHidden(bool value) { m_IsHidden = value; } 33 | 34 | BlendMode ActorDrawable::blendMode() const { return m_BlendMode; } 35 | void ActorDrawable::blendMode(BlendMode value) 36 | { 37 | if (value == m_BlendMode) 38 | { 39 | return; 40 | } 41 | BlendMode old = m_BlendMode; 42 | m_BlendMode = value; 43 | onBlendModeChanged(old, m_BlendMode); 44 | } 45 | 46 | ActorDrawable* ActorDrawable::read(ActorArtboard* artboard, BlockReader* reader, ActorDrawable* component) 47 | { 48 | Base::read(artboard, reader, component); 49 | 50 | component->m_IsHidden = reader->readUint8() == 0; 51 | component->m_BlendMode = (BlendMode)reader->readUint8(); 52 | component->m_DrawOrder = (int)reader->readUint16(); 53 | 54 | return component; 55 | } 56 | 57 | void ActorDrawable::onBlendModeChanged(BlendMode from, BlendMode to) {} -------------------------------------------------------------------------------- /flare/src/actor_constraint.cpp: -------------------------------------------------------------------------------- 1 | #include "flare/actor_constraint.hpp" 2 | #include "flare/actor.hpp" 3 | using namespace flare; 4 | 5 | ActorConstraint::ActorConstraint(ActorArtboard* artboard, ComponentType type) : 6 | ActorComponent(artboard, type), 7 | m_IsEnabled(false), 8 | m_Strength(1.0f) 9 | { 10 | } 11 | 12 | bool ActorConstraint::isEnabled() const { return m_IsEnabled; } 13 | 14 | float ActorConstraint::strength() const { return m_Strength; } 15 | 16 | void ActorConstraint::strength(float value) 17 | { 18 | if (m_Strength == value) 19 | { 20 | return; 21 | } 22 | m_Strength = value; 23 | m_Parent->markTransformDirty(); 24 | } 25 | 26 | void ActorConstraint::onDirty(DirtyFlags dirt) { m_Parent->markTransformDirty(); } 27 | 28 | void ActorConstraint::resolveComponentIndices(ActorComponent** components, int numComponents) 29 | { 30 | Base::resolveComponentIndices(components, numComponents); 31 | if (m_Parent != nullptr) 32 | { 33 | // This works because nodes are exported in hierarchy order, so we are 34 | // assured constraints get added in order as we resolve indices. 35 | m_Parent->addConstraint(this); 36 | } 37 | } 38 | 39 | void ActorConstraint::copy(const ActorConstraint* constraint, ActorArtboard* artboard) 40 | { 41 | Base::copy(constraint, artboard); 42 | 43 | m_IsEnabled = constraint->m_IsEnabled; 44 | m_Strength = constraint->m_Strength; 45 | } 46 | 47 | ActorConstraint* ActorConstraint::read(ActorArtboard* artboard, BlockReader* reader, ActorConstraint* constraint) 48 | { 49 | Base::read(artboard, reader, constraint); 50 | constraint->m_Strength = reader->readFloat32(); 51 | constraint->m_IsEnabled = reader->readUint8() == 1; 52 | 53 | return constraint; 54 | } -------------------------------------------------------------------------------- /flare/include/flare/animation/property_animation.hpp: -------------------------------------------------------------------------------- 1 | #ifndef _FLARE_PROPERTYANIMATION_HPP_ 2 | #define _FLARE_PROPERTYANIMATION_HPP_ 3 | 4 | #include 5 | #include 6 | 7 | namespace flare 8 | { 9 | class BlockReader; 10 | class ActorComponent; 11 | class KeyFrame; 12 | enum class PropertyType 13 | { 14 | Unknown = 0, 15 | PosX = 1, 16 | PosY = 2, 17 | ScaleX = 3, 18 | ScaleY = 4, 19 | Rotation = 5, 20 | Opacity = 6, 21 | DrawOrder = 7, 22 | Length = 8, 23 | ImageVertices = 9, 24 | ConstraintStrength = 10, 25 | Trigger = 11, 26 | IntProperty = 12, 27 | FloatProperty = 13, 28 | StringProperty = 14, 29 | BooleanProperty = 15, 30 | IsCollisionEnabled = 16, 31 | Sequence = 17, 32 | ActiveChildIndex = 18, 33 | PathVertices = 19, 34 | FillColor = 20, 35 | FillGradient = 21, 36 | FillRadial = 22, 37 | StrokeColor = 23, 38 | StrokeGradient = 24, 39 | StrokeRadial = 25, 40 | StrokeWidth = 26, 41 | StrokeOpacity = 27, 42 | FillOpacity = 28, 43 | ShapeWidth = 29, 44 | ShapeHeight = 30, 45 | CornerRadius = 31, 46 | InnerRadius = 32, 47 | StrokeStart = 33, 48 | StrokeEnd = 34, 49 | StrokeOffset = 35, 50 | Max 51 | }; 52 | 53 | class PropertyAnimation 54 | { 55 | private: 56 | PropertyType m_Type; 57 | std::vector m_KeyFrames; 58 | 59 | public: 60 | PropertyAnimation(); 61 | ~PropertyAnimation(); 62 | 63 | int keyFramesCount() const; 64 | inline const KeyFrame* keyFrame(int idx) const { return m_KeyFrames[idx]; } 65 | 66 | PropertyType type() const; 67 | void read(BlockReader* reader, ActorComponent* component); 68 | void apply(float time, ActorComponent* component, float mix); 69 | }; 70 | } // namespace flare 71 | #endif -------------------------------------------------------------------------------- /flare/src/actor_node_solo.cpp: -------------------------------------------------------------------------------- 1 | #include "flare/actor_node_solo.hpp" 2 | #include "flare/block_reader.hpp" 3 | #include 4 | 5 | using namespace flare; 6 | 7 | ActorNodeSolo::ActorNodeSolo() : ActorNode(ComponentType::ActorNodeSolo), m_ActiveChildIndex(0) {} 8 | 9 | int ActorNodeSolo::activeChildIndex() const { return m_ActiveChildIndex; } 10 | 11 | void ActorNodeSolo::activeChildIndex(int index) 12 | { 13 | if (m_ActiveChildIndex != index) 14 | { 15 | setActiveChildIndex(index); 16 | } 17 | } 18 | void ActorNodeSolo::setActiveChildIndex(int index) 19 | { 20 | int numChildren = m_Children.size(); 21 | m_ActiveChildIndex = std::min(numChildren, std::max(0, index)); 22 | for (int i = 0; i < numChildren; i++) 23 | { 24 | auto an = m_Children[i]; 25 | bool cv = (i != (m_ActiveChildIndex - 1)); 26 | an->collapsedVisibility(cv); 27 | } 28 | } 29 | 30 | ActorComponent* ActorNodeSolo::makeInstance(ActorArtboard* artboard) const 31 | { 32 | ActorNodeSolo* soloInstance = new ActorNodeSolo(); 33 | soloInstance->copy(this, artboard); 34 | 35 | return soloInstance; 36 | } 37 | 38 | void ActorNodeSolo::copy(const ActorNodeSolo* node, ActorArtboard* artboard) 39 | { 40 | Base::copy(node, artboard); 41 | m_ActiveChildIndex = node->m_ActiveChildIndex; 42 | } 43 | 44 | ActorNodeSolo* ActorNodeSolo::read(ActorArtboard* artboard, BlockReader* reader, ActorNodeSolo* node) 45 | { 46 | if (node == nullptr) 47 | { 48 | node = new ActorNodeSolo(); 49 | } 50 | 51 | Base::read(artboard, reader, node); 52 | 53 | node->m_ActiveChildIndex = reader->readUint32(); 54 | 55 | return node; 56 | } 57 | 58 | void ActorNodeSolo::completeResolve() 59 | { 60 | Base::completeResolve(); 61 | setActiveChildIndex(m_ActiveChildIndex); 62 | } -------------------------------------------------------------------------------- /flare/include/flare/jelly_component.hpp: -------------------------------------------------------------------------------- 1 | #ifndef _FLARE_JELLYCOMPONENT_HPP_ 2 | #define _FLARE_JELLYCOMPONENT_HPP_ 3 | 4 | #include "actor_component.hpp" 5 | #include "flare_math/vec2d.hpp" 6 | #include 7 | #include 8 | 9 | namespace flare 10 | { 11 | class ActorArtboard; 12 | class BlockReader; 13 | class ActorJellyBone; 14 | 15 | class JellyComponent : public ActorComponent 16 | { 17 | typedef ActorComponent Base; 18 | 19 | public: 20 | static constexpr int JellyMax = 16; 21 | static const float OptimalDistance; 22 | static const float CurveConstant; 23 | 24 | private: 25 | float m_EaseIn; 26 | float m_EaseOut; 27 | float m_ScaleIn; 28 | float m_ScaleOut; 29 | unsigned short m_InTargetIdx; 30 | unsigned short m_OutTargetIdx; 31 | ActorNode* m_InTarget; 32 | ActorNode* m_OutTarget; 33 | std::vector m_Bones; 34 | Vec2D m_InPoint; 35 | Vec2D m_InDirection; 36 | Vec2D m_OutPoint; 37 | Vec2D m_OutDirection; 38 | 39 | Vec2D m_CachedTip; 40 | Vec2D m_CachedOut; 41 | Vec2D m_CachedIn; 42 | float m_CachedScaleIn; 43 | float m_CachedScaleOut; 44 | 45 | Vec2D m_JellyPoints[JellyMax + 1]; 46 | std::vector m_NormalizedCurvePoints; 47 | 48 | public: 49 | JellyComponent(); 50 | ActorComponent* makeInstance(ActorArtboard* artboard) const override; 51 | void copy(const JellyComponent* node, ActorArtboard* artboard); 52 | static JellyComponent* read(ActorArtboard* artboard, BlockReader* reader, JellyComponent* node = nullptr); 53 | void resolveComponentIndices(ActorComponent** components, int numComponents) override; 54 | void completeResolve() override; 55 | void updateJellies(); 56 | void update(DirtyFlags dirt) override; 57 | }; 58 | } // namespace flare 59 | #endif -------------------------------------------------------------------------------- /flare/src/block_reader.cpp: -------------------------------------------------------------------------------- 1 | #include "flare/block_reader.hpp" 2 | #include "flare/exceptions/overflow_exception.hpp" 3 | 4 | #include "flare_math/mat2d.hpp" 5 | #include "flare_math/vec2d.hpp" 6 | #include "flare_math/color.hpp" 7 | 8 | using namespace flare; 9 | 10 | BlockReader::BlockReader(unsigned char* data, unsigned int length) : 11 | BinaryReader(data, length, BinaryReader::LittleEndian) 12 | { 13 | } 14 | 15 | BlockReader::BlockReader(int type, unsigned char* data, unsigned int length) : 16 | BinaryReader(data, length, BinaryReader::LittleEndian), 17 | m_BlockType(type) 18 | { 19 | } 20 | 21 | void BlockReader::read(Mat2D& mat) 22 | { 23 | float arr[6]; 24 | readFloat32Array(arr, 6); 25 | mat[0] = arr[0]; 26 | mat[1] = arr[1]; 27 | mat[2] = arr[2]; 28 | mat[3] = arr[3]; 29 | mat[4] = arr[4]; 30 | mat[5] = arr[5]; 31 | } 32 | 33 | void BlockReader::read(Vec2D& vec) 34 | { 35 | float arr[2]; 36 | readFloat32Array(arr, 2); 37 | vec[0] = arr[0]; 38 | vec[1] = arr[1]; 39 | } 40 | 41 | void BlockReader::read(Color& color) 42 | { 43 | float arr[4]; 44 | readFloat32Array(arr, 4); 45 | color[0] = arr[0]; 46 | color[1] = arr[1]; 47 | color[2] = arr[2]; 48 | color[3] = arr[3]; 49 | } 50 | 51 | BlockReader* BlockReader::readNextBlock() 52 | { 53 | if (m_DataPosition == m_DataLength) 54 | { 55 | return nullptr; 56 | } 57 | unsigned char blockType = readUint8(); 58 | unsigned int length = readUint32(); 59 | 60 | if (m_DataPosition + length > m_DataLength) 61 | { 62 | throw OverflowException("Block length is invalid and would cause overflow in BlockReader::readNextBlock."); 63 | } 64 | unsigned char* blockData = m_Data + m_DataPosition; 65 | 66 | m_DataPosition += length; 67 | return new BlockReader((int)blockType, blockData, length); 68 | } -------------------------------------------------------------------------------- /flare/src/path/actor_star.cpp: -------------------------------------------------------------------------------- 1 | #include "flare/path/actor_star.hpp" 2 | #include "flare/actor_shape.hpp" 3 | #include "flare/block_reader.hpp" 4 | #include 5 | 6 | using namespace flare; 7 | 8 | ActorStar::ActorStar() : Base(ComponentType::ActorStar), m_NumPoints(5), m_InnerRadius(0.0f) {} 9 | 10 | void ActorStar::makePoints() 11 | { 12 | float radiusX = width() / 2.0f; 13 | float radiusY = height() / 2.0f; 14 | int numSides = m_NumPoints * 2; 15 | 16 | m_Points.push_back(new StraightPathPoint(Vec2D(0.0f, -radiusY))); 17 | 18 | float angle = -M_PI / 2.0; 19 | float inc = (M_PI * 2.0) / numSides; 20 | Vec2D sx(radiusX, radiusX * m_InnerRadius); 21 | Vec2D sy(radiusY, radiusY * m_InnerRadius); 22 | 23 | for (int i = 0; i < numSides; i++) 24 | { 25 | m_Points.push_back(new StraightPathPoint(Vec2D(cos(angle) * sx[i % 2], sin(angle) * sy[i % 2]))); 26 | angle += inc; 27 | } 28 | } 29 | 30 | void ActorStar::copy(const ActorStar* star, ActorArtboard* artboard) 31 | { 32 | Base::copy(star, artboard); 33 | m_NumPoints = star->m_NumPoints; 34 | m_InnerRadius = star->m_InnerRadius; 35 | } 36 | 37 | ActorComponent* ActorStar::makeInstance(ActorArtboard* artboard) const 38 | { 39 | ActorStar* instance = new ActorStar(); 40 | instance->copy(this, artboard); 41 | return instance; 42 | } 43 | 44 | ActorStar* ActorStar::read(ActorArtboard* artboard, BlockReader* reader, ActorStar* component) 45 | { 46 | Base::read(artboard, reader, component); 47 | 48 | component->m_NumPoints = reader->readUint32(); 49 | component->m_InnerRadius = reader->readFloat32(); 50 | return component; 51 | } 52 | 53 | bool ActorStar::innerRadius(float value) 54 | { 55 | if (value == m_InnerRadius) 56 | { 57 | return false; 58 | } 59 | m_InnerRadius = value; 60 | invalidateDrawable(); 61 | return true; 62 | } -------------------------------------------------------------------------------- /flare/src/actor_skinnable.cpp: -------------------------------------------------------------------------------- 1 | #include "flare/actor_skinnable.hpp" 2 | #include "flare/block_reader.hpp" 3 | 4 | using namespace flare; 5 | 6 | ActorSkinnable::SkinnedBone::SkinnedBone() : boneIndex(0) {} 7 | 8 | ActorSkinnable::ActorSkinnable() : m_Skin(nullptr) {} 9 | 10 | ActorSkin* ActorSkinnable::skin() const { return m_Skin; } 11 | 12 | ActorSkinnable* ActorSkinnable::read(ActorArtboard* artboard, BlockReader* reader, ActorSkinnable* skinnable) 13 | { 14 | int numConnectedBones = reader->readUint8(); 15 | if (numConnectedBones != 0) 16 | { 17 | skinnable->m_ConnectedBones.reserve(numConnectedBones); 18 | for (int i = 0; i < numConnectedBones; i++) 19 | { 20 | SkinnedBone bc; 21 | bc.boneIndex = reader->readUint16(); 22 | reader->read(bc.bind); 23 | Mat2D::invert(bc.inverseBind, bc.bind); 24 | skinnable->m_ConnectedBones.emplace_back(bc); 25 | } 26 | 27 | Mat2D worldOverride; 28 | reader->read(worldOverride); 29 | skinnable->overrideWorldTransform(worldOverride); 30 | } 31 | return skinnable; 32 | } 33 | 34 | void ActorSkinnable::resolveSkinnable(ActorComponent** components, int numComponents) 35 | { 36 | for (auto& skinnedBone : m_ConnectedBones) 37 | { 38 | if (skinnedBone.boneIndex >= 0 && skinnedBone.boneIndex < numComponents) 39 | { 40 | skinnedBone.node = dynamic_cast(components[skinnedBone.boneIndex]); 41 | } 42 | } 43 | } 44 | 45 | void ActorSkinnable::copySkinnable(const ActorSkinnable* skinnable, ActorArtboard* artboard) 46 | { 47 | m_ConnectedBones.clear(); 48 | for (auto& from : skinnable->m_ConnectedBones) 49 | { 50 | SkinnedBone bc; 51 | bc.boneIndex = from.node == nullptr ? -1 : from.node->componentIndex(); 52 | Mat2D::copy(bc.bind, from.bind); 53 | Mat2D::copy(bc.inverseBind, from.inverseBind); 54 | m_ConnectedBones.emplace_back(std::move(bc)); 55 | } 56 | } -------------------------------------------------------------------------------- /flare/src/actor_bone_base.cpp: -------------------------------------------------------------------------------- 1 | #include "flare/actor_bone_base.hpp" 2 | #include "flare/block_reader.hpp" 3 | 4 | using namespace flare; 5 | 6 | ActorBoneBase::ActorBoneBase(ComponentType type) : ActorNode(type), m_Length(0.0f), m_IsConnectedToImage(false) {} 7 | 8 | float ActorBoneBase::length() const { return m_Length; } 9 | 10 | void ActorBoneBase::length(float l) 11 | { 12 | if (m_Length == l) 13 | { 14 | return; 15 | } 16 | m_Length = l; 17 | for (ActorNode* node : m_Children) 18 | { 19 | ActorBoneBase* bone = dynamic_cast(node); 20 | if (bone == nullptr) 21 | { 22 | continue; 23 | } 24 | bone->x(l); 25 | } 26 | } 27 | 28 | bool ActorBoneBase::isConnectedToImage() const { return m_IsConnectedToImage; } 29 | 30 | void ActorBoneBase::isConnectedToImage(bool isIt) { m_IsConnectedToImage = isIt; } 31 | 32 | Vec2D ActorBoneBase::tipWorldTranslation() 33 | { 34 | Mat2D transform; 35 | transform[4] = m_Length; 36 | 37 | Mat2D::multiply(transform, worldTransform(), transform); 38 | 39 | Vec2D result; 40 | result[0] = transform[4]; 41 | result[1] = transform[5]; 42 | 43 | return result; 44 | } 45 | 46 | void ActorBoneBase::tipWorldTranslation(Vec2D& result) 47 | { 48 | Mat2D transform; 49 | transform[4] = m_Length; 50 | 51 | Mat2D::multiply(transform, worldTransform(), transform); 52 | result[0] = transform[4]; 53 | result[1] = transform[5]; 54 | } 55 | 56 | ActorBoneBase* ActorBoneBase::read(ActorArtboard* artboard, BlockReader* reader, ActorBoneBase* node) 57 | { 58 | ActorNode::read(artboard, reader, node); 59 | 60 | node->m_Length = reader->readFloat32(); 61 | 62 | return node; 63 | } 64 | 65 | void ActorBoneBase::copy(const ActorBoneBase* node, ActorArtboard* artboard) 66 | { 67 | ActorNode::copy(node, artboard); 68 | m_Length = node->m_Length; 69 | m_IsConnectedToImage = node->m_IsConnectedToImage; 70 | } 71 | -------------------------------------------------------------------------------- /flare/include/flare/actor_ik_constraint.hpp: -------------------------------------------------------------------------------- 1 | #ifndef _FLARE_ACTORIKCONSTRAINT_HPP_ 2 | #define _FLARE_ACTORIKCONSTRAINT_HPP_ 3 | 4 | #include "actor_bone.hpp" 5 | #include "actor_targeted_constraint.hpp" 6 | #include "flare_math/transform_components.hpp" 7 | #include "flare_math/mat2d.hpp" 8 | #include 9 | 10 | namespace flare 11 | { 12 | class Actor; 13 | 14 | class ActorIKConstraint : public ActorTargetedConstraint 15 | { 16 | typedef ActorTargetedConstraint Base; 17 | 18 | public: 19 | union InfluencedBone 20 | { 21 | unsigned short boneIndex; 22 | ActorBone* bone; 23 | 24 | InfluencedBone(); 25 | }; 26 | 27 | struct BoneChain 28 | { 29 | int index; 30 | ActorBone* bone; 31 | float angle; 32 | bool included; 33 | TransformComponents transformComponents; 34 | Mat2D parentWorldInverse; 35 | }; 36 | 37 | private: 38 | std::vector m_InfluencedBones; 39 | std::vector m_FKChain; 40 | std::vector m_BoneData; 41 | bool m_InvertDirection; 42 | 43 | void solve1(BoneChain* fk1, const Vec2D& worldTargetTranslation); 44 | void solve2(BoneChain* fk1, BoneChain* fk2, const Vec2D& worldTargetTranslation); 45 | void constrainRotation(BoneChain* fk, float rotation); 46 | 47 | public: 48 | ActorIKConstraint(); 49 | ActorIKConstraint(ActorIKConstraint* target); // Support old system. 50 | 51 | ActorComponent* makeInstance(ActorArtboard* artboard) const override; 52 | void copy(const ActorIKConstraint* node, ActorArtboard* artboard); 53 | void resolveComponentIndices(ActorComponent** nodes, int numComponents) override; 54 | void completeResolve() override; 55 | void constrain(ActorNode* node) override; 56 | 57 | static ActorIKConstraint* read(ActorArtboard* artboard, BlockReader* reader, ActorIKConstraint* node = nullptr); 58 | }; 59 | } // namespace flare 60 | 61 | #endif -------------------------------------------------------------------------------- /example/build/genie.lua: -------------------------------------------------------------------------------- 1 | BASE_DIR = path.getabsolute("../..") 2 | 3 | solution "example" 4 | 5 | configurations 6 | { 7 | "Debug", 8 | "Release" 9 | } 10 | 11 | configuration "Debug" 12 | flags 13 | { 14 | "Symbols" 15 | } 16 | 17 | location("./"); 18 | dofile(path.join(BASE_DIR, "flare_math/build/flare_math.lua")) 19 | location("./"); 20 | dofile(path.join(BASE_DIR, "flare/build/flare.lua")) 21 | location("./"); 22 | dofile(path.join(BASE_DIR, "flare_skia/build/flare_skia.lua")) 23 | 24 | project "example" 25 | kind "ConsoleApp" 26 | language "C++" 27 | 28 | configuration { "Debug" } 29 | targetdir "./debug/bin" 30 | objdir "./debug/bin/obj" 31 | 32 | configuration { "Release" } 33 | targetdir "./release/bin" 34 | objdir "./release/bin/obj" 35 | 36 | configuration "macosx" 37 | links { "Cocoa.framework", "IOKit.framework", "CoreVideo.framework" } 38 | includedirs { "/usr/local/include" } 39 | libdirs { "/usr/local/lib" } 40 | 41 | configuration { } 42 | 43 | libdirs 44 | { 45 | "../../dependencies/glfw_build/src", 46 | "../../dependencies/skia/out/Static" 47 | } 48 | 49 | includedirs 50 | { 51 | "../../dependencies/glfw/include", 52 | "../../dependencies/skia", 53 | "../../dependencies/skia/include/core", 54 | "../../dependencies/skia/include/effects", 55 | "../../dependencies/skia/include/gpu", 56 | "../../dependencies/skia/include/config", 57 | "../../flare_skia/include", 58 | "../../flare/include", 59 | "../../flare_math/include" 60 | } 61 | 62 | links 63 | { 64 | "flare_skia", 65 | "flare", 66 | "flare_math", 67 | "glfw3", 68 | "skia", 69 | "png", 70 | "zlib", 71 | "sksg", 72 | "skshaper", 73 | "freetype2" 74 | } 75 | 76 | buildoptions_cpp 77 | { 78 | "-std=c++11", 79 | "-fembed-bitcode" 80 | } 81 | 82 | files 83 | { 84 | "../src/**.cpp" 85 | } 86 | 87 | targetname "example" -------------------------------------------------------------------------------- /flare/src/animation/keyframes/keyframe_draw_order.cpp: -------------------------------------------------------------------------------- 1 | #include "flare/animation/keyframes/keyframe_draw_order.hpp" 2 | #include "flare/actor.hpp" 3 | #include "flare/actor_drawable.hpp" 4 | #include "flare/block_reader.hpp" 5 | 6 | using namespace flare; 7 | 8 | 9 | KeyFrameDrawOrder::KeyFrameDrawOrder() : 10 | m_OrderedNodes(NULL), 11 | m_OrderedNodesCount(0) 12 | { 13 | 14 | } 15 | 16 | KeyFrameDrawOrder::~KeyFrameDrawOrder() 17 | { 18 | delete m_OrderedNodes; 19 | } 20 | 21 | 22 | bool KeyFrameDrawOrder::read(BlockReader* reader, ActorComponent* component) 23 | { 24 | if(!Base::read(reader, component)) 25 | { 26 | return false; 27 | } 28 | m_OrderedNodesCount = (int)reader->readUint16(); 29 | m_OrderedNodes = new DrawOrderIndex[m_OrderedNodesCount]; 30 | for(int i = 0; i < m_OrderedNodesCount; i++) 31 | { 32 | DrawOrderIndex& drawOrder = m_OrderedNodes[i]; 33 | drawOrder.nodeIdx = reader->readUint16(); 34 | drawOrder.order = reader->readUint16(); 35 | } 36 | return true; 37 | } 38 | 39 | void KeyFrameDrawOrder::setNext(KeyFrame* frame) 40 | { 41 | // Do nothing, we don't interpolate. 42 | } 43 | 44 | void KeyFrameDrawOrder::apply(ActorComponent* component, float mix) 45 | { 46 | ActorArtboard* artboard = component->artboard(); 47 | 48 | for(int i = 0; i < m_OrderedNodesCount; i++) 49 | { 50 | DrawOrderIndex& doi = m_OrderedNodes[i]; 51 | // Some pretty hard assumptions being made here. We're assuming we had good data to begin with. 52 | // Could validate it at load time by passing the actor into the read methods. 53 | ActorDrawable* renderNode = dynamic_cast(artboard->component(doi.nodeIdx)); 54 | if(renderNode != nullptr) 55 | { 56 | renderNode->drawOrder(doi.order); 57 | } 58 | } 59 | } 60 | 61 | void KeyFrameDrawOrder::applyInterpolation(ActorComponent* node, float time, KeyFrame* toFrame, float mix) 62 | { 63 | apply(node, mix); 64 | } -------------------------------------------------------------------------------- /flare/include/flare/path/actor_path.hpp: -------------------------------------------------------------------------------- 1 | #ifndef _FLARE_ACTORPATH_HPP_ 2 | #define _FLARE_ACTORPATH_HPP_ 3 | 4 | #include "flare_math/aabb.hpp" 5 | #include "flare_math/mat2d.hpp" 6 | #include "flare/actor_skinnable.hpp" 7 | #include "flare/path/actor_base_path.hpp" 8 | #include "flare/path/path_point.hpp" 9 | #include 10 | 11 | namespace flare 12 | { 13 | class ActorPath : public ActorBasePath, public ActorSkinnable 14 | { 15 | typedef ActorBasePath Base; 16 | 17 | private: 18 | bool m_IsHidden; 19 | bool m_IsClosed; 20 | std::vector m_Points; 21 | std::vector m_DeformedPoints; 22 | float* m_VertexDeform; 23 | int m_VertexDeformLength; 24 | 25 | static const unsigned char VertexDeformDirty = 1 << 2; 26 | public: 27 | ActorPath(); 28 | ~ActorPath(); 29 | 30 | bool isPathInWorldSpace() const override { return isConnectedToBones(); } 31 | const Mat2D& pathTransform() const override; 32 | const std::vector& deformedPoints() override; 33 | const std::vector& points() override { return m_Points; }; 34 | float* vertexDeform() { return m_VertexDeform; } 35 | void onDirty(DirtyFlags dirt) override; 36 | 37 | void copy(const ActorPath* path, ActorArtboard* resetActor); 38 | void resolveComponentIndices(ActorComponent** nodes, int numComponents) override; 39 | void invalidateDrawable() override; 40 | static ActorPath* read(ActorArtboard* artboard, BlockReader* reader, ActorPath* component = NULL); 41 | void makeVertexDeform(); 42 | void markVertexDeformDirty(); 43 | void update(DirtyFlags dirt) override; 44 | 45 | // Help ActorSkinnable find the override call. 46 | void overrideWorldTransform(const Mat2D& transform) override { ActorNode::overrideWorldTransform(transform); } 47 | 48 | bool isClosed() override { return m_IsClosed; } 49 | }; 50 | } // namespace flare 51 | #endif -------------------------------------------------------------------------------- /flare/src/actor_procedural_path.cpp: -------------------------------------------------------------------------------- 1 | #include "flare/path/actor_procedural_path.hpp" 2 | #include "flare/actor_shape.hpp" 3 | #include "flare/block_reader.hpp" 4 | 5 | using namespace flare; 6 | 7 | ActorProceduralPath::ActorProceduralPath(ComponentType type) : Base(type) {} 8 | ActorProceduralPath::~ActorProceduralPath() { invalidateDrawable(); } 9 | void ActorProceduralPath::width(float value) 10 | { 11 | if (m_Width == value) 12 | { 13 | return; 14 | } 15 | m_Width = value; 16 | invalidateDrawable(); 17 | } 18 | 19 | void ActorProceduralPath::height(float value) 20 | { 21 | if (m_Height == value) 22 | { 23 | return; 24 | } 25 | m_Height = value; 26 | invalidateDrawable(); 27 | } 28 | 29 | void ActorProceduralPath::copy(const ActorProceduralPath* path, ActorArtboard* resetActor) 30 | { 31 | Base::copy(path, resetActor); 32 | m_Width = path->m_Width; 33 | m_Height = path->m_Height; 34 | } 35 | 36 | void ActorProceduralPath::onDirty(DirtyFlags dirt) 37 | { 38 | Base::onDirty(dirt); 39 | if (shape() != nullptr) 40 | { 41 | shape()->invalidateDrawable(); 42 | } 43 | } 44 | 45 | void ActorProceduralPath::invalidateDrawable() 46 | { 47 | if (shape() != nullptr) 48 | { 49 | shape()->invalidateDrawable(); 50 | } 51 | for (auto point : m_Points) 52 | { 53 | delete point; 54 | } 55 | m_Points.clear(); 56 | } 57 | 58 | const std::vector& ActorProceduralPath::deformedPoints() { return points(); } 59 | 60 | const std::vector& ActorProceduralPath::points() 61 | { 62 | if (m_Points.empty()) 63 | { 64 | makePoints(); 65 | } 66 | return m_Points; 67 | } 68 | 69 | ActorProceduralPath* ActorProceduralPath::read(ActorArtboard* artboard, BlockReader* reader, ActorProceduralPath* component) 70 | { 71 | Base::read(artboard, reader, component); 72 | 73 | component->m_Width = reader->readFloat32(); 74 | component->m_Height = reader->readFloat32(); 75 | return component; 76 | } -------------------------------------------------------------------------------- /flare_math/include/flare_math/transform_components.hpp: -------------------------------------------------------------------------------- 1 | #ifndef _FLARE_TRANSFORMCOMPONENTS_HPP_ 2 | #define _FLARE_TRANSFORMCOMPONENTS_HPP_ 3 | 4 | #include "vec2d.hpp" 5 | #include 6 | 7 | namespace flare 8 | { 9 | class TransformComponents 10 | { 11 | private: 12 | float m_X; 13 | float m_Y; 14 | float m_ScaleX; 15 | float m_ScaleY; 16 | float m_Rotation; 17 | float m_Skew; 18 | 19 | public: 20 | TransformComponents() : m_X(0.0f), m_Y(0.0f), m_ScaleX(1.0f), m_ScaleY(1.0f), m_Rotation(0.0f), m_Skew(0.0f) {} 21 | TransformComponents(const TransformComponents& copy) : 22 | m_X(copy.m_X), 23 | m_Y(copy.m_Y), 24 | m_ScaleX(copy.m_ScaleX), 25 | m_ScaleY(copy.m_ScaleY), 26 | m_Rotation(copy.m_Rotation), 27 | m_Skew(copy.m_Skew) 28 | { 29 | } 30 | 31 | float x() const { return m_X; } 32 | void x(float value) { m_X = value; } 33 | float y() const { return m_Y; } 34 | void y(float value) { m_Y = value; } 35 | float scaleX() const { return m_ScaleX; } 36 | void scaleX(float value) { m_ScaleX = value; } 37 | float scaleY() const { return m_ScaleY; } 38 | void scaleY(float value) { m_ScaleY = value; } 39 | float rotation() const { return m_Rotation; } 40 | void rotation(float value) { m_Rotation = value; } 41 | float skew() const { return m_Skew; } 42 | void skew(float value) { m_Skew = value; } 43 | 44 | void translation(Vec2D& result) const 45 | { 46 | result[0] = m_X; 47 | result[1] = m_Y; 48 | } 49 | void scale(Vec2D& result) const 50 | { 51 | result[0] = m_ScaleX; 52 | result[1] = m_ScaleY; 53 | } 54 | 55 | static void copy(TransformComponents& result, const TransformComponents& a) 56 | { 57 | result.m_X = a.m_X; 58 | result.m_Y = a.m_Y; 59 | result.m_ScaleX = a.m_ScaleX; 60 | result.m_ScaleY = a.m_ScaleY; 61 | result.m_Rotation = a.m_Rotation; 62 | result.m_Skew = a.m_Skew; 63 | } 64 | }; 65 | } // namespace flare 66 | #endif -------------------------------------------------------------------------------- /flare/src/animation/keyframes/keyframe_fill_color.cpp: -------------------------------------------------------------------------------- 1 | #include "flare/animation/keyframes/keyframe_color.hpp" 2 | #include "flare/block_reader.hpp" 3 | #include "flare/paint/actor_color.hpp" 4 | 5 | using namespace flare; 6 | 7 | KeyFrameColor::KeyFrameColor() : m_Value{0.0f} {} 8 | 9 | bool KeyFrameColor::read(BlockReader* reader, ActorComponent* component) 10 | { 11 | if (dynamic_cast(component) == nullptr || !Base::read(reader, component)) 12 | { 13 | return false; 14 | } 15 | reader->readFloat32Array(m_Value, 4); 16 | return true; 17 | } 18 | 19 | void KeyFrameColor::apply(ActorComponent* component, float mix) 20 | { 21 | ActorColor* actorColor = static_cast(component); 22 | if (actorColor == nullptr) 23 | { 24 | return; 25 | } 26 | Color wr; 27 | if (mix == 1.0) 28 | { 29 | for (int i = 0; i < 4; i++) 30 | { 31 | wr[i] = m_Value[i]; 32 | } 33 | } 34 | else 35 | { 36 | float mixi = 1.0 - mix; 37 | for (int i = 0; i < 4; i++) 38 | { 39 | wr[i] = wr[i] * mixi + m_Value[i] * mix; 40 | } 41 | } 42 | actorColor->color(wr); 43 | } 44 | 45 | void KeyFrameColor::applyInterpolation(ActorComponent* component, float time, KeyFrame* toFrame, float mix) 46 | { 47 | ActorColor* actorColor = static_cast(component); 48 | if (actorColor == nullptr) 49 | { 50 | return; 51 | } 52 | Color wr; 53 | float* to = reinterpret_cast(toFrame)->m_Value; 54 | 55 | float f = (time - m_Time) / (toFrame->time() - m_Time); 56 | if (m_Interpolator != nullptr) 57 | { 58 | f = m_Interpolator->getEasedMix(f); 59 | } 60 | float fi = 1.0 - f; 61 | if (mix == 1.0) 62 | { 63 | for (int i = 0; i < 4; i++) 64 | { 65 | wr[i] = m_Value[i] * fi + to[i] * f; 66 | } 67 | } 68 | else 69 | { 70 | float mixi = 1.0 - mix; 71 | for (int i = 0; i < 4; i++) 72 | { 73 | float v = m_Value[i] * fi + to[i] * f; 74 | 75 | wr[i] = wr[i] * mixi + v * mix; 76 | } 77 | } 78 | actorColor->color(wr); 79 | } -------------------------------------------------------------------------------- /dependencies/make_dependencies.sh: -------------------------------------------------------------------------------- 1 | #!/bin/sh 2 | 3 | # Requires depot_tools and git: 4 | # https://skia.org/user/download 5 | # Build notes: 6 | # https://skia.org/user/build 7 | # GLFW requires CMake 8 | 9 | SKIA_REPO=https://github.com/google/skia 10 | GLFW_REPO=https://github.com/glfw/glfw 11 | 12 | # ----------------------------- 13 | # Get & Build Skia 14 | # ----------------------------- 15 | if [ ! -d skia ]; then 16 | echo "Cloning Skia." 17 | git clone $SKIA_REPO 18 | else 19 | echo "Already have Skia, update it." 20 | cd skia && git fetch && git merge master 21 | cd .. 22 | fi 23 | 24 | cd skia 25 | python tools/git-sync-deps 26 | bin/gn gen out/Static --args=" \ 27 | is_official_build=true \ 28 | skia_use_angle=false \ 29 | skia_use_dng_sdk=false \ 30 | skia_use_egl=false \ 31 | skia_use_expat=false \ 32 | skia_use_fontconfig=false \ 33 | skia_use_freetype=true \ 34 | skia_use_system_freetype2=false \ 35 | skia_use_icu=false \ 36 | skia_use_libheif=false \ 37 | skia_use_libjpeg_turbo=false \ 38 | skia_use_libpng=true \ 39 | skia_use_system_libpng=false \ 40 | skia_use_libwebp=false \ 41 | skia_use_lua=false \ 42 | skia_use_piex=false \ 43 | skia_use_vulkan=false \ 44 | skia_use_metal=false \ 45 | skia_use_zlib=true \ 46 | skia_use_system_zlib=false \ 47 | skia_enable_ccpr=true \ 48 | skia_enable_gpu=true \ 49 | skia_enable_fontmgr_empty=false \ 50 | skia_enable_spirv_validation=false \ 51 | skia_enable_pdf=false 52 | " 53 | ninja -C out/Static 54 | cd .. 55 | 56 | # ----------------------------- 57 | # Get & Build GLFW 58 | # ----------------------------- 59 | if [ ! -d glfw ]; then 60 | echo "Cloning GLFW." 61 | git clone $GLFW_REPO 62 | else 63 | echo "Already have GLFW, update it." 64 | cd glfw && git fetch && git merge master 65 | cd .. 66 | fi 67 | 68 | mkdir glfw_build 69 | cd glfw_build 70 | cmake ../glfw -DBUILD_SHARED_LIBS=OFF 71 | make -------------------------------------------------------------------------------- /flare/src/animation/keyframes/keyframe_numeric.cpp: -------------------------------------------------------------------------------- 1 | #include "flare/animation/keyframes/keyframe_numeric.hpp" 2 | #include "flare/block_reader.hpp" 3 | 4 | using namespace flare; 5 | 6 | KeyFrameNumeric::KeyFrameNumeric() : 7 | m_Value(0.0f) 8 | { 9 | 10 | } 11 | 12 | float KeyFrameNumeric::value() const 13 | { 14 | return m_Value; 15 | } 16 | 17 | bool KeyFrameNumeric::read(BlockReader* reader, ActorComponent* component) 18 | { 19 | if(!Base::read(reader, component)) 20 | { 21 | return false; 22 | } 23 | 24 | m_Value = reader->readFloat32(); 25 | 26 | return true; 27 | } 28 | 29 | void KeyFrameNumeric::apply(ActorComponent* component, float mix) 30 | { 31 | this->setValue(component, m_Value, mix); 32 | } 33 | 34 | void KeyFrameNumeric::applyInterpolation(ActorComponent* component, float time, KeyFrame* toFrame, float mix) 35 | { 36 | double f = (time - m_Time) / (toFrame->time() - m_Time); 37 | if(m_Interpolator != nullptr) 38 | { 39 | f = m_Interpolator->getEasedMix(f); 40 | } 41 | setValue(component, m_Value * (1.0 - f) + reinterpret_cast(toFrame)->value() * f, mix); 42 | } 43 | 44 | KeyFrameInt::KeyFrameInt() : 45 | m_Value(0) 46 | { 47 | 48 | } 49 | 50 | int KeyFrameInt::value() const 51 | { 52 | return m_Value; 53 | } 54 | 55 | bool KeyFrameInt::read(BlockReader* reader, ActorComponent* component) 56 | { 57 | if(!Base::read(reader, component)) 58 | { 59 | return false; 60 | } 61 | 62 | m_Value = reader->readInt32(); 63 | 64 | return true; 65 | } 66 | 67 | void KeyFrameInt::apply(ActorComponent* component, float mix) 68 | { 69 | this->setValue(component, m_Value, mix); 70 | } 71 | 72 | void KeyFrameInt::applyInterpolation(ActorComponent* component, float time, KeyFrame* toFrame, float mix) 73 | { 74 | double f = (time - m_Time) / (toFrame->time() - m_Time); 75 | if(m_Interpolator != nullptr) 76 | { 77 | f = m_Interpolator->getEasedMix(f); 78 | } 79 | setValue(component, m_Value * (1.0 - f) + reinterpret_cast(toFrame)->value() * f, mix); 80 | } -------------------------------------------------------------------------------- /flare/src/path/straight_path_point.cpp: -------------------------------------------------------------------------------- 1 | #include "flare/block_reader.hpp" 2 | #include "flare/path/path_point.hpp" 3 | 4 | using namespace flare; 5 | 6 | StraightPathPoint::StraightPathPoint() : PathPoint(PointType::Straight), m_Radius(0.0f) {} 7 | StraightPathPoint::StraightPathPoint(Vec2D translation) : PathPoint(PointType::Straight, translation), m_Radius(0.0f) {} 8 | StraightPathPoint::StraightPathPoint(Vec2D translation, float radius) : PathPoint(PointType::Straight, translation), m_Radius(radius) {} 9 | 10 | PathPoint* StraightPathPoint::makeInstance() const 11 | { 12 | StraightPathPoint* point = new StraightPathPoint(); 13 | point->copy(this); 14 | return point; 15 | } 16 | 17 | void StraightPathPoint::copy(const StraightPathPoint* from) 18 | { 19 | PathPoint::copy(from); 20 | m_Radius = from->m_Radius; 21 | } 22 | 23 | void StraightPathPoint::radius(float value) 24 | { 25 | m_Radius = value; 26 | } 27 | 28 | void StraightPathPoint::readPoint(BlockReader* reader, bool isConnectedToBones) 29 | { 30 | m_Radius = reader->readFloat32(); 31 | if (isConnectedToBones) 32 | { 33 | setWeightCount(8); 34 | } 35 | } 36 | 37 | PathPoint* StraightPathPoint::skin(const Mat2D& world, const float* bones) 38 | { 39 | StraightPathPoint* point = new StraightPathPoint(); 40 | point->m_Radius = m_Radius; 41 | 42 | float px = world[0] * m_Translation[0] + world[2] * m_Translation[1] + world[4]; 43 | float py = world[1] * m_Translation[0] + world[3] * m_Translation[1] + world[5]; 44 | 45 | float a = 0.0, b = 0.0, c = 0.0, d = 0.0, e = 0.0, f = 0.0; 46 | 47 | for (int i = 0; i < 4; i++) 48 | { 49 | int boneIndex = (int)m_Weights[i]; 50 | float weight = m_Weights[i + 4]; 51 | if (weight > 0) 52 | { 53 | int bb = boneIndex * 6; 54 | 55 | a += bones[bb] * weight; 56 | b += bones[bb + 1] * weight; 57 | c += bones[bb + 2] * weight; 58 | d += bones[bb + 3] * weight; 59 | e += bones[bb + 4] * weight; 60 | f += bones[bb + 5] * weight; 61 | } 62 | } 63 | 64 | Vec2D& pos = point->translation(); 65 | pos[0] = a * px + c * py + e; 66 | pos[1] = b * px + d * py + f; 67 | 68 | return point; 69 | } -------------------------------------------------------------------------------- /flare_math/include/flare_math/vec2d.hpp: -------------------------------------------------------------------------------- 1 | #ifndef _FLARE_VEC2D_HPP_ 2 | #define _FLARE_VEC2D_HPP_ 3 | 4 | #include 5 | 6 | namespace flare 7 | { 8 | class Mat2D; 9 | class Vec2D 10 | { 11 | private: 12 | float m_Buffer[2]; 13 | 14 | public: 15 | Vec2D(); 16 | Vec2D(const Vec2D& copy); 17 | Vec2D(float x, float y); 18 | 19 | inline const float* values() const { return m_Buffer; } 20 | 21 | float& operator[](std::size_t idx) { return m_Buffer[idx]; } 22 | const float& operator[](std::size_t idx) const { return m_Buffer[idx]; } 23 | 24 | static void transform(Vec2D& result, const Vec2D& a, const Mat2D& m); 25 | static void transformDir(Vec2D& result, const Vec2D& a, const Mat2D& m); 26 | static void subtract(Vec2D& result, const Vec2D& a, const Vec2D& b); 27 | static void add(Vec2D& result, const Vec2D& a, const Vec2D& b); 28 | static float length(const Vec2D& a); 29 | static float distance(const Vec2D& a, const Vec2D& b); 30 | static void copy(Vec2D& result, const Vec2D& a); 31 | static void normalize(Vec2D& result, const Vec2D& a); 32 | static float dot(const Vec2D& a, const Vec2D& b); 33 | static void lerp(Vec2D& o, const Vec2D& a, const Vec2D& b, float f); 34 | static void scale(Vec2D& o, const Vec2D& a, float scale); 35 | static void scaleAndAdd(Vec2D& o, const Vec2D& a, const Vec2D&b, float scale); 36 | static void negate(Vec2D& o, const Vec2D& a); 37 | }; 38 | 39 | inline Vec2D operator*(const Mat2D& a, const Vec2D& b) 40 | { 41 | Vec2D result; 42 | Vec2D::transform(result, b, a); 43 | return result; 44 | } 45 | 46 | inline Vec2D operator-(const Vec2D& a, const Vec2D& b) 47 | { 48 | Vec2D result; 49 | Vec2D::subtract(result, a, b); 50 | return result; 51 | } 52 | 53 | inline Vec2D operator+(const Vec2D& a, const Vec2D& b) 54 | { 55 | Vec2D result; 56 | Vec2D::add(result, a, b); 57 | return result; 58 | } 59 | 60 | inline bool operator==(const Vec2D& a, const Vec2D& b) { return a[0] == b[0] && a[1] == b[1]; } 61 | inline bool operator!=(const Vec2D& a, const Vec2D& b) { return a[0] != b[0] || a[1] != b[1]; } 62 | } // namespace flare 63 | #endif -------------------------------------------------------------------------------- /flare/src/paint/actor_paint.cpp: -------------------------------------------------------------------------------- 1 | #include "flare/paint/actor_paint.hpp" 2 | #include "flare/actor_artboard.hpp" 3 | #include "flare/actor_shape.hpp" 4 | #include "flare/block_reader.hpp" 5 | 6 | using namespace flare; 7 | 8 | ActorPaint::ActorPaint(ComponentType type) : 9 | ActorComponent(nullptr, type), 10 | m_Opacity(1.0f), 11 | m_RenderOpacity(1.0f), 12 | m_IsPaintInvalid(false), 13 | m_Shape(nullptr) 14 | { 15 | } 16 | 17 | void ActorPaint::onParentChanged(ActorNode* from, ActorNode* to) 18 | { 19 | if (to != nullptr && to->type() == ComponentType::ActorShape) 20 | { 21 | ActorShape* oldShape = m_Shape; 22 | m_Shape = static_cast(to); 23 | onShapeChanged(oldShape, m_Shape); 24 | } 25 | } 26 | 27 | void ActorPaint::opacity(float value) 28 | { 29 | if (value == m_Opacity) 30 | { 31 | return; 32 | } 33 | m_Opacity = value; 34 | markPaintDirty(); 35 | } 36 | 37 | void ActorPaint::copy(const ActorPaint* paint, ActorArtboard* artboard) 38 | { 39 | Base::copy(paint, artboard); 40 | m_Opacity = paint->m_Opacity; 41 | } 42 | 43 | ActorPaint* ActorPaint::read(ActorArtboard* artboard, BlockReader* reader, ActorPaint* component) 44 | { 45 | Base::read(artboard, reader, component); 46 | component->m_Opacity = reader->readFloat32(); 47 | return component; 48 | } 49 | 50 | void ActorPaint::completeResolve() 51 | { 52 | Base::completeResolve(); 53 | m_Artboard->addDependency(this, m_Parent); 54 | } 55 | 56 | void ActorPaint::update(DirtyFlags dirt) 57 | { 58 | float ro = m_Shape != nullptr ? m_Shape->renderOpacity() * m_Opacity : 1.0f; 59 | if (ro != m_RenderOpacity) 60 | { 61 | m_RenderOpacity = ro; 62 | invalidatePaint(); 63 | } 64 | 65 | // If something has forced our dirty flag up, make sure we invalidate the paint. 66 | if((dirt & DirtyFlags::PaintDirty) == DirtyFlags::PaintDirty) 67 | { 68 | invalidatePaint(); 69 | } 70 | } 71 | 72 | void ActorPaint::markPaintDirty() { m_Artboard->addDirt(this, DirtyFlags::PaintDirty, false); } 73 | 74 | void ActorPaint::invalidatePaint() { m_IsPaintInvalid = true; } 75 | 76 | void ActorPaint::validatePaint() 77 | { 78 | if(m_IsPaintInvalid) 79 | { 80 | m_IsPaintInvalid = false; 81 | updatePaint(); 82 | } 83 | } -------------------------------------------------------------------------------- /flare/src/animation/keyframes/keyframe_custom_property.cpp: -------------------------------------------------------------------------------- 1 | #include "flare/animation/keyframes/keyframe_custom_property.hpp" 2 | #include "flare/block_reader.hpp" 3 | #include "flare/custom_property.hpp" 4 | #include 5 | 6 | using namespace flare; 7 | 8 | void KeyFrameIntProperty::setValue(ActorComponent* component, float value, float mix) 9 | { 10 | CustomIntProperty* property = reinterpret_cast(component); 11 | property->value((int)round(property->value() * (1.0f - mix) + value * mix)); 12 | } 13 | 14 | void KeyFrameFloatProperty::setValue(ActorComponent* component, float value, float mix) 15 | { 16 | CustomFloatProperty* property = reinterpret_cast(component); 17 | property->value(property->value() * (1.0f - mix) + value * mix); 18 | } 19 | 20 | bool KeyFrameStringProperty::read(BlockReader* reader, ActorComponent* component) 21 | { 22 | if(!Base::read(reader, component)) 23 | { 24 | return false; 25 | } 26 | m_Value = reader->readString(); 27 | return true; 28 | } 29 | 30 | void KeyFrameStringProperty::setNext(KeyFrame* frame) 31 | { 32 | // Intentionally blank, we do not interpolate. 33 | } 34 | 35 | void KeyFrameStringProperty::apply(ActorComponent* component, float mix) 36 | { 37 | CustomStringProperty* property = reinterpret_cast(component); 38 | property->value(m_Value); 39 | } 40 | 41 | void KeyFrameStringProperty::applyInterpolation(ActorComponent* component, float time, KeyFrame* toFrame, float mix) 42 | { 43 | apply(component, mix); 44 | } 45 | 46 | bool KeyFrameBooleanProperty::read(BlockReader* reader, ActorComponent* component) 47 | { 48 | if(!Base::read(reader, component)) 49 | { 50 | return false; 51 | } 52 | m_Value = reader->readUint8() == 1; 53 | return true; 54 | } 55 | 56 | void KeyFrameBooleanProperty::setNext(KeyFrame* frame) 57 | { 58 | // Intentionally blank, we do not interpolate. 59 | } 60 | 61 | void KeyFrameBooleanProperty::apply(ActorComponent* component, float mix) 62 | { 63 | CustomBooleanProperty* property = reinterpret_cast(component); 64 | property->value(m_Value); 65 | } 66 | 67 | void KeyFrameBooleanProperty::applyInterpolation(ActorComponent* component, float time, KeyFrame* toFrame, float mix) 68 | { 69 | apply(component, mix); 70 | } --------------------------------------------------------------------------------