submodule/include/generated/bones/root_bone_base.hpp

   1 #ifndef _RIVE_ROOT_BONE_BASE_HPP_
   2 #define _RIVE_ROOT_BONE_BASE_HPP_
   3 #include "bones/bone.hpp"
   4 #include "core/field_types/core_double_type.hpp"
   5 namespace rive
   6 {
   7         class RootBoneBase : public Bone
   8         {
   9         protected:
  10                 typedef Bone Super;
  11
  12         public:
  13                 static const int typeKey = 41;
  14
  15                 /// Helper to quickly determine if a core object extends another without
  16                 /// RTTI at runtime.
  17                 bool isTypeOf(int typeKey) const override
  18                 {
  19                         switch (typeKey)
  20                         {
  21                                 case RootBoneBase::typeKey:
  22                                 case BoneBase::typeKey:
  23                                 case SkeletalComponentBase::typeKey:
  24                                 case TransformComponentBase::typeKey:
  25                                 case ContainerComponentBase::typeKey:
  26                                 case ComponentBase::typeKey:
  27                                         return true;
  28                                 default:
  29                                         return false;
  30                         }
  31                 }
  32
  33                 int coreType() const override { return typeKey; }
  34
  35                 static const int xPropertyKey = 90;
  36                 static const int yPropertyKey = 91;
  37
  38         private:
  39                 float m_X = 0;
  40                 float m_Y = 0;
  41         public:
  42                 inline float x() const override { return m_X; }
  43                 void x(float value)
  44                 {
  45                         if (m_X == value)
  46                         {
  47                                 return;
  48                         }
  49                         m_X = value;
  50                         xChanged();
  51                 }
  52
  53                 inline float y() const override { return m_Y; }
  54                 void y(float value)
  55                 {
  56                         if (m_Y == value)
  57                         {
  58                                 return;
  59                         }
  60                         m_Y = value;
  61                         yChanged();
  62                 }
  63
  64                 bool deserialize(int propertyKey, BinaryReader& reader) override
  65                 {
  66                         switch (propertyKey)
  67                         {
  68                                 case xPropertyKey:
  69                                         m_X = CoreDoubleType::deserialize(reader);
  70                                         return true;
  71                                 case yPropertyKey:
  72                                         m_Y = CoreDoubleType::deserialize(reader);
  73                                         return true;
  74                         }
  75                         return Bone::deserialize(propertyKey, reader);
  76                 }
  77
  78         protected:
  79                 virtual void xChanged() {}
  80                 virtual void yChanged() {}
  81         };
  82 } // namespace rive
  83
  84 #endif