[cpp][c] Clean up AtlasRegion, TextureRegion to use _ field prefixes and getters/setters instead of public fields

spine-c/build.sh

@@ -3,6 +3,12 @@ set -e
 
 cd "$(dirname "$0")"
 
+# Run codegen if requested
+if [ "$1" = "codegen" ]; then
+    npx tsx codegen/src/index.ts
+    exit 0
+fi
+
 # Clean only if explicitly requested
 if [ "$1" = "clean" ]; then
     rm -rf build

spine-c/codegen/exclusions.txt

@@ -40,7 +40,8 @@ method: TrackEntry::setRendererObject
 # Array<String> returning methods and fields not supported
 method: AttachmentTimeline::getAttachmentNames
 method: Skin::findNamesForSlot
-field: AtlasRegion::names
+method: AtlasRegion::getNames
+method: AtlasRegion::setNames
 
 # Array<Array<T>> returning methods not supported
 method: DeformTimeline::getVertices
@@ -68,4 +69,5 @@ method: TransformConstraintData::getSetupPose const
 
 # Exclude setters and constructor for RenderCommand
 method: RenderCommand::RenderCommand
-field-set: RenderCommand
+field-set: RenderCommand
+

spine-c/src/generated/animation_state.cpp

@@ -60,7 +60,7 @@ spine_track_entry spine_animation_state_get_current(spine_animation_state self,
 }
 
 spine_animation_state_data spine_animation_state_get_data(spine_animation_state self) {
-    return (spine_animation_state_data)((AnimationState*)self)->getData();
+    return (spine_animation_state_data)&((AnimationState*)self)->getData();
 }
 
 spine_array_track_entry spine_animation_state_get_tracks(spine_animation_state self) {

spine-c/src/generated/atlas_region.cpp

@@ -12,65 +12,149 @@ void spine_atlas_region_dispose(spine_atlas_region self) {
 }
 
 spine_atlas_page spine_atlas_region_get_page(spine_atlas_region self) {
-    return (spine_atlas_page)((AtlasRegion*)self)->page;
-}
-
-void spine_atlas_region_set_page(spine_atlas_region self, spine_atlas_page value) {
-    ((AtlasRegion*)self)->page = (AtlasPage*)value;
-}
-
-const char* spine_atlas_region_get_name(spine_atlas_region self) {
-    return ((AtlasRegion*)self)->name.buffer();
-}
-
-void spine_atlas_region_set_name(spine_atlas_region self, const char* value) {
-    ((AtlasRegion*)self)->name = String(value);
+    return (spine_atlas_page)((AtlasRegion*)self)->getPage();
 }
 
 int spine_atlas_region_get_index(spine_atlas_region self) {
-    return ((AtlasRegion*)self)->index;
-}
-
-void spine_atlas_region_set_index(spine_atlas_region self, int value) {
-    ((AtlasRegion*)self)->index = value;
+    return ((AtlasRegion*)self)->getIndex();
 }
 
 int spine_atlas_region_get_x(spine_atlas_region self) {
-    return ((AtlasRegion*)self)->x;
-}
-
-void spine_atlas_region_set_x(spine_atlas_region self, int value) {
-    ((AtlasRegion*)self)->x = value;
+    return ((AtlasRegion*)self)->getX();
 }
 
 int spine_atlas_region_get_y(spine_atlas_region self) {
-    return ((AtlasRegion*)self)->y;
-}
-
-void spine_atlas_region_set_y(spine_atlas_region self, int value) {
-    ((AtlasRegion*)self)->y = value;
+    return ((AtlasRegion*)self)->getY();
 }
 
 spine_array_int spine_atlas_region_get_splits(spine_atlas_region self) {
-    return (spine_array_int)&((AtlasRegion*)self)->splits;
-}
-
-void spine_atlas_region_set_splits(spine_atlas_region self, spine_array_int value) {
-    ((AtlasRegion*)self)->splits = *((Array<int>*)value);
+    return (spine_array_int)&((AtlasRegion*)self)->getSplits();
 }
 
 spine_array_int spine_atlas_region_get_pads(spine_atlas_region self) {
-    return (spine_array_int)&((AtlasRegion*)self)->pads;
-}
-
-void spine_atlas_region_set_pads(spine_atlas_region self, spine_array_int value) {
-    ((AtlasRegion*)self)->pads = *((Array<int>*)value);
+    return (spine_array_int)&((AtlasRegion*)self)->getPads();
 }
 
 spine_array_float spine_atlas_region_get_values(spine_atlas_region self) {
-    return (spine_array_float)&((AtlasRegion*)self)->values;
+    return (spine_array_float)&((AtlasRegion*)self)->getValues();
+}
+
+void spine_atlas_region_set_page(spine_atlas_region self, spine_atlas_page value) {
+    ((AtlasRegion*)self)->setPage((AtlasPage *)value);
+}
+
+void spine_atlas_region_set_name(spine_atlas_region self, const char* value) {
+    ((AtlasRegion*)self)->setName(String(value));
+}
+
+void spine_atlas_region_set_index(spine_atlas_region self, int value) {
+    ((AtlasRegion*)self)->setIndex(value);
+}
+
+void spine_atlas_region_set_x(spine_atlas_region self, int value) {
+    ((AtlasRegion*)self)->setX(value);
+}
+
+void spine_atlas_region_set_y(spine_atlas_region self, int value) {
+    ((AtlasRegion*)self)->setY(value);
+}
+
+void spine_atlas_region_set_splits(spine_atlas_region self, spine_array_int value) {
+    ((AtlasRegion*)self)->setSplits(*((const Array<int>*)value));
+}
+
+void spine_atlas_region_set_pads(spine_atlas_region self, spine_array_int value) {
+    ((AtlasRegion*)self)->setPads(*((const Array<int>*)value));
 }
 
 void spine_atlas_region_set_values(spine_atlas_region self, spine_array_float value) {
-    ((AtlasRegion*)self)->values = *((Array<float>*)value);
+    ((AtlasRegion*)self)->setValues(*((const Array<float>*)value));
+}
+
+float spine_atlas_region_get_u(spine_atlas_region self) {
+    return ((TextureRegion*)(AtlasRegion*)self)->getU();
+}
+
+void spine_atlas_region_set_u(spine_atlas_region self, float value) {
+    ((TextureRegion*)(AtlasRegion*)self)->setU(value);
+}
+
+float spine_atlas_region_get_v(spine_atlas_region self) {
+    return ((TextureRegion*)(AtlasRegion*)self)->getV();
+}
+
+void spine_atlas_region_set_v(spine_atlas_region self, float value) {
+    ((TextureRegion*)(AtlasRegion*)self)->setV(value);
+}
+
+float spine_atlas_region_get_u2(spine_atlas_region self) {
+    return ((TextureRegion*)(AtlasRegion*)self)->getU2();
+}
+
+void spine_atlas_region_set_u2(spine_atlas_region self, float value) {
+    ((TextureRegion*)(AtlasRegion*)self)->setU2(value);
+}
+
+float spine_atlas_region_get_v2(spine_atlas_region self) {
+    return ((TextureRegion*)(AtlasRegion*)self)->getV2();
+}
+
+void spine_atlas_region_set_v2(spine_atlas_region self, float value) {
+    ((TextureRegion*)(AtlasRegion*)self)->setV2(value);
+}
+
+int spine_atlas_region_get_degrees(spine_atlas_region self) {
+    return ((TextureRegion*)(AtlasRegion*)self)->getDegrees();
+}
+
+void spine_atlas_region_set_degrees(spine_atlas_region self, int value) {
+    ((TextureRegion*)(AtlasRegion*)self)->setDegrees(value);
+}
+
+float spine_atlas_region_get_offset_x(spine_atlas_region self) {
+    return ((TextureRegion*)(AtlasRegion*)self)->getOffsetX();
+}
+
+void spine_atlas_region_set_offset_x(spine_atlas_region self, float value) {
+    ((TextureRegion*)(AtlasRegion*)self)->setOffsetX(value);
+}
+
+float spine_atlas_region_get_offset_y(spine_atlas_region self) {
+    return ((TextureRegion*)(AtlasRegion*)self)->getOffsetY();
+}
+
+void spine_atlas_region_set_offset_y(spine_atlas_region self, float value) {
+    ((TextureRegion*)(AtlasRegion*)self)->setOffsetY(value);
+}
+
+int spine_atlas_region_get_region_width(spine_atlas_region self) {
+    return ((TextureRegion*)(AtlasRegion*)self)->getRegionWidth();
+}
+
+void spine_atlas_region_set_region_width(spine_atlas_region self, int value) {
+    ((TextureRegion*)(AtlasRegion*)self)->setRegionWidth(value);
+}
+
+int spine_atlas_region_get_region_height(spine_atlas_region self) {
+    return ((TextureRegion*)(AtlasRegion*)self)->getRegionHeight();
+}
+
+void spine_atlas_region_set_region_height(spine_atlas_region self, int value) {
+    ((TextureRegion*)(AtlasRegion*)self)->setRegionHeight(value);
+}
+
+int spine_atlas_region_get_original_width(spine_atlas_region self) {
+    return ((TextureRegion*)(AtlasRegion*)self)->getOriginalWidth();
+}
+
+void spine_atlas_region_set_original_width(spine_atlas_region self, int value) {
+    ((TextureRegion*)(AtlasRegion*)self)->setOriginalWidth(value);
+}
+
+int spine_atlas_region_get_original_height(spine_atlas_region self) {
+    return ((TextureRegion*)(AtlasRegion*)self)->getOriginalHeight();
+}
+
+void spine_atlas_region_set_original_height(spine_atlas_region self, int value) {
+    ((TextureRegion*)(AtlasRegion*)self)->setOriginalHeight(value);
 }

spine-c/src/generated/atlas_region.h

@@ -13,21 +13,42 @@ SPINE_C_API spine_atlas_region spine_atlas_region_create(void);
 SPINE_C_API void spine_atlas_region_dispose(spine_atlas_region self);
 
 SPINE_C_API spine_atlas_page spine_atlas_region_get_page(spine_atlas_region self);
-SPINE_C_API void spine_atlas_region_set_page(spine_atlas_region self, spine_atlas_page value);
-SPINE_C_API const char* spine_atlas_region_get_name(spine_atlas_region self);
-SPINE_C_API void spine_atlas_region_set_name(spine_atlas_region self, const char* value);
 SPINE_C_API int spine_atlas_region_get_index(spine_atlas_region self);
-SPINE_C_API void spine_atlas_region_set_index(spine_atlas_region self, int value);
 SPINE_C_API int spine_atlas_region_get_x(spine_atlas_region self);
-SPINE_C_API void spine_atlas_region_set_x(spine_atlas_region self, int value);
 SPINE_C_API int spine_atlas_region_get_y(spine_atlas_region self);
-SPINE_C_API void spine_atlas_region_set_y(spine_atlas_region self, int value);
 SPINE_C_API spine_array_int spine_atlas_region_get_splits(spine_atlas_region self);
-SPINE_C_API void spine_atlas_region_set_splits(spine_atlas_region self, spine_array_int value);
 SPINE_C_API spine_array_int spine_atlas_region_get_pads(spine_atlas_region self);
-SPINE_C_API void spine_atlas_region_set_pads(spine_atlas_region self, spine_array_int value);
 SPINE_C_API spine_array_float spine_atlas_region_get_values(spine_atlas_region self);
+SPINE_C_API void spine_atlas_region_set_page(spine_atlas_region self, spine_atlas_page value);
+SPINE_C_API void spine_atlas_region_set_name(spine_atlas_region self, const char* value);
+SPINE_C_API void spine_atlas_region_set_index(spine_atlas_region self, int value);
+SPINE_C_API void spine_atlas_region_set_x(spine_atlas_region self, int value);
+SPINE_C_API void spine_atlas_region_set_y(spine_atlas_region self, int value);
+SPINE_C_API void spine_atlas_region_set_splits(spine_atlas_region self, spine_array_int value);
+SPINE_C_API void spine_atlas_region_set_pads(spine_atlas_region self, spine_array_int value);
 SPINE_C_API void spine_atlas_region_set_values(spine_atlas_region self, spine_array_float value);
+SPINE_C_API float spine_atlas_region_get_u(spine_atlas_region self);
+SPINE_C_API void spine_atlas_region_set_u(spine_atlas_region self, float value);
+SPINE_C_API float spine_atlas_region_get_v(spine_atlas_region self);
+SPINE_C_API void spine_atlas_region_set_v(spine_atlas_region self, float value);
+SPINE_C_API float spine_atlas_region_get_u2(spine_atlas_region self);
+SPINE_C_API void spine_atlas_region_set_u2(spine_atlas_region self, float value);
+SPINE_C_API float spine_atlas_region_get_v2(spine_atlas_region self);
+SPINE_C_API void spine_atlas_region_set_v2(spine_atlas_region self, float value);
+SPINE_C_API int spine_atlas_region_get_degrees(spine_atlas_region self);
+SPINE_C_API void spine_atlas_region_set_degrees(spine_atlas_region self, int value);
+SPINE_C_API float spine_atlas_region_get_offset_x(spine_atlas_region self);
+SPINE_C_API void spine_atlas_region_set_offset_x(spine_atlas_region self, float value);
+SPINE_C_API float spine_atlas_region_get_offset_y(spine_atlas_region self);
+SPINE_C_API void spine_atlas_region_set_offset_y(spine_atlas_region self, float value);
+SPINE_C_API int spine_atlas_region_get_region_width(spine_atlas_region self);
+SPINE_C_API void spine_atlas_region_set_region_width(spine_atlas_region self, int value);
+SPINE_C_API int spine_atlas_region_get_region_height(spine_atlas_region self);
+SPINE_C_API void spine_atlas_region_set_region_height(spine_atlas_region self, int value);
+SPINE_C_API int spine_atlas_region_get_original_width(spine_atlas_region self);
+SPINE_C_API void spine_atlas_region_set_original_width(spine_atlas_region self, int value);
+SPINE_C_API int spine_atlas_region_get_original_height(spine_atlas_region self);
+SPINE_C_API void spine_atlas_region_set_original_height(spine_atlas_region self, int value);
 
 #ifdef __cplusplus
 }

spine-c/src/generated/bone_data.cpp

@@ -55,8 +55,8 @@ const char* spine_bone_data_get_name(spine_bone_data self) {
     return ((PosedDataGeneric<BoneLocal>*)(BoneData*)self)->getName().buffer();
 }
 
-bool spine_bone_data_is_skin_required(spine_bone_data self) {
-    return ((PosedDataGeneric<BoneLocal>*)(BoneData*)self)->isSkinRequired();
+bool spine_bone_data_get_skin_required(spine_bone_data self) {
+    return ((PosedDataGeneric<BoneLocal>*)(BoneData*)self)->getSkinRequired();
 }
 
 void spine_bone_data_set_skin_required(spine_bone_data self, bool skinRequired) {

spine-c/src/generated/bone_data.h

@@ -23,7 +23,7 @@ SPINE_C_API bool spine_bone_data_get_visible(spine_bone_data self);
 SPINE_C_API void spine_bone_data_set_visible(spine_bone_data self, bool inValue);
 SPINE_C_API spine_bone_local spine_bone_data_get_setup_pose(spine_bone_data self);
 SPINE_C_API const char* spine_bone_data_get_name(spine_bone_data self);
-SPINE_C_API bool spine_bone_data_is_skin_required(spine_bone_data self);
+SPINE_C_API bool spine_bone_data_get_skin_required(spine_bone_data self);
 SPINE_C_API void spine_bone_data_set_skin_required(spine_bone_data self, bool skinRequired);
 
 #ifdef __cplusplus

spine-c/src/generated/constraint_data.cpp

@@ -19,8 +19,8 @@ const char* spine_constraint_data_get_name(spine_constraint_data self) {
     return ((ConstraintData*)self)->getName().buffer();
 }
 
-bool spine_constraint_data_is_skin_required(spine_constraint_data self) {
-    return ((ConstraintData*)self)->isSkinRequired();
+bool spine_constraint_data_get_skin_required(spine_constraint_data self) {
+    return ((ConstraintData*)self)->getSkinRequired();
 }
 
 spine_rtti spine_constraint_data_rtti(void) {

spine-c/src/generated/constraint_data.h

@@ -13,7 +13,7 @@ SPINE_C_API void spine_constraint_data_dispose(spine_constraint_data self);
 SPINE_C_API spine_rtti spine_constraint_data_get_rtti(spine_constraint_data self);
 SPINE_C_API spine_constraint spine_constraint_data_create_method(spine_constraint_data self, spine_skeleton skeleton);
 SPINE_C_API const char* spine_constraint_data_get_name(spine_constraint_data self);
-SPINE_C_API bool spine_constraint_data_is_skin_required(spine_constraint_data self);
+SPINE_C_API bool spine_constraint_data_get_skin_required(spine_constraint_data self);
 SPINE_C_API spine_rtti spine_constraint_data_rtti(void);
 
 #ifdef __cplusplus

spine-c/src/generated/event_data.cpp

@@ -15,28 +15,28 @@ const char* spine_event_data_get_name(spine_event_data self) {
     return ((EventData*)self)->getName().buffer();
 }
 
-int spine_event_data_get_int_value(spine_event_data self) {
-    return ((EventData*)self)->getIntValue();
+int spine_event_data_get_int(spine_event_data self) {
+    return ((EventData*)self)->getInt();
 }
 
-void spine_event_data_set_int_value(spine_event_data self, int inValue) {
-    ((EventData*)self)->setIntValue(inValue);
+void spine_event_data_set_int(spine_event_data self, int inValue) {
+    ((EventData*)self)->setInt(inValue);
 }
 
-float spine_event_data_get_float_value(spine_event_data self) {
-    return ((EventData*)self)->getFloatValue();
+float spine_event_data_get_float(spine_event_data self) {
+    return ((EventData*)self)->getFloat();
 }
 
-void spine_event_data_set_float_value(spine_event_data self, float inValue) {
-    ((EventData*)self)->setFloatValue(inValue);
+void spine_event_data_set_float(spine_event_data self, float inValue) {
+    ((EventData*)self)->setFloat(inValue);
 }
 
-const char* spine_event_data_get_string_value(spine_event_data self) {
-    return ((EventData*)self)->getStringValue().buffer();
+const char* spine_event_data_get_string(spine_event_data self) {
+    return ((EventData*)self)->getString().buffer();
 }
 
-void spine_event_data_set_string_value(spine_event_data self, const char* inValue) {
-    ((EventData*)self)->setStringValue(String(inValue));
+void spine_event_data_set_string(spine_event_data self, const char* inValue) {
+    ((EventData*)self)->setString(String(inValue));
 }
 
 const char* spine_event_data_get_audio_path(spine_event_data self) {

spine-c/src/generated/event_data.h

@@ -13,12 +13,12 @@ SPINE_C_API spine_event_data spine_event_data_create(const char* name);
 SPINE_C_API void spine_event_data_dispose(spine_event_data self);
 
 SPINE_C_API const char* spine_event_data_get_name(spine_event_data self);
-SPINE_C_API int spine_event_data_get_int_value(spine_event_data self);
-SPINE_C_API void spine_event_data_set_int_value(spine_event_data self, int inValue);
-SPINE_C_API float spine_event_data_get_float_value(spine_event_data self);
-SPINE_C_API void spine_event_data_set_float_value(spine_event_data self, float inValue);
-SPINE_C_API const char* spine_event_data_get_string_value(spine_event_data self);
-SPINE_C_API void spine_event_data_set_string_value(spine_event_data self, const char* inValue);
+SPINE_C_API int spine_event_data_get_int(spine_event_data self);
+SPINE_C_API void spine_event_data_set_int(spine_event_data self, int inValue);
+SPINE_C_API float spine_event_data_get_float(spine_event_data self);
+SPINE_C_API void spine_event_data_set_float(spine_event_data self, float inValue);
+SPINE_C_API const char* spine_event_data_get_string(spine_event_data self);
+SPINE_C_API void spine_event_data_set_string(spine_event_data self, const char* inValue);
 SPINE_C_API const char* spine_event_data_get_audio_path(spine_event_data self);
 SPINE_C_API void spine_event_data_set_audio_path(spine_event_data self, const char* inValue);
 SPINE_C_API float spine_event_data_get_volume(spine_event_data self);

spine-c/src/generated/from_property.cpp

@@ -7,10 +7,18 @@ void spine_from_property_dispose(spine_from_property self) {
     delete (FromProperty*)self;
 }
 
+spine_rtti spine_from_property_get_rtti(spine_from_property self) {
+    return (spine_rtti)&((FromProperty*)self)->getRTTI();
+}
+
 float spine_from_property_value(spine_from_property self, spine_skeleton skeleton, spine_bone_pose source, bool local, float * offsets) {
     return ((FromProperty*)self)->value(*((Skeleton*)skeleton), *((BonePose*)source), local, offsets);
 }
 
+spine_rtti spine_from_property_rtti(void) {
+    return (spine_rtti)&FromProperty::rtti;
+}
+
 float spine_from_property_get__offset(spine_from_property self) {
     return ((FromProperty*)self)->_offset;
 }

spine-c/src/generated/from_property.h

@@ -10,7 +10,9 @@ extern "C" {
 
 SPINE_C_API void spine_from_property_dispose(spine_from_property self);
 
+SPINE_C_API spine_rtti spine_from_property_get_rtti(spine_from_property self);
 SPINE_C_API float spine_from_property_value(spine_from_property self, spine_skeleton skeleton, spine_bone_pose source, bool local, float * offsets);
+SPINE_C_API spine_rtti spine_from_property_rtti(void);
 SPINE_C_API float spine_from_property_get__offset(spine_from_property self);
 SPINE_C_API void spine_from_property_set__offset(spine_from_property self, float value);
 SPINE_C_API spine_array_to_property spine_from_property_get__to(spine_from_property self);

spine-c/src/generated/from_rotate.cpp

@@ -11,6 +11,14 @@ void spine_from_rotate_dispose(spine_from_rotate self) {
     delete (FromRotate*)self;
 }
 
+spine_rtti spine_from_rotate_get_rtti(spine_from_rotate self) {
+    return (spine_rtti)&((FromRotate*)self)->getRTTI();
+}
+
 float spine_from_rotate_value(spine_from_rotate self, spine_skeleton skeleton, spine_bone_pose source, bool local, float * offsets) {
     return ((FromRotate*)self)->value(*((Skeleton*)skeleton), *((BonePose*)source), local, offsets);
 }
+
+spine_rtti spine_from_rotate_rtti(void) {
+    return (spine_rtti)&FromRotate::rtti;
+}

spine-c/src/generated/from_rotate.h

@@ -12,7 +12,9 @@ SPINE_C_API spine_from_rotate spine_from_rotate_create(void);
 
 SPINE_C_API void spine_from_rotate_dispose(spine_from_rotate self);
 
+SPINE_C_API spine_rtti spine_from_rotate_get_rtti(spine_from_rotate self);
 SPINE_C_API float spine_from_rotate_value(spine_from_rotate self, spine_skeleton skeleton, spine_bone_pose source, bool local, float * offsets);
+SPINE_C_API spine_rtti spine_from_rotate_rtti(void);
 
 #ifdef __cplusplus
 }

spine-c/src/generated/from_scale_x.cpp

@@ -11,6 +11,14 @@ void spine_from_scale_x_dispose(spine_from_scale_x self) {
     delete (FromScaleX*)self;
 }
 
+spine_rtti spine_from_scale_x_get_rtti(spine_from_scale_x self) {
+    return (spine_rtti)&((FromScaleX*)self)->getRTTI();
+}
+
 float spine_from_scale_x_value(spine_from_scale_x self, spine_skeleton skeleton, spine_bone_pose source, bool local, float * offsets) {
     return ((FromScaleX*)self)->value(*((Skeleton*)skeleton), *((BonePose*)source), local, offsets);
 }
+
+spine_rtti spine_from_scale_x_rtti(void) {
+    return (spine_rtti)&FromScaleX::rtti;
+}

spine-c/src/generated/from_scale_x.h

@@ -12,7 +12,9 @@ SPINE_C_API spine_from_scale_x spine_from_scale_x_create(void);
 
 SPINE_C_API void spine_from_scale_x_dispose(spine_from_scale_x self);
 
+SPINE_C_API spine_rtti spine_from_scale_x_get_rtti(spine_from_scale_x self);
 SPINE_C_API float spine_from_scale_x_value(spine_from_scale_x self, spine_skeleton skeleton, spine_bone_pose source, bool local, float * offsets);
+SPINE_C_API spine_rtti spine_from_scale_x_rtti(void);
 
 #ifdef __cplusplus
 }

spine-c/src/generated/from_scale_y.cpp

@@ -11,6 +11,14 @@ void spine_from_scale_y_dispose(spine_from_scale_y self) {
     delete (FromScaleY*)self;
 }
 
+spine_rtti spine_from_scale_y_get_rtti(spine_from_scale_y self) {
+    return (spine_rtti)&((FromScaleY*)self)->getRTTI();
+}
+
 float spine_from_scale_y_value(spine_from_scale_y self, spine_skeleton skeleton, spine_bone_pose source, bool local, float * offsets) {
     return ((FromScaleY*)self)->value(*((Skeleton*)skeleton), *((BonePose*)source), local, offsets);
 }
+
+spine_rtti spine_from_scale_y_rtti(void) {
+    return (spine_rtti)&FromScaleY::rtti;
+}

spine-c/src/generated/from_scale_y.h

@@ -12,7 +12,9 @@ SPINE_C_API spine_from_scale_y spine_from_scale_y_create(void);
 
 SPINE_C_API void spine_from_scale_y_dispose(spine_from_scale_y self);
 
+SPINE_C_API spine_rtti spine_from_scale_y_get_rtti(spine_from_scale_y self);
 SPINE_C_API float spine_from_scale_y_value(spine_from_scale_y self, spine_skeleton skeleton, spine_bone_pose source, bool local, float * offsets);
+SPINE_C_API spine_rtti spine_from_scale_y_rtti(void);
 
 #ifdef __cplusplus
 }

spine-c/src/generated/from_shear_y.cpp

@@ -11,6 +11,14 @@ void spine_from_shear_y_dispose(spine_from_shear_y self) {
     delete (FromShearY*)self;
 }
 
+spine_rtti spine_from_shear_y_get_rtti(spine_from_shear_y self) {
+    return (spine_rtti)&((FromShearY*)self)->getRTTI();
+}
+
 float spine_from_shear_y_value(spine_from_shear_y self, spine_skeleton skeleton, spine_bone_pose source, bool local, float * offsets) {
     return ((FromShearY*)self)->value(*((Skeleton*)skeleton), *((BonePose*)source), local, offsets);
 }
+
+spine_rtti spine_from_shear_y_rtti(void) {
+    return (spine_rtti)&FromShearY::rtti;
+}

spine-c/src/generated/from_shear_y.h

@@ -12,7 +12,9 @@ SPINE_C_API spine_from_shear_y spine_from_shear_y_create(void);
 
 SPINE_C_API void spine_from_shear_y_dispose(spine_from_shear_y self);
 
+SPINE_C_API spine_rtti spine_from_shear_y_get_rtti(spine_from_shear_y self);
 SPINE_C_API float spine_from_shear_y_value(spine_from_shear_y self, spine_skeleton skeleton, spine_bone_pose source, bool local, float * offsets);
+SPINE_C_API spine_rtti spine_from_shear_y_rtti(void);
 
 #ifdef __cplusplus
 }

spine-c/src/generated/from_x.cpp

@@ -11,6 +11,14 @@ void spine_from_x_dispose(spine_from_x self) {
     delete (FromX*)self;
 }
 
+spine_rtti spine_from_x_get_rtti(spine_from_x self) {
+    return (spine_rtti)&((FromX*)self)->getRTTI();
+}
+
 float spine_from_x_value(spine_from_x self, spine_skeleton skeleton, spine_bone_pose source, bool local, float * offsets) {
     return ((FromX*)self)->value(*((Skeleton*)skeleton), *((BonePose*)source), local, offsets);
 }
+
+spine_rtti spine_from_x_rtti(void) {
+    return (spine_rtti)&FromX::rtti;
+}

spine-c/src/generated/from_x.h

@@ -12,7 +12,9 @@ SPINE_C_API spine_from_x spine_from_x_create(void);
 
 SPINE_C_API void spine_from_x_dispose(spine_from_x self);
 
+SPINE_C_API spine_rtti spine_from_x_get_rtti(spine_from_x self);
 SPINE_C_API float spine_from_x_value(spine_from_x self, spine_skeleton skeleton, spine_bone_pose source, bool local, float * offsets);
+SPINE_C_API spine_rtti spine_from_x_rtti(void);
 
 #ifdef __cplusplus
 }

spine-c/src/generated/from_y.cpp

@@ -11,6 +11,14 @@ void spine_from_y_dispose(spine_from_y self) {
     delete (FromY*)self;
 }
 
+spine_rtti spine_from_y_get_rtti(spine_from_y self) {
+    return (spine_rtti)&((FromY*)self)->getRTTI();
+}
+
 float spine_from_y_value(spine_from_y self, spine_skeleton skeleton, spine_bone_pose source, bool local, float * offsets) {
     return ((FromY*)self)->value(*((Skeleton*)skeleton), *((BonePose*)source), local, offsets);
 }
+
+spine_rtti spine_from_y_rtti(void) {
+    return (spine_rtti)&FromY::rtti;
+}

spine-c/src/generated/from_y.h

@@ -12,7 +12,9 @@ SPINE_C_API spine_from_y spine_from_y_create(void);
 
 SPINE_C_API void spine_from_y_dispose(spine_from_y self);
 
+SPINE_C_API spine_rtti spine_from_y_get_rtti(spine_from_y self);
 SPINE_C_API float spine_from_y_value(spine_from_y self, spine_skeleton skeleton, spine_bone_pose source, bool local, float * offsets);
+SPINE_C_API spine_rtti spine_from_y_rtti(void);
 
 #ifdef __cplusplus
 }

spine-c/src/generated/ik_constraint_data.cpp

@@ -43,8 +43,8 @@ const char* spine_ik_constraint_data_get_name(spine_ik_constraint_data self) {
     return ((ConstraintDataGeneric<IkConstraint, IkConstraintPose>*)(IkConstraintData*)self)->getName().buffer();
 }
 
-bool spine_ik_constraint_data_is_skin_required(spine_ik_constraint_data self) {
-    return ((ConstraintDataGeneric<IkConstraint, IkConstraintPose>*)(IkConstraintData*)self)->isSkinRequired();
+bool spine_ik_constraint_data_get_skin_required(spine_ik_constraint_data self) {
+    return ((ConstraintDataGeneric<IkConstraint, IkConstraintPose>*)(IkConstraintData*)self)->getSkinRequired();
 }
 
 spine_ik_constraint_pose spine_ik_constraint_data_get_setup_pose(spine_ik_constraint_data self) {

spine-c/src/generated/ik_constraint_data.h

@@ -20,7 +20,7 @@ SPINE_C_API void spine_ik_constraint_data_set_target(spine_ik_constraint_data se
 SPINE_C_API bool spine_ik_constraint_data_get_uniform(spine_ik_constraint_data self);
 SPINE_C_API void spine_ik_constraint_data_set_uniform(spine_ik_constraint_data self, bool uniform);
 SPINE_C_API const char* spine_ik_constraint_data_get_name(spine_ik_constraint_data self);
-SPINE_C_API bool spine_ik_constraint_data_is_skin_required(spine_ik_constraint_data self);
+SPINE_C_API bool spine_ik_constraint_data_get_skin_required(spine_ik_constraint_data self);
 SPINE_C_API spine_ik_constraint_pose spine_ik_constraint_data_get_setup_pose(spine_ik_constraint_data self);
 SPINE_C_API void spine_ik_constraint_data_set_skin_required(spine_ik_constraint_data self, bool skinRequired);
 SPINE_C_API spine_rtti spine_ik_constraint_data_rtti(void);

spine-c/src/generated/path_attachment.cpp

@@ -23,16 +23,16 @@ void spine_path_attachment_set_lengths(spine_path_attachment self, spine_array_f
     ((PathAttachment*)self)->setLengths(*((Array<float>*)inValue));
 }
 
-bool spine_path_attachment_is_closed(spine_path_attachment self) {
-    return ((PathAttachment*)self)->isClosed();
+bool spine_path_attachment_get_closed(spine_path_attachment self) {
+    return ((PathAttachment*)self)->getClosed();
 }
 
 void spine_path_attachment_set_closed(spine_path_attachment self, bool inValue) {
     ((PathAttachment*)self)->setClosed(inValue);
 }
 
-bool spine_path_attachment_is_constant_speed(spine_path_attachment self) {
-    return ((PathAttachment*)self)->isConstantSpeed();
+bool spine_path_attachment_get_constant_speed(spine_path_attachment self) {
+    return ((PathAttachment*)self)->getConstantSpeed();
 }
 
 void spine_path_attachment_set_constant_speed(spine_path_attachment self, bool inValue) {

spine-c/src/generated/path_attachment.h

@@ -15,9 +15,9 @@ SPINE_C_API void spine_path_attachment_dispose(spine_path_attachment self);
 SPINE_C_API spine_rtti spine_path_attachment_get_rtti(spine_path_attachment self);
 SPINE_C_API spine_array_float spine_path_attachment_get_lengths(spine_path_attachment self);
 SPINE_C_API void spine_path_attachment_set_lengths(spine_path_attachment self, spine_array_float inValue);
-SPINE_C_API bool spine_path_attachment_is_closed(spine_path_attachment self);
+SPINE_C_API bool spine_path_attachment_get_closed(spine_path_attachment self);
 SPINE_C_API void spine_path_attachment_set_closed(spine_path_attachment self, bool inValue);
-SPINE_C_API bool spine_path_attachment_is_constant_speed(spine_path_attachment self);
+SPINE_C_API bool spine_path_attachment_get_constant_speed(spine_path_attachment self);
 SPINE_C_API void spine_path_attachment_set_constant_speed(spine_path_attachment self, bool inValue);
 SPINE_C_API spine_color spine_path_attachment_get_color(spine_path_attachment self);
 SPINE_C_API spine_attachment spine_path_attachment_copy(spine_path_attachment self);

spine-c/src/generated/path_constraint_data.cpp

@@ -67,8 +67,8 @@ const char* spine_path_constraint_data_get_name(spine_path_constraint_data self)
     return ((ConstraintDataGeneric<PathConstraint, PathConstraintPose>*)(PathConstraintData*)self)->getName().buffer();
 }
 
-bool spine_path_constraint_data_is_skin_required(spine_path_constraint_data self) {
-    return ((ConstraintDataGeneric<PathConstraint, PathConstraintPose>*)(PathConstraintData*)self)->isSkinRequired();
+bool spine_path_constraint_data_get_skin_required(spine_path_constraint_data self) {
+    return ((ConstraintDataGeneric<PathConstraint, PathConstraintPose>*)(PathConstraintData*)self)->getSkinRequired();
 }
 
 spine_path_constraint_pose spine_path_constraint_data_get_setup_pose(spine_path_constraint_data self) {

spine-c/src/generated/path_constraint_data.h

@@ -26,7 +26,7 @@ SPINE_C_API void spine_path_constraint_data_set_rotate_mode(spine_path_constrain
 SPINE_C_API float spine_path_constraint_data_get_offset_rotation(spine_path_constraint_data self);
 SPINE_C_API void spine_path_constraint_data_set_offset_rotation(spine_path_constraint_data self, float offsetRotation);
 SPINE_C_API const char* spine_path_constraint_data_get_name(spine_path_constraint_data self);
-SPINE_C_API bool spine_path_constraint_data_is_skin_required(spine_path_constraint_data self);
+SPINE_C_API bool spine_path_constraint_data_get_skin_required(spine_path_constraint_data self);
 SPINE_C_API spine_path_constraint_pose spine_path_constraint_data_get_setup_pose(spine_path_constraint_data self);
 SPINE_C_API void spine_path_constraint_data_set_skin_required(spine_path_constraint_data self, bool skinRequired);
 SPINE_C_API spine_rtti spine_path_constraint_data_rtti(void);

spine-c/src/generated/physics_constraint.cpp

@@ -51,8 +51,8 @@ void spine_physics_constraint_set_bone(spine_physics_constraint self, spine_bone
     ((PhysicsConstraint*)self)->setBone(*((BonePose*)bone));
 }
 
-spine_constraint_data spine_physics_constraint_get_data(spine_physics_constraint self) {
-    return (spine_constraint_data)&((ConstraintGeneric<PhysicsConstraint, PhysicsConstraintData, PhysicsConstraintPose>*)(PhysicsConstraint*)self)->getData();
+spine_physics_constraint_data spine_physics_constraint_get_data(spine_physics_constraint self) {
+    return (spine_physics_constraint_data)&((ConstraintGeneric<PhysicsConstraint, PhysicsConstraintData, PhysicsConstraintPose>*)(PhysicsConstraint*)self)->getData();
 }
 
 spine_physics_constraint_pose spine_physics_constraint_get_pose(spine_physics_constraint self) {

spine-c/src/generated/physics_constraint.h

@@ -22,7 +22,7 @@ SPINE_C_API void spine_physics_constraint_translate(spine_physics_constraint sel
 SPINE_C_API void spine_physics_constraint_rotate(spine_physics_constraint self, float x, float y, float degrees);
 SPINE_C_API spine_bone_pose spine_physics_constraint_get_bone(spine_physics_constraint self);
 SPINE_C_API void spine_physics_constraint_set_bone(spine_physics_constraint self, spine_bone_pose bone);
-SPINE_C_API spine_constraint_data spine_physics_constraint_get_data(spine_physics_constraint self);
+SPINE_C_API spine_physics_constraint_data spine_physics_constraint_get_data(spine_physics_constraint self);
 SPINE_C_API spine_physics_constraint_pose spine_physics_constraint_get_pose(spine_physics_constraint self);
 SPINE_C_API spine_physics_constraint_pose spine_physics_constraint_get_applied_pose(spine_physics_constraint self);
 SPINE_C_API void spine_physics_constraint_reset_constrained(spine_physics_constraint self);

spine-c/src/generated/physics_constraint_data.cpp

@@ -143,8 +143,8 @@ const char* spine_physics_constraint_data_get_name(spine_physics_constraint_data
     return ((ConstraintDataGeneric<PhysicsConstraint, PhysicsConstraintPose>*)(PhysicsConstraintData*)self)->getName().buffer();
 }
 
-bool spine_physics_constraint_data_is_skin_required(spine_physics_constraint_data self) {
-    return ((ConstraintDataGeneric<PhysicsConstraint, PhysicsConstraintPose>*)(PhysicsConstraintData*)self)->isSkinRequired();
+bool spine_physics_constraint_data_get_skin_required(spine_physics_constraint_data self) {
+    return ((ConstraintDataGeneric<PhysicsConstraint, PhysicsConstraintPose>*)(PhysicsConstraintData*)self)->getSkinRequired();
 }
 
 spine_physics_constraint_pose spine_physics_constraint_data_get_setup_pose(spine_physics_constraint_data self) {

spine-c/src/generated/physics_constraint_data.h

@@ -45,7 +45,7 @@ SPINE_C_API void spine_physics_constraint_data_set_gravity_global(spine_physics_
 SPINE_C_API bool spine_physics_constraint_data_get_mix_global(spine_physics_constraint_data self);
 SPINE_C_API void spine_physics_constraint_data_set_mix_global(spine_physics_constraint_data self, bool mixGlobal);
 SPINE_C_API const char* spine_physics_constraint_data_get_name(spine_physics_constraint_data self);
-SPINE_C_API bool spine_physics_constraint_data_is_skin_required(spine_physics_constraint_data self);
+SPINE_C_API bool spine_physics_constraint_data_get_skin_required(spine_physics_constraint_data self);
 SPINE_C_API spine_physics_constraint_pose spine_physics_constraint_data_get_setup_pose(spine_physics_constraint_data self);
 SPINE_C_API void spine_physics_constraint_data_set_skin_required(spine_physics_constraint_data self, bool skinRequired);
 SPINE_C_API spine_rtti spine_physics_constraint_data_rtti(void);

spine-c/src/generated/posed_data.cpp

@@ -15,8 +15,8 @@ const char* spine_posed_data_get_name(spine_posed_data self) {
     return ((PosedData*)self)->getName().buffer();
 }
 
-bool spine_posed_data_is_skin_required(spine_posed_data self) {
-    return ((PosedData*)self)->isSkinRequired();
+bool spine_posed_data_get_skin_required(spine_posed_data self) {
+    return ((PosedData*)self)->getSkinRequired();
 }
 
 void spine_posed_data_set_skin_required(spine_posed_data self, bool skinRequired) {

spine-c/src/generated/posed_data.h

@@ -13,7 +13,7 @@ SPINE_C_API spine_posed_data spine_posed_data_create(const char* name);
 SPINE_C_API void spine_posed_data_dispose(spine_posed_data self);
 
 SPINE_C_API const char* spine_posed_data_get_name(spine_posed_data self);
-SPINE_C_API bool spine_posed_data_is_skin_required(spine_posed_data self);
+SPINE_C_API bool spine_posed_data_get_skin_required(spine_posed_data self);
 SPINE_C_API void spine_posed_data_set_skin_required(spine_posed_data self, bool skinRequired);
 
 #ifdef __cplusplus

spine-c/src/generated/slider.cpp

@@ -39,8 +39,8 @@ void spine_slider_set_bone(spine_slider self, spine_bone bone) {
     ((Slider*)self)->setBone((Bone *)bone);
 }
 
-spine_constraint_data spine_slider_get_data(spine_slider self) {
-    return (spine_constraint_data)&((ConstraintGeneric<Slider, SliderData, SliderPose>*)(Slider*)self)->getData();
+spine_slider_data spine_slider_get_data(spine_slider self) {
+    return (spine_slider_data)&((ConstraintGeneric<Slider, SliderData, SliderPose>*)(Slider*)self)->getData();
 }
 
 spine_slider_pose spine_slider_get_pose(spine_slider self) {

spine-c/src/generated/slider.h

@@ -19,7 +19,7 @@ SPINE_C_API void spine_slider_sort(spine_slider self, spine_skeleton skeleton);
 SPINE_C_API bool spine_slider_is_source_active(spine_slider self);
 SPINE_C_API spine_bone spine_slider_get_bone(spine_slider self);
 SPINE_C_API void spine_slider_set_bone(spine_slider self, spine_bone bone);
-SPINE_C_API spine_constraint_data spine_slider_get_data(spine_slider self);
+SPINE_C_API spine_slider_data spine_slider_get_data(spine_slider self);
 SPINE_C_API spine_slider_pose spine_slider_get_pose(spine_slider self);
 SPINE_C_API spine_slider_pose spine_slider_get_applied_pose(spine_slider self);
 SPINE_C_API void spine_slider_reset_constrained(spine_slider self);

spine-c/src/generated/slider_data.cpp

@@ -87,8 +87,8 @@ const char* spine_slider_data_get_name(spine_slider_data self) {
     return ((ConstraintDataGeneric<Slider, SliderPose>*)(SliderData*)self)->getName().buffer();
 }
 
-bool spine_slider_data_is_skin_required(spine_slider_data self) {
-    return ((ConstraintDataGeneric<Slider, SliderPose>*)(SliderData*)self)->isSkinRequired();
+bool spine_slider_data_get_skin_required(spine_slider_data self) {
+    return ((ConstraintDataGeneric<Slider, SliderPose>*)(SliderData*)self)->getSkinRequired();
 }
 
 spine_slider_pose spine_slider_data_get_setup_pose(spine_slider_data self) {

spine-c/src/generated/slider_data.h

@@ -31,7 +31,7 @@ SPINE_C_API void spine_slider_data_set_offset(spine_slider_data self, float offs
 SPINE_C_API bool spine_slider_data_get_local(spine_slider_data self);
 SPINE_C_API void spine_slider_data_set_local(spine_slider_data self, bool local);
 SPINE_C_API const char* spine_slider_data_get_name(spine_slider_data self);
-SPINE_C_API bool spine_slider_data_is_skin_required(spine_slider_data self);
+SPINE_C_API bool spine_slider_data_get_skin_required(spine_slider_data self);
 SPINE_C_API spine_slider_pose spine_slider_data_get_setup_pose(spine_slider_data self);
 SPINE_C_API void spine_slider_data_set_skin_required(spine_slider_data self, bool skinRequired);
 SPINE_C_API spine_rtti spine_slider_data_rtti(void);

spine-c/src/generated/slot_data.cpp

@@ -51,8 +51,8 @@ const char* spine_slot_data_get_name(spine_slot_data self) {
     return ((PosedDataGeneric<SlotPose>*)(SlotData*)self)->getName().buffer();
 }
 
-bool spine_slot_data_is_skin_required(spine_slot_data self) {
-    return ((PosedDataGeneric<SlotPose>*)(SlotData*)self)->isSkinRequired();
+bool spine_slot_data_get_skin_required(spine_slot_data self) {
+    return ((PosedDataGeneric<SlotPose>*)(SlotData*)self)->getSkinRequired();
 }
 
 void spine_slot_data_set_skin_required(spine_slot_data self, bool skinRequired) {

spine-c/src/generated/slot_data.h

@@ -22,7 +22,7 @@ SPINE_C_API bool spine_slot_data_get_visible(spine_slot_data self);
 SPINE_C_API void spine_slot_data_set_visible(spine_slot_data self, bool visible);
 SPINE_C_API spine_slot_pose spine_slot_data_get_setup_pose(spine_slot_data self);
 SPINE_C_API const char* spine_slot_data_get_name(spine_slot_data self);
-SPINE_C_API bool spine_slot_data_is_skin_required(spine_slot_data self);
+SPINE_C_API bool spine_slot_data_get_skin_required(spine_slot_data self);
 SPINE_C_API void spine_slot_data_set_skin_required(spine_slot_data self, bool skinRequired);
 
 #ifdef __cplusplus

spine-c/src/generated/texture_region.cpp

@@ -11,98 +11,90 @@ void spine_texture_region_dispose(spine_texture_region self) {
     delete (TextureRegion*)self;
 }
 
-void * spine_texture_region_get_renderer_object(spine_texture_region self) {
-    return ((TextureRegion*)self)->rendererObject;
-}
-
-void spine_texture_region_set_renderer_object(spine_texture_region self, void * value) {
-    ((TextureRegion*)self)->rendererObject = (void*)value;
-}
-
 float spine_texture_region_get_u(spine_texture_region self) {
-    return ((TextureRegion*)self)->u;
+    return ((TextureRegion*)self)->getU();
 }
 
 void spine_texture_region_set_u(spine_texture_region self, float value) {
-    ((TextureRegion*)self)->u = value;
+    ((TextureRegion*)self)->setU(value);
 }
 
 float spine_texture_region_get_v(spine_texture_region self) {
-    return ((TextureRegion*)self)->v;
+    return ((TextureRegion*)self)->getV();
 }
 
 void spine_texture_region_set_v(spine_texture_region self, float value) {
-    ((TextureRegion*)self)->v = value;
+    ((TextureRegion*)self)->setV(value);
 }
 
 float spine_texture_region_get_u2(spine_texture_region self) {
-    return ((TextureRegion*)self)->u2;
+    return ((TextureRegion*)self)->getU2();
 }
 
 void spine_texture_region_set_u2(spine_texture_region self, float value) {
-    ((TextureRegion*)self)->u2 = value;
+    ((TextureRegion*)self)->setU2(value);
 }
 
 float spine_texture_region_get_v2(spine_texture_region self) {
-    return ((TextureRegion*)self)->v2;
+    return ((TextureRegion*)self)->getV2();
 }
 
 void spine_texture_region_set_v2(spine_texture_region self, float value) {
-    ((TextureRegion*)self)->v2 = value;
+    ((TextureRegion*)self)->setV2(value);
 }
 
 int spine_texture_region_get_degrees(spine_texture_region self) {
-    return ((TextureRegion*)self)->degrees;
+    return ((TextureRegion*)self)->getDegrees();
 }
 
 void spine_texture_region_set_degrees(spine_texture_region self, int value) {
-    ((TextureRegion*)self)->degrees = value;
+    ((TextureRegion*)self)->setDegrees(value);
 }
 
 float spine_texture_region_get_offset_x(spine_texture_region self) {
-    return ((TextureRegion*)self)->offsetX;
+    return ((TextureRegion*)self)->getOffsetX();
 }
 
 void spine_texture_region_set_offset_x(spine_texture_region self, float value) {
-    ((TextureRegion*)self)->offsetX = value;
+    ((TextureRegion*)self)->setOffsetX(value);
 }
 
 float spine_texture_region_get_offset_y(spine_texture_region self) {
-    return ((TextureRegion*)self)->offsetY;
+    return ((TextureRegion*)self)->getOffsetY();
 }
 
 void spine_texture_region_set_offset_y(spine_texture_region self, float value) {
-    ((TextureRegion*)self)->offsetY = value;
+    ((TextureRegion*)self)->setOffsetY(value);
 }
 
-int spine_texture_region_get_width(spine_texture_region self) {
-    return ((TextureRegion*)self)->width;
+int spine_texture_region_get_region_width(spine_texture_region self) {
+    return ((TextureRegion*)self)->getRegionWidth();
 }
 
-void spine_texture_region_set_width(spine_texture_region self, int value) {
-    ((TextureRegion*)self)->width = value;
+void spine_texture_region_set_region_width(spine_texture_region self, int value) {
+    ((TextureRegion*)self)->setRegionWidth(value);
 }
 
-int spine_texture_region_get_height(spine_texture_region self) {
-    return ((TextureRegion*)self)->height;
+int spine_texture_region_get_region_height(spine_texture_region self) {
+    return ((TextureRegion*)self)->getRegionHeight();
 }
 
-void spine_texture_region_set_height(spine_texture_region self, int value) {
-    ((TextureRegion*)self)->height = value;
+void spine_texture_region_set_region_height(spine_texture_region self, int value) {
+    ((TextureRegion*)self)->setRegionHeight(value);
 }
 
 int spine_texture_region_get_original_width(spine_texture_region self) {
-    return ((TextureRegion*)self)->originalWidth;
+    return ((TextureRegion*)self)->getOriginalWidth();
 }
 
 void spine_texture_region_set_original_width(spine_texture_region self, int value) {
-    ((TextureRegion*)self)->originalWidth = value;
+    ((TextureRegion*)self)->setOriginalWidth(value);
 }
 
 int spine_texture_region_get_original_height(spine_texture_region self) {
-    return ((TextureRegion*)self)->originalHeight;
+    return ((TextureRegion*)self)->getOriginalHeight();
 }
 
 void spine_texture_region_set_original_height(spine_texture_region self, int value) {
-    ((TextureRegion*)self)->originalHeight = value;
+    ((TextureRegion*)self)->setOriginalHeight(value);
 }

spine-c/src/generated/texture_region.h

@@ -12,8 +12,6 @@ SPINE_C_API spine_texture_region spine_texture_region_create(void);
 
 SPINE_C_API void spine_texture_region_dispose(spine_texture_region self);
 
-SPINE_C_API void * spine_texture_region_get_renderer_object(spine_texture_region self);
-SPINE_C_API void spine_texture_region_set_renderer_object(spine_texture_region self, void * value);
 SPINE_C_API float spine_texture_region_get_u(spine_texture_region self);
 SPINE_C_API void spine_texture_region_set_u(spine_texture_region self, float value);
 SPINE_C_API float spine_texture_region_get_v(spine_texture_region self);
@@ -28,10 +26,10 @@ SPINE_C_API float spine_texture_region_get_offset_x(spine_texture_region self);
 SPINE_C_API void spine_texture_region_set_offset_x(spine_texture_region self, float value);
 SPINE_C_API float spine_texture_region_get_offset_y(spine_texture_region self);
 SPINE_C_API void spine_texture_region_set_offset_y(spine_texture_region self, float value);
-SPINE_C_API int spine_texture_region_get_width(spine_texture_region self);
-SPINE_C_API void spine_texture_region_set_width(spine_texture_region self, int value);
-SPINE_C_API int spine_texture_region_get_height(spine_texture_region self);
-SPINE_C_API void spine_texture_region_set_height(spine_texture_region self, int value);
+SPINE_C_API int spine_texture_region_get_region_width(spine_texture_region self);
+SPINE_C_API void spine_texture_region_set_region_width(spine_texture_region self, int value);
+SPINE_C_API int spine_texture_region_get_region_height(spine_texture_region self);
+SPINE_C_API void spine_texture_region_set_region_height(spine_texture_region self, int value);
 SPINE_C_API int spine_texture_region_get_original_width(spine_texture_region self);
 SPINE_C_API void spine_texture_region_set_original_width(spine_texture_region self, int value);
 SPINE_C_API int spine_texture_region_get_original_height(spine_texture_region self);

spine-c/src/generated/to_property.cpp

@@ -7,6 +7,10 @@ void spine_to_property_dispose(spine_to_property self) {
     delete (ToProperty*)self;
 }
 
+spine_rtti spine_to_property_get_rtti(spine_to_property self) {
+    return (spine_rtti)&((ToProperty*)self)->getRTTI();
+}
+
 float spine_to_property_mix(spine_to_property self, spine_transform_constraint_pose pose) {
     return ((ToProperty*)self)->mix(*((TransformConstraintPose*)pose));
 }
@@ -15,6 +19,10 @@ void spine_to_property_apply(spine_to_property self, spine_skeleton skeleton, sp
     ((ToProperty*)self)->apply(*((Skeleton*)skeleton), *((TransformConstraintPose*)pose), *((BonePose*)bone), value, local, additive);
 }
 
+spine_rtti spine_to_property_rtti(void) {
+    return (spine_rtti)&ToProperty::rtti;
+}
+
 float spine_to_property_get__offset(spine_to_property self) {
     return ((ToProperty*)self)->_offset;
 }

spine-c/src/generated/to_property.h

@@ -10,8 +10,10 @@ extern "C" {
 
 SPINE_C_API void spine_to_property_dispose(spine_to_property self);
 
+SPINE_C_API spine_rtti spine_to_property_get_rtti(spine_to_property self);
 SPINE_C_API float spine_to_property_mix(spine_to_property self, spine_transform_constraint_pose pose);
 SPINE_C_API void spine_to_property_apply(spine_to_property self, spine_skeleton skeleton, spine_transform_constraint_pose pose, spine_bone_pose bone, float value, bool local, bool additive);
+SPINE_C_API spine_rtti spine_to_property_rtti(void);
 SPINE_C_API float spine_to_property_get__offset(spine_to_property self);
 SPINE_C_API void spine_to_property_set__offset(spine_to_property self, float value);
 SPINE_C_API float spine_to_property_get__max(spine_to_property self);

spine-c/src/generated/to_rotate.cpp

@@ -11,6 +11,10 @@ void spine_to_rotate_dispose(spine_to_rotate self) {
     delete (ToRotate*)self;
 }
 
+spine_rtti spine_to_rotate_get_rtti(spine_to_rotate self) {
+    return (spine_rtti)&((ToRotate*)self)->getRTTI();
+}
+
 float spine_to_rotate_mix(spine_to_rotate self, spine_transform_constraint_pose pose) {
     return ((ToRotate*)self)->mix(*((TransformConstraintPose*)pose));
 }
@@ -18,3 +22,7 @@ float spine_to_rotate_mix(spine_to_rotate self, spine_transform_constraint_pose
 void spine_to_rotate_apply(spine_to_rotate self, spine_skeleton skeleton, spine_transform_constraint_pose pose, spine_bone_pose bone, float value, bool local, bool additive) {
     ((ToRotate*)self)->apply(*((Skeleton*)skeleton), *((TransformConstraintPose*)pose), *((BonePose*)bone), value, local, additive);
 }
+
+spine_rtti spine_to_rotate_rtti(void) {
+    return (spine_rtti)&ToRotate::rtti;
+}

spine-c/src/generated/to_rotate.h

@@ -12,8 +12,10 @@ SPINE_C_API spine_to_rotate spine_to_rotate_create(void);
 
 SPINE_C_API void spine_to_rotate_dispose(spine_to_rotate self);
 
+SPINE_C_API spine_rtti spine_to_rotate_get_rtti(spine_to_rotate self);
 SPINE_C_API float spine_to_rotate_mix(spine_to_rotate self, spine_transform_constraint_pose pose);
 SPINE_C_API void spine_to_rotate_apply(spine_to_rotate self, spine_skeleton skeleton, spine_transform_constraint_pose pose, spine_bone_pose bone, float value, bool local, bool additive);
+SPINE_C_API spine_rtti spine_to_rotate_rtti(void);
 
 #ifdef __cplusplus
 }

spine-c/src/generated/to_scale_x.cpp

@@ -11,6 +11,10 @@ void spine_to_scale_x_dispose(spine_to_scale_x self) {
     delete (ToScaleX*)self;
 }
 
+spine_rtti spine_to_scale_x_get_rtti(spine_to_scale_x self) {
+    return (spine_rtti)&((ToScaleX*)self)->getRTTI();
+}
+
 float spine_to_scale_x_mix(spine_to_scale_x self, spine_transform_constraint_pose pose) {
     return ((ToScaleX*)self)->mix(*((TransformConstraintPose*)pose));
 }
@@ -18,3 +22,7 @@ float spine_to_scale_x_mix(spine_to_scale_x self, spine_transform_constraint_pos
 void spine_to_scale_x_apply(spine_to_scale_x self, spine_skeleton skeleton, spine_transform_constraint_pose pose, spine_bone_pose bone, float value, bool local, bool additive) {
     ((ToScaleX*)self)->apply(*((Skeleton*)skeleton), *((TransformConstraintPose*)pose), *((BonePose*)bone), value, local, additive);
 }
+
+spine_rtti spine_to_scale_x_rtti(void) {
+    return (spine_rtti)&ToScaleX::rtti;
+}

spine-c/src/generated/to_scale_x.h

@@ -12,8 +12,10 @@ SPINE_C_API spine_to_scale_x spine_to_scale_x_create(void);
 
 SPINE_C_API void spine_to_scale_x_dispose(spine_to_scale_x self);
 
+SPINE_C_API spine_rtti spine_to_scale_x_get_rtti(spine_to_scale_x self);
 SPINE_C_API float spine_to_scale_x_mix(spine_to_scale_x self, spine_transform_constraint_pose pose);
 SPINE_C_API void spine_to_scale_x_apply(spine_to_scale_x self, spine_skeleton skeleton, spine_transform_constraint_pose pose, spine_bone_pose bone, float value, bool local, bool additive);
+SPINE_C_API spine_rtti spine_to_scale_x_rtti(void);
 
 #ifdef __cplusplus
 }

spine-c/src/generated/to_scale_y.cpp

@@ -11,6 +11,10 @@ void spine_to_scale_y_dispose(spine_to_scale_y self) {
     delete (ToScaleY*)self;
 }
 
+spine_rtti spine_to_scale_y_get_rtti(spine_to_scale_y self) {
+    return (spine_rtti)&((ToScaleY*)self)->getRTTI();
+}
+
 float spine_to_scale_y_mix(spine_to_scale_y self, spine_transform_constraint_pose pose) {
     return ((ToScaleY*)self)->mix(*((TransformConstraintPose*)pose));
 }
@@ -18,3 +22,7 @@ float spine_to_scale_y_mix(spine_to_scale_y self, spine_transform_constraint_pos
 void spine_to_scale_y_apply(spine_to_scale_y self, spine_skeleton skeleton, spine_transform_constraint_pose pose, spine_bone_pose bone, float value, bool local, bool additive) {
     ((ToScaleY*)self)->apply(*((Skeleton*)skeleton), *((TransformConstraintPose*)pose), *((BonePose*)bone), value, local, additive);
 }
+
+spine_rtti spine_to_scale_y_rtti(void) {
+    return (spine_rtti)&ToScaleY::rtti;
+}

spine-c/src/generated/to_scale_y.h

@@ -12,8 +12,10 @@ SPINE_C_API spine_to_scale_y spine_to_scale_y_create(void);
 
 SPINE_C_API void spine_to_scale_y_dispose(spine_to_scale_y self);
 
+SPINE_C_API spine_rtti spine_to_scale_y_get_rtti(spine_to_scale_y self);
 SPINE_C_API float spine_to_scale_y_mix(spine_to_scale_y self, spine_transform_constraint_pose pose);
 SPINE_C_API void spine_to_scale_y_apply(spine_to_scale_y self, spine_skeleton skeleton, spine_transform_constraint_pose pose, spine_bone_pose bone, float value, bool local, bool additive);
+SPINE_C_API spine_rtti spine_to_scale_y_rtti(void);
 
 #ifdef __cplusplus
 }

spine-c/src/generated/to_shear_y.cpp

@@ -11,6 +11,10 @@ void spine_to_shear_y_dispose(spine_to_shear_y self) {
     delete (ToShearY*)self;
 }
 
+spine_rtti spine_to_shear_y_get_rtti(spine_to_shear_y self) {
+    return (spine_rtti)&((ToShearY*)self)->getRTTI();
+}
+
 float spine_to_shear_y_mix(spine_to_shear_y self, spine_transform_constraint_pose pose) {
     return ((ToShearY*)self)->mix(*((TransformConstraintPose*)pose));
 }
@@ -18,3 +22,7 @@ float spine_to_shear_y_mix(spine_to_shear_y self, spine_transform_constraint_pos
 void spine_to_shear_y_apply(spine_to_shear_y self, spine_skeleton skeleton, spine_transform_constraint_pose pose, spine_bone_pose bone, float value, bool local, bool additive) {
     ((ToShearY*)self)->apply(*((Skeleton*)skeleton), *((TransformConstraintPose*)pose), *((BonePose*)bone), value, local, additive);
 }
+
+spine_rtti spine_to_shear_y_rtti(void) {
+    return (spine_rtti)&ToShearY::rtti;
+}

spine-c/src/generated/to_shear_y.h

@@ -12,8 +12,10 @@ SPINE_C_API spine_to_shear_y spine_to_shear_y_create(void);
 
 SPINE_C_API void spine_to_shear_y_dispose(spine_to_shear_y self);
 
+SPINE_C_API spine_rtti spine_to_shear_y_get_rtti(spine_to_shear_y self);
 SPINE_C_API float spine_to_shear_y_mix(spine_to_shear_y self, spine_transform_constraint_pose pose);
 SPINE_C_API void spine_to_shear_y_apply(spine_to_shear_y self, spine_skeleton skeleton, spine_transform_constraint_pose pose, spine_bone_pose bone, float value, bool local, bool additive);
+SPINE_C_API spine_rtti spine_to_shear_y_rtti(void);
 
 #ifdef __cplusplus
 }

spine-c/src/generated/to_x.cpp

@@ -11,6 +11,10 @@ void spine_to_x_dispose(spine_to_x self) {
     delete (ToX*)self;
 }
 
+spine_rtti spine_to_x_get_rtti(spine_to_x self) {
+    return (spine_rtti)&((ToX*)self)->getRTTI();
+}
+
 float spine_to_x_mix(spine_to_x self, spine_transform_constraint_pose pose) {
     return ((ToX*)self)->mix(*((TransformConstraintPose*)pose));
 }
@@ -18,3 +22,7 @@ float spine_to_x_mix(spine_to_x self, spine_transform_constraint_pose pose) {
 void spine_to_x_apply(spine_to_x self, spine_skeleton skeleton, spine_transform_constraint_pose pose, spine_bone_pose bone, float value, bool local, bool additive) {
     ((ToX*)self)->apply(*((Skeleton*)skeleton), *((TransformConstraintPose*)pose), *((BonePose*)bone), value, local, additive);
 }
+
+spine_rtti spine_to_x_rtti(void) {
+    return (spine_rtti)&ToX::rtti;
+}

spine-c/src/generated/to_x.h

@@ -12,8 +12,10 @@ SPINE_C_API spine_to_x spine_to_x_create(void);
 
 SPINE_C_API void spine_to_x_dispose(spine_to_x self);
 
+SPINE_C_API spine_rtti spine_to_x_get_rtti(spine_to_x self);
 SPINE_C_API float spine_to_x_mix(spine_to_x self, spine_transform_constraint_pose pose);
 SPINE_C_API void spine_to_x_apply(spine_to_x self, spine_skeleton skeleton, spine_transform_constraint_pose pose, spine_bone_pose bone, float value, bool local, bool additive);
+SPINE_C_API spine_rtti spine_to_x_rtti(void);
 
 #ifdef __cplusplus
 }

spine-c/src/generated/to_y.cpp

@@ -11,6 +11,10 @@ void spine_to_y_dispose(spine_to_y self) {
     delete (ToY*)self;
 }
 
+spine_rtti spine_to_y_get_rtti(spine_to_y self) {
+    return (spine_rtti)&((ToY*)self)->getRTTI();
+}
+
 float spine_to_y_mix(spine_to_y self, spine_transform_constraint_pose pose) {
     return ((ToY*)self)->mix(*((TransformConstraintPose*)pose));
 }
@@ -18,3 +22,7 @@ float spine_to_y_mix(spine_to_y self, spine_transform_constraint_pose pose) {
 void spine_to_y_apply(spine_to_y self, spine_skeleton skeleton, spine_transform_constraint_pose pose, spine_bone_pose bone, float value, bool local, bool additive) {
     ((ToY*)self)->apply(*((Skeleton*)skeleton), *((TransformConstraintPose*)pose), *((BonePose*)bone), value, local, additive);
 }
+
+spine_rtti spine_to_y_rtti(void) {
+    return (spine_rtti)&ToY::rtti;
+}

spine-c/src/generated/to_y.h

@@ -12,8 +12,10 @@ SPINE_C_API spine_to_y spine_to_y_create(void);
 
 SPINE_C_API void spine_to_y_dispose(spine_to_y self);
 
+SPINE_C_API spine_rtti spine_to_y_get_rtti(spine_to_y self);
 SPINE_C_API float spine_to_y_mix(spine_to_y self, spine_transform_constraint_pose pose);
 SPINE_C_API void spine_to_y_apply(spine_to_y self, spine_skeleton skeleton, spine_transform_constraint_pose pose, spine_bone_pose bone, float value, bool local, bool additive);
+SPINE_C_API spine_rtti spine_to_y_rtti(void);
 
 #ifdef __cplusplus
 }

spine-c/src/generated/transform_constraint.cpp

@@ -43,8 +43,8 @@ void spine_transform_constraint_set_source(spine_transform_constraint self, spin
     ((TransformConstraint*)self)->setSource((Bone *)source);
 }
 
-spine_constraint_data spine_transform_constraint_get_data(spine_transform_constraint self) {
-    return (spine_constraint_data)&((ConstraintGeneric<TransformConstraint, TransformConstraintData, TransformConstraintPose>*)(TransformConstraint*)self)->getData();
+spine_transform_constraint_data spine_transform_constraint_get_data(spine_transform_constraint self) {
+    return (spine_transform_constraint_data)&((ConstraintGeneric<TransformConstraint, TransformConstraintData, TransformConstraintPose>*)(TransformConstraint*)self)->getData();
 }
 
 spine_transform_constraint_pose spine_transform_constraint_get_pose(spine_transform_constraint self) {

spine-c/src/generated/transform_constraint.h

@@ -20,7 +20,7 @@ SPINE_C_API bool spine_transform_constraint_is_source_active(spine_transform_con
 SPINE_C_API spine_array_bone_pose spine_transform_constraint_get_bones(spine_transform_constraint self);
 SPINE_C_API spine_bone spine_transform_constraint_get_source(spine_transform_constraint self);
 SPINE_C_API void spine_transform_constraint_set_source(spine_transform_constraint self, spine_bone source);
-SPINE_C_API spine_constraint_data spine_transform_constraint_get_data(spine_transform_constraint self);
+SPINE_C_API spine_transform_constraint_data spine_transform_constraint_get_data(spine_transform_constraint self);
 SPINE_C_API spine_transform_constraint_pose spine_transform_constraint_get_pose(spine_transform_constraint self);
 SPINE_C_API spine_transform_constraint_pose spine_transform_constraint_get_applied_pose(spine_transform_constraint self);
 SPINE_C_API void spine_transform_constraint_reset_constrained(spine_transform_constraint self);

spine-c/src/generated/transform_constraint_data.cpp

@@ -119,8 +119,8 @@ const char* spine_transform_constraint_data_get_name(spine_transform_constraint_
     return ((ConstraintDataGeneric<TransformConstraint, TransformConstraintPose>*)(TransformConstraintData*)self)->getName().buffer();
 }
 
-bool spine_transform_constraint_data_is_skin_required(spine_transform_constraint_data self) {
-    return ((ConstraintDataGeneric<TransformConstraint, TransformConstraintPose>*)(TransformConstraintData*)self)->isSkinRequired();
+bool spine_transform_constraint_data_get_skin_required(spine_transform_constraint_data self) {
+    return ((ConstraintDataGeneric<TransformConstraint, TransformConstraintPose>*)(TransformConstraintData*)self)->getSkinRequired();
 }
 
 spine_transform_constraint_pose spine_transform_constraint_data_get_setup_pose(spine_transform_constraint_data self) {

spine-c/src/generated/transform_constraint_data.h

@@ -39,7 +39,7 @@ SPINE_C_API bool spine_transform_constraint_data_get_clamp(spine_transform_const
 SPINE_C_API void spine_transform_constraint_data_set_clamp(spine_transform_constraint_data self, bool clamp);
 SPINE_C_API spine_array_from_property spine_transform_constraint_data_get_properties(spine_transform_constraint_data self);
 SPINE_C_API const char* spine_transform_constraint_data_get_name(spine_transform_constraint_data self);
-SPINE_C_API bool spine_transform_constraint_data_is_skin_required(spine_transform_constraint_data self);
+SPINE_C_API bool spine_transform_constraint_data_get_skin_required(spine_transform_constraint_data self);
 SPINE_C_API spine_transform_constraint_pose spine_transform_constraint_data_get_setup_pose(spine_transform_constraint_data self);
 SPINE_C_API void spine_transform_constraint_data_set_skin_required(spine_transform_constraint_data self, bool skinRequired);
 SPINE_C_API spine_rtti spine_transform_constraint_data_rtti(void);

spine-cpp/include/spine/Atlas.h

@@ -107,18 +107,38 @@ namespace spine {
 	};
 
 	class SP_API AtlasRegion : public TextureRegion {
-	public:
-		AtlasRegion() : TextureRegion(), page(nullptr), name(""), index(0), x(0), y(0) {}
-		~AtlasRegion() {}
+		friend class Atlas;
 
-		AtlasPage *page;
-		String name;
-		int index;
-		int x, y;
-		Array<int> splits;
-		Array<int> pads;
-		Array<String> names;
-		Array<float> values;
+	public:
+		AtlasRegion() : TextureRegion(), _page(nullptr), _name(""), _index(0), _x(0), _y(0) {}
+		~AtlasRegion() {}
+		AtlasPage *getPage() const { return _page; }
+		String getName() const { return _name; }
+		int getIndex() const { return _index; }
+		int getX() const { return _x; }
+		int getY() const { return _y; }
+		Array<int> &getSplits() { return _splits; }
+		Array<int> &getPads() { return _pads; }
+		Array<String> &getNames() { return _names; }
+		Array<float> &getValues() { return _values; }
+		void setPage(AtlasPage *value) { _page = value; }
+		void setName(const String &value) { _name = value; }
+		void setIndex(int value) { _index = value; }
+		void setX(int value) { _x = value; }
+		void setY(int value) { _y = value; }
+		void setSplits(const Array<int> &value) { _splits = value; }
+		void setPads(const Array<int> &value) { _pads = value; }
+		void setNames(const Array<String> &value) { _names = value; }
+		void setValues(const Array<float> &value) { _values = value; }
+	private:
+		AtlasPage *_page;
+		String _name;
+		int _index;
+		int _x, _y;
+		Array<int> _splits;
+		Array<int> _pads;
+		Array<String> _names;
+		Array<float> _values;
 	};
 
 	class TextureLoader;

spine-cpp/include/spine/TextureRegion.h

@@ -34,28 +34,46 @@
 
 namespace spine {
 	class SP_API TextureRegion : public SpineObject {
-	public:
-		void *rendererObject;
-		float u, v, u2, v2;
-		int degrees;
-		float offsetX, offsetY;
-		int width, height;
-		int originalWidth, originalHeight;
+		friend class MeshAttachment;
+		friend class RegionAttachment;
+		friend class Atlas;
+		friend class AtlasRegion;
+		friend class SkeletonRenderer;
 
-		TextureRegion(): rendererObject(NULL), u(0), v(0), u2(0), v2(0), degrees(0), offsetX(0), offsetY(0), width(0), height(0), originalWidth(0), originalHeight(0) {};
+	public:
+		TextureRegion(): _rendererObject(NULL), _u(0), _v(0), _u2(0), _v2(0), _degrees(0), _offsetX(0), _offsetY(0), _width(0), _height(0), _originalWidth(0), _originalHeight(0) {};
 		~TextureRegion() {};
 
-		float getU() const { return u; };
-		float getV() const { return v; };
-		float getU2() const { return u2; };
-		float getV2() const { return v2; };
-		int getDegrees() const { return degrees; };
-		float getOffsetX() const { return offsetX; };
-		float getOffsetY() const { return offsetY; };
-		int getRegionWidth() const { return width; };
-		int getRegionHeight() const { return height; };
-		int getOriginalWidth() const { return originalWidth; };
-		int getOriginalHeight() const { return originalHeight; };
+		float getU() const { return _u; };
+		void setU(float value) { _u = value; }
+		float getV() const { return _v; }
+		void setV(float value) { _v = value; }
+		float getU2() const { return _u2; }
+		void setU2(float value) { _u2 = value; }
+		float getV2() const { return _v2; }
+		void setV2(float value) { _v2 = value; }
+		int getDegrees() const { return _degrees; }
+		void setDegrees(int value) { _degrees = value; }
+		float getOffsetX() const { return _offsetX; }
+		void setOffsetX(float value) { _offsetX = value; }
+		float getOffsetY() const { return _offsetY; }
+		void setOffsetY(float value) { _offsetY = value; }
+		int getRegionWidth() const { return _width; };
+		void setRegionWidth(int value) { _width = value; }
+		int getRegionHeight() const { return _height; }
+		void setRegionHeight(int value) { _height = value; }
+		int getOriginalWidth() const { return _originalWidth; };
+		void setOriginalWidth(int value) { _originalWidth = value; }
+		int getOriginalHeight() const { return _originalHeight; };
+		void setOriginalHeight(int value) { _originalHeight = value; }
+
+	private:
+		void *_rendererObject;
+		float _u, _v, _u2, _v2;
+		int _degrees;
+		float _offsetX, _offsetY;
+		int _width, _height;
+		int _originalWidth, _originalHeight;
 	};
 }
 

spine-cpp/src/spine/Atlas.cpp

@@ -80,14 +80,14 @@ void Atlas::flipV() {
 	for (size_t i = 0, n = _regions.size(); i < n; ++i) {
 		AtlasRegion *regionP = _regions[i];
 		AtlasRegion &region = *regionP;
-		region.v = 1 - region.v;
-		region.v2 = 1 - region.v2;
+		region._v = 1 - region._v;
+		region._v2 = 1 - region._v2;
 	}
 }
 
 AtlasRegion *Atlas::findRegion(const String &name) {
 	for (size_t i = 0, n = _regions.size(); i < n; ++i)
-		if (_regions[i]->name == name) return _regions[i];
+		if (_regions[i]->_name == name) return _regions[i];
 	return NULL;
 }
 
@@ -291,63 +291,63 @@ void Atlas::load(const char *begin, int length, const char *dir, bool createText
 			_pages.add(page);
 		} else {
 			AtlasRegion *region = new (__FILE__, __LINE__) AtlasRegion();
-			region->page = page;
-			region->rendererObject = page->texture;
-			region->name = String(line->copy(), true);
+			region->_page = page;
+			region->_rendererObject = page->texture;
+			region->_name = String(line->copy(), true);
 			while (true) {
 				line = reader.readLine();
 				int count = reader.readEntry(entry, line);
 				if (count == 0) break;
 				if (entry[0].equals("xy")) {
-					region->x = entry[1].toInt();
-					region->y = entry[2].toInt();
+					region->_x = entry[1].toInt();
+					region->_y = entry[2].toInt();
 				} else if (entry[0].equals("size")) {
-					region->width = entry[1].toInt();
-					region->height = entry[2].toInt();
+					region->_width = entry[1].toInt();
+					region->_height = entry[2].toInt();
 				} else if (entry[0].equals("bounds")) {
-					region->x = entry[1].toInt();
-					region->y = entry[2].toInt();
-					region->width = entry[3].toInt();
-					region->height = entry[4].toInt();
+					region->_x = entry[1].toInt();
+					region->_y = entry[2].toInt();
+					region->_width = entry[3].toInt();
+					region->_height = entry[4].toInt();
 				} else if (entry[0].equals("offset")) {
-					region->offsetX = entry[1].toInt();
-					region->offsetY = entry[2].toInt();
+					region->_offsetX = entry[1].toInt();
+					region->_offsetY = entry[2].toInt();
 				} else if (entry[0].equals("orig")) {
-					region->originalWidth = entry[1].toInt();
-					region->originalHeight = entry[2].toInt();
+					region->_originalWidth = entry[1].toInt();
+					region->_originalHeight = entry[2].toInt();
 				} else if (entry[0].equals("offsets")) {
-					region->offsetX = entry[1].toInt();
-					region->offsetY = entry[2].toInt();
-					region->originalWidth = entry[3].toInt();
-					region->originalHeight = entry[4].toInt();
+					region->_offsetX = entry[1].toInt();
+					region->_offsetY = entry[2].toInt();
+					region->_originalWidth = entry[3].toInt();
+					region->_originalHeight = entry[4].toInt();
 				} else if (entry[0].equals("rotate")) {
 					if (entry[1].equals("true")) {
-						region->degrees = 90;
+						region->_degrees = 90;
 					} else if (!entry[1].equals("false")) {
-						region->degrees = entry[1].toInt();
+						region->_degrees = entry[1].toInt();
 					}
 				} else if (entry[0].equals("index")) {
-					region->index = entry[1].toInt();
+					region->_index = entry[1].toInt();
 				} else {
-					region->names.add(String(entry[0].copy()));
+					region->_names.add(String(entry[0].copy()));
 					for (int i = 0; i < count; i++) {
-						region->values.add(entry[i + 1].toInt());
+						region->_values.add(entry[i + 1].toInt());
 					}
 				}
 			}
-			if (region->originalWidth == 0 && region->originalHeight == 0) {
-				region->originalWidth = region->width;
-				region->originalHeight = region->height;
+			if (region->_originalWidth == 0 && region->_originalHeight == 0) {
+				region->_originalWidth = region->_width;
+				region->_originalHeight = region->_height;
 			}
 
-			region->u = (float) region->x / page->width;
-			region->v = (float) region->y / page->height;
-			if (region->degrees == 90) {
-				region->u2 = (float) (region->x + region->height) / page->width;
-				region->v2 = (float) (region->y + region->width) / page->height;
+			region->_u = (float) region->_x / page->width;
+			region->_v = (float) region->_y / page->height;
+			if (region->_degrees == 90) {
+				region->_u2 = (float) (region->_x + region->_height) / page->width;
+				region->_v2 = (float) (region->_y + region->_width) / page->height;
 			} else {
-				region->u2 = (float) (region->x + region->width) / page->width;
-				region->v2 = (float) (region->y + region->height) / page->height;
+				region->_u2 = (float) (region->_x + region->_width) / page->width;
+				region->_v2 = (float) (region->_y + region->_height) / page->height;
 			}
 			_regions.add(region);
 		}

spine-cpp/src/spine/MeshAttachment.cpp

@@ -58,16 +58,16 @@ void MeshAttachment::updateRegion() {
 	}
 
 	int i = 0, n = (int) _regionUVs.size();
-	float u = _region->u, v = _region->v;
+	float u = _region->_u, v = _region->_v;
 	float width = 0, height = 0;
-	switch (_region->degrees) {
+	switch (_region->_degrees) {
 		case 90: {
-			float textureWidth = _region->height / (_region->u2 - _region->u);
-			float textureHeight = _region->width / (_region->v2 - _region->v);
-			u -= (_region->originalHeight - _region->offsetY - _region->height) / textureWidth;
-			v -= (_region->originalWidth - _region->offsetX - _region->width) / textureHeight;
-			width = _region->originalHeight / textureWidth;
-			height = _region->originalWidth / textureHeight;
+			float textureWidth = _region->_height / (_region->_u2 - _region->_u);
+			float textureHeight = _region->_width / (_region->_v2 - _region->_v);
+			u -= (_region->_originalHeight - _region->_offsetY - _region->_height) / textureWidth;
+			v -= (_region->_originalWidth - _region->_offsetX - _region->_width) / textureHeight;
+			width = _region->_originalHeight / textureWidth;
+			height = _region->_originalWidth / textureHeight;
 			for (i = 0; i < n; i += 2) {
 				_uvs[i] = u + _regionUVs[i + 1] * width;
 				_uvs[i + 1] = v + (1 - _regionUVs[i]) * height;
@@ -75,12 +75,12 @@ void MeshAttachment::updateRegion() {
 			return;
 		}
 		case 180: {
-			float textureWidth = _region->width / (_region->u2 - _region->u);
-			float textureHeight = _region->height / (_region->v2 - _region->v);
-			u -= (_region->originalWidth - _region->offsetX - _region->width) / textureWidth;
-			v -= _region->offsetY / textureHeight;
-			width = _region->originalWidth / textureWidth;
-			height = _region->originalHeight / textureHeight;
+			float textureWidth = _region->_width / (_region->_u2 - _region->_u);
+			float textureHeight = _region->_height / (_region->_v2 - _region->_v);
+			u -= (_region->_originalWidth - _region->_offsetX - _region->_width) / textureWidth;
+			v -= _region->_offsetY / textureHeight;
+			width = _region->_originalWidth / textureWidth;
+			height = _region->_originalHeight / textureHeight;
 			for (i = 0; i < n; i += 2) {
 				_uvs[i] = u + (1 - _regionUVs[i]) * width;
 				_uvs[i + 1] = v + (1 - _regionUVs[i + 1]) * height;
@@ -88,12 +88,12 @@ void MeshAttachment::updateRegion() {
 			return;
 		}
 		case 270: {
-			float textureHeight = _region->height / (_region->v2 - _region->v);
-			float textureWidth = _region->width / (_region->u2 - _region->u);
-			u -= _region->offsetY / textureWidth;
-			v -= _region->offsetX / textureHeight;
-			width = _region->originalHeight / textureWidth;
-			height = _region->originalWidth / textureHeight;
+			float textureHeight = _region->_height / (_region->_v2 - _region->_v);
+			float textureWidth = _region->_width / (_region->_u2 - _region->_u);
+			u -= _region->_offsetY / textureWidth;
+			v -= _region->_offsetX / textureHeight;
+			width = _region->_originalHeight / textureWidth;
+			height = _region->_originalWidth / textureHeight;
 			for (i = 0; i < n; i += 2) {
 				_uvs[i] = u + (1 - _regionUVs[i + 1]) * width;
 				_uvs[i + 1] = v + _regionUVs[i] * height;
@@ -101,12 +101,12 @@ void MeshAttachment::updateRegion() {
 			return;
 		}
 		default: {
-			float textureWidth = _region->width / (_region->u2 - _region->u);
-			float textureHeight = _region->height / (_region->v2 - _region->v);
-			u -= _region->offsetX / textureWidth;
-			v -= (_region->originalHeight - _region->offsetY - _region->height) / textureHeight;
-			width = _region->originalWidth / textureWidth;
-			height = _region->originalHeight / textureHeight;
+			float textureWidth = _region->_width / (_region->_u2 - _region->_u);
+			float textureHeight = _region->_height / (_region->_v2 - _region->_v);
+			u -= _region->_offsetX / textureWidth;
+			v -= (_region->_originalHeight - _region->_offsetY - _region->_height) / textureHeight;
+			width = _region->_originalWidth / textureWidth;
+			height = _region->_originalHeight / textureHeight;
 			for (i = 0; i < n; i += 2) {
 				_uvs[i] = u + _regionUVs[i] * width;
 				_uvs[i + 1] = v + _regionUVs[i + 1] * height;

spine-cpp/src/spine/RegionAttachment.cpp

@@ -80,12 +80,12 @@ void RegionAttachment::updateRegion() {
 		return;
 	}
 
-	float regionScaleX = _width / _region->originalWidth * _scaleX;
-	float regionScaleY = _height / _region->originalHeight * _scaleY;
-	float localX = -_width / 2 * _scaleX + _region->offsetX * regionScaleX;
-	float localY = -_height / 2 * _scaleY + _region->offsetY * regionScaleY;
-	float localX2 = localX + _region->width * regionScaleX;
-	float localY2 = localY + _region->height * regionScaleY;
+	float regionScaleX = _width / _region->_originalWidth * _scaleX;
+	float regionScaleY = _height / _region->_originalHeight * _scaleY;
+	float localX = -_width / 2 * _scaleX + _region->_offsetX * regionScaleX;
+	float localY = -_height / 2 * _scaleY + _region->_offsetY * regionScaleY;
+	float localX2 = localX + _region->_width * regionScaleX;
+	float localY2 = localY + _region->_height * regionScaleY;
 	float cos = MathUtil::cosDeg(_rotation);
 	float sin = MathUtil::sinDeg(_rotation);
 	float localXCos = localX * cos + _x;
@@ -106,24 +106,24 @@ void RegionAttachment::updateRegion() {
 	_vertexOffset[BRX] = localX2Cos - localYSin;
 	_vertexOffset[BRY] = localYCos + localX2Sin;
 
-	if (_region->degrees == 90) {
-		_uvs[URX] = _region->u;
-		_uvs[URY] = _region->v2;
-		_uvs[BRX] = _region->u;
-		_uvs[BRY] = _region->v;
-		_uvs[BLX] = _region->u2;
-		_uvs[BLY] = _region->v;
-		_uvs[ULX] = _region->u2;
-		_uvs[ULY] = _region->v2;
+	if (_region->_degrees == 90) {
+		_uvs[URX] = _region->_u;
+		_uvs[URY] = _region->_v2;
+		_uvs[BRX] = _region->_u;
+		_uvs[BRY] = _region->_v;
+		_uvs[BLX] = _region->_u2;
+		_uvs[BLY] = _region->_v;
+		_uvs[ULX] = _region->_u2;
+		_uvs[ULY] = _region->_v2;
 	} else {
-		_uvs[ULX] = _region->u;
-		_uvs[ULY] = _region->v2;
-		_uvs[URX] = _region->u;
-		_uvs[URY] = _region->v;
-		_uvs[BRX] = _region->u2;
-		_uvs[BRY] = _region->v;
-		_uvs[BLX] = _region->u2;
-		_uvs[BLY] = _region->v2;
+		_uvs[ULX] = _region->_u;
+		_uvs[ULY] = _region->_v2;
+		_uvs[URX] = _region->_u;
+		_uvs[URY] = _region->_v;
+		_uvs[BRX] = _region->_u2;
+		_uvs[BRY] = _region->_v;
+		_uvs[BLX] = _region->_u2;
+		_uvs[BLY] = _region->_v2;
 	}
 }
 

spine-cpp/src/spine/SkeletonRenderer.cpp

@@ -182,7 +182,7 @@ RenderCommand *SkeletonRenderer::render(Skeleton &skeleton) {
 			uvs = &regionAttachment->getUVs();
 			indices = quadIndices;
 			indicesCount = 6;
-			texture = regionAttachment->getRegion()->rendererObject;
+			texture = regionAttachment->getRegion()->_rendererObject;
 
 		} else if (attachment->getRTTI().isExactly(MeshAttachment::rtti)) {
 			MeshAttachment *mesh = (MeshAttachment *) attachment;
@@ -200,7 +200,7 @@ RenderCommand *SkeletonRenderer::render(Skeleton &skeleton) {
 			uvs = &mesh->getUVs();
 			indices = &mesh->getTriangles();
 			indicesCount = (int32_t) indices->size();
-			texture = mesh->getRegion()->rendererObject;
+			texture = mesh->getRegion()->_rendererObject;
 
 		} else if (attachment->getRTTI().isExactly(ClippingAttachment::rtti)) {
 			ClippingAttachment *clip = (ClippingAttachment *) slot.getAppliedPose().getAttachment();