From aac98324f2e325077653c2ecc37671235068950b Mon Sep 17 00:00:00 2001 From: Mario Zechner Date: Mon, 14 Jul 2025 21:13:56 +0200 Subject: [PATCH] [cpp][c] Clean up AtlasRegion, TextureRegion to use _ field prefixes and getters/setters instead of public fields --- spine-c/build.sh | 6 + spine-c/codegen/exclusions.txt | 6 +- spine-c/codegen/spine-cpp-types.json | 1177 +++++++++++++++-- spine-c/src/generated/animation_state.cpp | 2 +- spine-c/src/generated/atlas_region.cpp | 164 ++- spine-c/src/generated/atlas_region.h | 37 +- spine-c/src/generated/bone_data.cpp | 4 +- spine-c/src/generated/bone_data.h | 2 +- spine-c/src/generated/constraint_data.cpp | 4 +- spine-c/src/generated/constraint_data.h | 2 +- spine-c/src/generated/event_data.cpp | 24 +- spine-c/src/generated/event_data.h | 12 +- spine-c/src/generated/from_property.cpp | 8 + spine-c/src/generated/from_property.h | 2 + spine-c/src/generated/from_rotate.cpp | 8 + spine-c/src/generated/from_rotate.h | 2 + spine-c/src/generated/from_scale_x.cpp | 8 + spine-c/src/generated/from_scale_x.h | 2 + spine-c/src/generated/from_scale_y.cpp | 8 + spine-c/src/generated/from_scale_y.h | 2 + spine-c/src/generated/from_shear_y.cpp | 8 + spine-c/src/generated/from_shear_y.h | 2 + spine-c/src/generated/from_x.cpp | 8 + spine-c/src/generated/from_x.h | 2 + spine-c/src/generated/from_y.cpp | 8 + spine-c/src/generated/from_y.h | 2 + spine-c/src/generated/ik_constraint_data.cpp | 4 +- spine-c/src/generated/ik_constraint_data.h | 2 +- spine-c/src/generated/path_attachment.cpp | 8 +- spine-c/src/generated/path_attachment.h | 4 +- .../src/generated/path_constraint_data.cpp | 4 +- spine-c/src/generated/path_constraint_data.h | 2 +- spine-c/src/generated/physics_constraint.cpp | 4 +- spine-c/src/generated/physics_constraint.h | 2 +- .../src/generated/physics_constraint_data.cpp | 4 +- .../src/generated/physics_constraint_data.h | 2 +- spine-c/src/generated/posed_data.cpp | 4 +- spine-c/src/generated/posed_data.h | 2 +- spine-c/src/generated/slider.cpp | 4 +- spine-c/src/generated/slider.h | 2 +- spine-c/src/generated/slider_data.cpp | 4 +- spine-c/src/generated/slider_data.h | 2 +- spine-c/src/generated/slot_data.cpp | 4 +- spine-c/src/generated/slot_data.h | 2 +- spine-c/src/generated/texture_region.cpp | 60 +- spine-c/src/generated/texture_region.h | 10 +- spine-c/src/generated/to_property.cpp | 8 + spine-c/src/generated/to_property.h | 2 + spine-c/src/generated/to_rotate.cpp | 8 + spine-c/src/generated/to_rotate.h | 2 + spine-c/src/generated/to_scale_x.cpp | 8 + spine-c/src/generated/to_scale_x.h | 2 + spine-c/src/generated/to_scale_y.cpp | 8 + spine-c/src/generated/to_scale_y.h | 2 + spine-c/src/generated/to_shear_y.cpp | 8 + spine-c/src/generated/to_shear_y.h | 2 + spine-c/src/generated/to_x.cpp | 8 + spine-c/src/generated/to_x.h | 2 + spine-c/src/generated/to_y.cpp | 8 + spine-c/src/generated/to_y.h | 2 + .../src/generated/transform_constraint.cpp | 4 +- spine-c/src/generated/transform_constraint.h | 2 +- .../generated/transform_constraint_data.cpp | 4 +- .../src/generated/transform_constraint_data.h | 2 +- spine-cpp/include/spine/Atlas.h | 42 +- spine-cpp/include/spine/TextureRegion.h | 56 +- spine-cpp/src/spine/Atlas.cpp | 74 +- spine-cpp/src/spine/MeshAttachment.cpp | 52 +- spine-cpp/src/spine/RegionAttachment.cpp | 46 +- spine-cpp/src/spine/SkeletonRenderer.cpp | 4 +- 70 files changed, 1580 insertions(+), 416 deletions(-) diff --git a/spine-c/build.sh b/spine-c/build.sh index b03b82928..53543b1fe 100755 --- a/spine-c/build.sh +++ b/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 diff --git a/spine-c/codegen/exclusions.txt b/spine-c/codegen/exclusions.txt index c423dcbaf..c54e0c656 100644 --- a/spine-c/codegen/exclusions.txt +++ b/spine-c/codegen/exclusions.txt @@ -40,7 +40,8 @@ method: TrackEntry::setRendererObject # Array returning methods and fields not supported method: AttachmentTimeline::getAttachmentNames method: Skin::findNamesForSlot -field: AtlasRegion::names +method: AtlasRegion::getNames +method: AtlasRegion::setNames # Array> 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 \ No newline at end of file +field-set: RenderCommand + diff --git a/spine-c/codegen/spine-cpp-types.json b/spine-c/codegen/spine-cpp-types.json index c3eadfc26..e512e9b88 100644 --- a/spine-c/codegen/spine-cpp-types.json +++ b/spine-c/codegen/spine-cpp-types.json @@ -1333,7 +1333,7 @@ { "kind": "method", "name": "getData", - "returnType": "AnimationStateData *", + "returnType": "AnimationStateData &", "parameters": [], "isStatic": false, "isVirtual": false, @@ -2062,58 +2062,526 @@ "isPure": false }, { - "kind": "field", - "name": "page", - "type": "AtlasPage *", - "isStatic": false + "kind": "method", + "name": "getPage", + "returnType": "AtlasPage *", + "parameters": [], + "isStatic": false, + "isVirtual": false, + "isPure": false, + "isConst": false }, { - "kind": "field", - "name": "name", - "type": "String", - "isStatic": false + "kind": "method", + "name": "getName", + "returnType": "String", + "parameters": [], + "isStatic": false, + "isVirtual": false, + "isPure": false, + "isConst": false }, { - "kind": "field", - "name": "index", - "type": "int", - "isStatic": false + "kind": "method", + "name": "getIndex", + "returnType": "int", + "parameters": [], + "isStatic": false, + "isVirtual": false, + "isPure": false, + "isConst": false }, { - "kind": "field", - "name": "x", - "type": "int", - "isStatic": false + "kind": "method", + "name": "getX", + "returnType": "int", + "parameters": [], + "isStatic": false, + "isVirtual": false, + "isPure": false, + "isConst": false }, { - "kind": "field", - "name": "y", - "type": "int", - "isStatic": false + "kind": "method", + "name": "getY", + "returnType": "int", + "parameters": [], + "isStatic": false, + "isVirtual": false, + "isPure": false, + "isConst": false }, { - "kind": "field", - "name": "splits", - "type": "Array", - "isStatic": false + "kind": "method", + "name": "getSplits", + "returnType": "Array &", + "parameters": [], + "isStatic": false, + "isVirtual": false, + "isPure": false, + "isConst": false }, { - "kind": "field", - "name": "pads", - "type": "Array", - "isStatic": false + "kind": "method", + "name": "getPads", + "returnType": "Array &", + "parameters": [], + "isStatic": false, + "isVirtual": false, + "isPure": false, + "isConst": false }, { - "kind": "field", - "name": "names", - "type": "Array", - "isStatic": false + "kind": "method", + "name": "getNames", + "returnType": "Array &", + "parameters": [], + "isStatic": false, + "isVirtual": false, + "isPure": false, + "isConst": false }, { - "kind": "field", - "name": "values", - "type": "Array", - "isStatic": false + "kind": "method", + "name": "getValues", + "returnType": "Array &", + "parameters": [], + "isStatic": false, + "isVirtual": false, + "isPure": false, + "isConst": false + }, + { + "kind": "method", + "name": "setPage", + "returnType": "void", + "parameters": [ + { + "name": "value", + "type": "AtlasPage *" + } + ], + "isStatic": false, + "isVirtual": false, + "isPure": false, + "isConst": false + }, + { + "kind": "method", + "name": "setName", + "returnType": "void", + "parameters": [ + { + "name": "value", + "type": "const String &" + } + ], + "isStatic": false, + "isVirtual": false, + "isPure": false, + "isConst": false + }, + { + "kind": "method", + "name": "setIndex", + "returnType": "void", + "parameters": [ + { + "name": "value", + "type": "int" + } + ], + "isStatic": false, + "isVirtual": false, + "isPure": false, + "isConst": false + }, + { + "kind": "method", + "name": "setX", + "returnType": "void", + "parameters": [ + { + "name": "value", + "type": "int" + } + ], + "isStatic": false, + "isVirtual": false, + "isPure": false, + "isConst": false + }, + { + "kind": "method", + "name": "setY", + "returnType": "void", + "parameters": [ + { + "name": "value", + "type": "int" + } + ], + "isStatic": false, + "isVirtual": false, + "isPure": false, + "isConst": false + }, + { + "kind": "method", + "name": "setSplits", + "returnType": "void", + "parameters": [ + { + "name": "value", + "type": "const Array &" + } + ], + "isStatic": false, + "isVirtual": false, + "isPure": false, + "isConst": false + }, + { + "kind": "method", + "name": "setPads", + "returnType": "void", + "parameters": [ + { + "name": "value", + "type": "const Array &" + } + ], + "isStatic": false, + "isVirtual": false, + "isPure": false, + "isConst": false + }, + { + "kind": "method", + "name": "setNames", + "returnType": "void", + "parameters": [ + { + "name": "value", + "type": "const Array &" + } + ], + "isStatic": false, + "isVirtual": false, + "isPure": false, + "isConst": false + }, + { + "kind": "method", + "name": "setValues", + "returnType": "void", + "parameters": [ + { + "name": "value", + "type": "const Array &" + } + ], + "isStatic": false, + "isVirtual": false, + "isPure": false, + "isConst": false + }, + { + "kind": "method", + "name": "getU", + "returnType": "float", + "parameters": [], + "isStatic": false, + "isVirtual": false, + "isPure": false, + "isConst": false, + "fromSupertype": "TextureRegion" + }, + { + "kind": "method", + "name": "setU", + "returnType": "void", + "parameters": [ + { + "name": "value", + "type": "float" + } + ], + "isStatic": false, + "isVirtual": false, + "isPure": false, + "isConst": false, + "fromSupertype": "TextureRegion" + }, + { + "kind": "method", + "name": "getV", + "returnType": "float", + "parameters": [], + "isStatic": false, + "isVirtual": false, + "isPure": false, + "isConst": false, + "fromSupertype": "TextureRegion" + }, + { + "kind": "method", + "name": "setV", + "returnType": "void", + "parameters": [ + { + "name": "value", + "type": "float" + } + ], + "isStatic": false, + "isVirtual": false, + "isPure": false, + "isConst": false, + "fromSupertype": "TextureRegion" + }, + { + "kind": "method", + "name": "getU2", + "returnType": "float", + "parameters": [], + "isStatic": false, + "isVirtual": false, + "isPure": false, + "isConst": false, + "fromSupertype": "TextureRegion" + }, + { + "kind": "method", + "name": "setU2", + "returnType": "void", + "parameters": [ + { + "name": "value", + "type": "float" + } + ], + "isStatic": false, + "isVirtual": false, + "isPure": false, + "isConst": false, + "fromSupertype": "TextureRegion" + }, + { + "kind": "method", + "name": "getV2", + "returnType": "float", + "parameters": [], + "isStatic": false, + "isVirtual": false, + "isPure": false, + "isConst": false, + "fromSupertype": "TextureRegion" + }, + { + "kind": "method", + "name": "setV2", + "returnType": "void", + "parameters": [ + { + "name": "value", + "type": "float" + } + ], + "isStatic": false, + "isVirtual": false, + "isPure": false, + "isConst": false, + "fromSupertype": "TextureRegion" + }, + { + "kind": "method", + "name": "getDegrees", + "returnType": "int", + "parameters": [], + "isStatic": false, + "isVirtual": false, + "isPure": false, + "isConst": false, + "fromSupertype": "TextureRegion" + }, + { + "kind": "method", + "name": "setDegrees", + "returnType": "void", + "parameters": [ + { + "name": "value", + "type": "int" + } + ], + "isStatic": false, + "isVirtual": false, + "isPure": false, + "isConst": false, + "fromSupertype": "TextureRegion" + }, + { + "kind": "method", + "name": "getOffsetX", + "returnType": "float", + "parameters": [], + "isStatic": false, + "isVirtual": false, + "isPure": false, + "isConst": false, + "fromSupertype": "TextureRegion" + }, + { + "kind": "method", + "name": "setOffsetX", + "returnType": "void", + "parameters": [ + { + "name": "value", + "type": "float" + } + ], + "isStatic": false, + "isVirtual": false, + "isPure": false, + "isConst": false, + "fromSupertype": "TextureRegion" + }, + { + "kind": "method", + "name": "getOffsetY", + "returnType": "float", + "parameters": [], + "isStatic": false, + "isVirtual": false, + "isPure": false, + "isConst": false, + "fromSupertype": "TextureRegion" + }, + { + "kind": "method", + "name": "setOffsetY", + "returnType": "void", + "parameters": [ + { + "name": "value", + "type": "float" + } + ], + "isStatic": false, + "isVirtual": false, + "isPure": false, + "isConst": false, + "fromSupertype": "TextureRegion" + }, + { + "kind": "method", + "name": "getRegionWidth", + "returnType": "int", + "parameters": [], + "isStatic": false, + "isVirtual": false, + "isPure": false, + "isConst": false, + "fromSupertype": "TextureRegion" + }, + { + "kind": "method", + "name": "setRegionWidth", + "returnType": "void", + "parameters": [ + { + "name": "value", + "type": "int" + } + ], + "isStatic": false, + "isVirtual": false, + "isPure": false, + "isConst": false, + "fromSupertype": "TextureRegion" + }, + { + "kind": "method", + "name": "getRegionHeight", + "returnType": "int", + "parameters": [], + "isStatic": false, + "isVirtual": false, + "isPure": false, + "isConst": false, + "fromSupertype": "TextureRegion" + }, + { + "kind": "method", + "name": "setRegionHeight", + "returnType": "void", + "parameters": [ + { + "name": "value", + "type": "int" + } + ], + "isStatic": false, + "isVirtual": false, + "isPure": false, + "isConst": false, + "fromSupertype": "TextureRegion" + }, + { + "kind": "method", + "name": "getOriginalWidth", + "returnType": "int", + "parameters": [], + "isStatic": false, + "isVirtual": false, + "isPure": false, + "isConst": false, + "fromSupertype": "TextureRegion" + }, + { + "kind": "method", + "name": "setOriginalWidth", + "returnType": "void", + "parameters": [ + { + "name": "value", + "type": "int" + } + ], + "isStatic": false, + "isVirtual": false, + "isPure": false, + "isConst": false, + "fromSupertype": "TextureRegion" + }, + { + "kind": "method", + "name": "getOriginalHeight", + "returnType": "int", + "parameters": [], + "isStatic": false, + "isVirtual": false, + "isPure": false, + "isConst": false, + "fromSupertype": "TextureRegion" + }, + { + "kind": "method", + "name": "setOriginalHeight", + "returnType": "void", + "parameters": [ + { + "name": "value", + "type": "int" + } + ], + "isStatic": false, + "isVirtual": false, + "isPure": false, + "isConst": false, + "fromSupertype": "TextureRegion" } ], "isAbstract": false, @@ -2124,7 +2592,7 @@ "name": "Atlas", "kind": "class", "loc": { - "line": 126, + "line": 146, "col": 15 }, "superTypes": [ @@ -3411,7 +3879,7 @@ }, { "kind": "method", - "name": "isSkinRequired", + "name": "getSkinRequired", "returnType": "bool", "parameters": [], "isStatic": false, @@ -8344,7 +8812,7 @@ { "kind": "method", "name": "getData", - "returnType": "ConstraintData &", + "returnType": "D &", "parameters": [], "isStatic": false, "isVirtual": true, @@ -8567,7 +9035,7 @@ }, { "kind": "method", - "name": "isSkinRequired", + "name": "getSkinRequired", "returnType": "bool", "parameters": [], "isStatic": false, @@ -8635,7 +9103,7 @@ }, { "kind": "method", - "name": "isSkinRequired", + "name": "getSkinRequired", "returnType": "bool", "parameters": [], "isStatic": false, @@ -11390,7 +11858,7 @@ }, { "kind": "method", - "name": "getIntValue", + "name": "getInt", "returnType": "int", "parameters": [], "isStatic": false, @@ -11400,7 +11868,7 @@ }, { "kind": "method", - "name": "setIntValue", + "name": "setInt", "returnType": "void", "parameters": [ { @@ -11415,7 +11883,7 @@ }, { "kind": "method", - "name": "getFloatValue", + "name": "getFloat", "returnType": "float", "parameters": [], "isStatic": false, @@ -11425,7 +11893,7 @@ }, { "kind": "method", - "name": "setFloatValue", + "name": "setFloat", "returnType": "void", "parameters": [ { @@ -11440,7 +11908,7 @@ }, { "kind": "method", - "name": "getStringValue", + "name": "getString", "returnType": "const String &", "parameters": [], "isStatic": false, @@ -11450,7 +11918,7 @@ }, { "kind": "method", - "name": "setStringValue", + "name": "setString", "returnType": "void", "parameters": [ { @@ -12747,7 +13215,7 @@ }, { "kind": "method", - "name": "isSkinRequired", + "name": "getSkinRequired", "returnType": "bool", "parameters": [], "isStatic": false, @@ -13539,6 +14007,63 @@ "SpineObject" ], "members": [ + { + "kind": "method", + "name": "asFloatArray", + "returnType": "bool", + "parameters": [ + { + "name": "value", + "type": "Json *" + }, + { + "name": "array", + "type": "Array &" + } + ], + "isStatic": true, + "isVirtual": false, + "isPure": false, + "isConst": false + }, + { + "kind": "method", + "name": "asIntArray", + "returnType": "bool", + "parameters": [ + { + "name": "value", + "type": "Json *" + }, + { + "name": "array", + "type": "Array &" + } + ], + "isStatic": true, + "isVirtual": false, + "isPure": false, + "isConst": false + }, + { + "kind": "method", + "name": "asUnsignedShortArray", + "returnType": "bool", + "parameters": [ + { + "name": "value", + "type": "Json *" + }, + { + "name": "array", + "type": "Array &" + } + ], + "isStatic": true, + "isVirtual": false, + "isPure": false, + "isConst": false + }, { "kind": "method", "name": "getItem", @@ -14805,7 +15330,7 @@ }, { "kind": "method", - "name": "isClosed", + "name": "getClosed", "returnType": "bool", "parameters": [], "isStatic": false, @@ -14830,7 +15355,7 @@ }, { "kind": "method", - "name": "isConstantSpeed", + "name": "getConstantSpeed", "returnType": "bool", "parameters": [], "isStatic": false, @@ -15561,7 +16086,7 @@ }, { "kind": "method", - "name": "isSkinRequired", + "name": "getSkinRequired", "returnType": "bool", "parameters": [], "isStatic": false, @@ -17272,7 +17797,7 @@ { "kind": "method", "name": "getData", - "returnType": "ConstraintData &", + "returnType": "PhysicsConstraintData &", "parameters": [], "isStatic": false, "isVirtual": true, @@ -17803,7 +18328,7 @@ }, { "kind": "method", - "name": "isSkinRequired", + "name": "getSkinRequired", "returnType": "bool", "parameters": [], "isStatic": false, @@ -22601,7 +23126,7 @@ }, { "kind": "method", - "name": "isSkinRequired", + "name": "getSkinRequired", "returnType": "bool", "parameters": [], "isStatic": false, @@ -22689,7 +23214,7 @@ }, { "kind": "method", - "name": "isSkinRequired", + "name": "getSkinRequired", "returnType": "bool", "parameters": [], "isStatic": false, @@ -29426,7 +29951,7 @@ { "kind": "method", "name": "getData", - "returnType": "ConstraintData &", + "returnType": "SliderData &", "parameters": [], "isStatic": false, "isVirtual": true, @@ -29782,7 +30307,7 @@ }, { "kind": "method", - "name": "isSkinRequired", + "name": "getSkinRequired", "returnType": "bool", "parameters": [], "isStatic": false, @@ -31454,7 +31979,7 @@ }, { "kind": "method", - "name": "isSkinRequired", + "name": "getSkinRequired", "returnType": "bool", "parameters": [], "isStatic": false, @@ -31900,6 +32425,21 @@ "isPure": false, "isConst": false }, + { + "kind": "method", + "name": "append", + "returnType": "String &", + "parameters": [ + { + "name": "c", + "type": "char" + } + ], + "isStatic": false, + "isVirtual": false, + "isPure": false, + "isConst": false + }, { "kind": "method", "name": "startsWith", @@ -32051,78 +32591,6 @@ "SpineObject" ], "members": [ - { - "kind": "field", - "name": "rendererObject", - "type": "void *", - "isStatic": false - }, - { - "kind": "field", - "name": "u", - "type": "float", - "isStatic": false - }, - { - "kind": "field", - "name": "v", - "type": "float", - "isStatic": false - }, - { - "kind": "field", - "name": "u2", - "type": "float", - "isStatic": false - }, - { - "kind": "field", - "name": "v2", - "type": "float", - "isStatic": false - }, - { - "kind": "field", - "name": "degrees", - "type": "int", - "isStatic": false - }, - { - "kind": "field", - "name": "offsetX", - "type": "float", - "isStatic": false - }, - { - "kind": "field", - "name": "offsetY", - "type": "float", - "isStatic": false - }, - { - "kind": "field", - "name": "width", - "type": "int", - "isStatic": false - }, - { - "kind": "field", - "name": "height", - "type": "int", - "isStatic": false - }, - { - "kind": "field", - "name": "originalWidth", - "type": "int", - "isStatic": false - }, - { - "kind": "field", - "name": "originalHeight", - "type": "int", - "isStatic": false - }, { "kind": "constructor", "name": "TextureRegion", @@ -32133,6 +32601,281 @@ "name": "~TextureRegion", "isVirtual": false, "isPure": false + }, + { + "kind": "method", + "name": "getU", + "returnType": "float", + "parameters": [], + "isStatic": false, + "isVirtual": false, + "isPure": false, + "isConst": false + }, + { + "kind": "method", + "name": "setU", + "returnType": "void", + "parameters": [ + { + "name": "value", + "type": "float" + } + ], + "isStatic": false, + "isVirtual": false, + "isPure": false, + "isConst": false + }, + { + "kind": "method", + "name": "getV", + "returnType": "float", + "parameters": [], + "isStatic": false, + "isVirtual": false, + "isPure": false, + "isConst": false + }, + { + "kind": "method", + "name": "setV", + "returnType": "void", + "parameters": [ + { + "name": "value", + "type": "float" + } + ], + "isStatic": false, + "isVirtual": false, + "isPure": false, + "isConst": false + }, + { + "kind": "method", + "name": "getU2", + "returnType": "float", + "parameters": [], + "isStatic": false, + "isVirtual": false, + "isPure": false, + "isConst": false + }, + { + "kind": "method", + "name": "setU2", + "returnType": "void", + "parameters": [ + { + "name": "value", + "type": "float" + } + ], + "isStatic": false, + "isVirtual": false, + "isPure": false, + "isConst": false + }, + { + "kind": "method", + "name": "getV2", + "returnType": "float", + "parameters": [], + "isStatic": false, + "isVirtual": false, + "isPure": false, + "isConst": false + }, + { + "kind": "method", + "name": "setV2", + "returnType": "void", + "parameters": [ + { + "name": "value", + "type": "float" + } + ], + "isStatic": false, + "isVirtual": false, + "isPure": false, + "isConst": false + }, + { + "kind": "method", + "name": "getDegrees", + "returnType": "int", + "parameters": [], + "isStatic": false, + "isVirtual": false, + "isPure": false, + "isConst": false + }, + { + "kind": "method", + "name": "setDegrees", + "returnType": "void", + "parameters": [ + { + "name": "value", + "type": "int" + } + ], + "isStatic": false, + "isVirtual": false, + "isPure": false, + "isConst": false + }, + { + "kind": "method", + "name": "getOffsetX", + "returnType": "float", + "parameters": [], + "isStatic": false, + "isVirtual": false, + "isPure": false, + "isConst": false + }, + { + "kind": "method", + "name": "setOffsetX", + "returnType": "void", + "parameters": [ + { + "name": "value", + "type": "float" + } + ], + "isStatic": false, + "isVirtual": false, + "isPure": false, + "isConst": false + }, + { + "kind": "method", + "name": "getOffsetY", + "returnType": "float", + "parameters": [], + "isStatic": false, + "isVirtual": false, + "isPure": false, + "isConst": false + }, + { + "kind": "method", + "name": "setOffsetY", + "returnType": "void", + "parameters": [ + { + "name": "value", + "type": "float" + } + ], + "isStatic": false, + "isVirtual": false, + "isPure": false, + "isConst": false + }, + { + "kind": "method", + "name": "getRegionWidth", + "returnType": "int", + "parameters": [], + "isStatic": false, + "isVirtual": false, + "isPure": false, + "isConst": false + }, + { + "kind": "method", + "name": "setRegionWidth", + "returnType": "void", + "parameters": [ + { + "name": "value", + "type": "int" + } + ], + "isStatic": false, + "isVirtual": false, + "isPure": false, + "isConst": false + }, + { + "kind": "method", + "name": "getRegionHeight", + "returnType": "int", + "parameters": [], + "isStatic": false, + "isVirtual": false, + "isPure": false, + "isConst": false + }, + { + "kind": "method", + "name": "setRegionHeight", + "returnType": "void", + "parameters": [ + { + "name": "value", + "type": "int" + } + ], + "isStatic": false, + "isVirtual": false, + "isPure": false, + "isConst": false + }, + { + "kind": "method", + "name": "getOriginalWidth", + "returnType": "int", + "parameters": [], + "isStatic": false, + "isVirtual": false, + "isPure": false, + "isConst": false + }, + { + "kind": "method", + "name": "setOriginalWidth", + "returnType": "void", + "parameters": [ + { + "name": "value", + "type": "int" + } + ], + "isStatic": false, + "isVirtual": false, + "isPure": false, + "isConst": false + }, + { + "kind": "method", + "name": "getOriginalHeight", + "returnType": "int", + "parameters": [], + "isStatic": false, + "isVirtual": false, + "isPure": false, + "isConst": false + }, + { + "kind": "method", + "name": "setOriginalHeight", + "returnType": "void", + "parameters": [ + { + "name": "value", + "type": "int" + } + ], + "isStatic": false, + "isVirtual": false, + "isPure": false, + "isConst": false } ], "isAbstract": false, @@ -32414,7 +33157,7 @@ { "kind": "method", "name": "getData", - "returnType": "ConstraintData &", + "returnType": "TransformConstraintData &", "parameters": [], "isStatic": false, "isVirtual": true, @@ -32522,6 +33265,16 @@ "SpineObject" ], "members": [ + { + "kind": "method", + "name": "getRTTI", + "returnType": "const RTTI &", + "parameters": [], + "isStatic": false, + "isVirtual": true, + "isPure": false, + "isConst": false + }, { "kind": "field", "name": "_offset", @@ -32581,13 +33334,23 @@ "name": "ToProperty", "kind": "class", "loc": { - "line": 66, + "line": 67, "col": 15 }, "superTypes": [ "SpineObject" ], "members": [ + { + "kind": "method", + "name": "getRTTI", + "returnType": "const RTTI &", + "parameters": [], + "isStatic": false, + "isVirtual": true, + "isPure": false, + "isConst": false + }, { "kind": "field", "name": "_offset", @@ -32676,13 +33439,23 @@ "name": "FromRotate", "kind": "class", "loc": { - "line": 89, + "line": 91, "col": 15 }, "superTypes": [ "FromProperty" ], "members": [ + { + "kind": "method", + "name": "getRTTI", + "returnType": "const RTTI &", + "parameters": [], + "isStatic": false, + "isVirtual": true, + "isPure": false, + "isConst": false + }, { "kind": "constructor", "name": "FromRotate", @@ -32730,13 +33503,23 @@ "name": "ToRotate", "kind": "class", "loc": { - "line": 97, + "line": 101, "col": 15 }, "superTypes": [ "ToProperty" ], "members": [ + { + "kind": "method", + "name": "getRTTI", + "returnType": "const RTTI &", + "parameters": [], + "isStatic": false, + "isVirtual": true, + "isPure": false, + "isConst": false + }, { "kind": "constructor", "name": "ToRotate", @@ -32807,13 +33590,23 @@ "name": "FromX", "kind": "class", "loc": { - "line": 106, + "line": 112, "col": 15 }, "superTypes": [ "FromProperty" ], "members": [ + { + "kind": "method", + "name": "getRTTI", + "returnType": "const RTTI &", + "parameters": [], + "isStatic": false, + "isVirtual": true, + "isPure": false, + "isConst": false + }, { "kind": "constructor", "name": "FromX", @@ -32861,13 +33654,23 @@ "name": "ToX", "kind": "class", "loc": { - "line": 114, + "line": 122, "col": 15 }, "superTypes": [ "ToProperty" ], "members": [ + { + "kind": "method", + "name": "getRTTI", + "returnType": "const RTTI &", + "parameters": [], + "isStatic": false, + "isVirtual": true, + "isPure": false, + "isConst": false + }, { "kind": "constructor", "name": "ToX", @@ -32938,13 +33741,23 @@ "name": "FromY", "kind": "class", "loc": { - "line": 123, + "line": 133, "col": 15 }, "superTypes": [ "FromProperty" ], "members": [ + { + "kind": "method", + "name": "getRTTI", + "returnType": "const RTTI &", + "parameters": [], + "isStatic": false, + "isVirtual": true, + "isPure": false, + "isConst": false + }, { "kind": "constructor", "name": "FromY", @@ -32992,13 +33805,23 @@ "name": "ToY", "kind": "class", "loc": { - "line": 131, + "line": 143, "col": 15 }, "superTypes": [ "ToProperty" ], "members": [ + { + "kind": "method", + "name": "getRTTI", + "returnType": "const RTTI &", + "parameters": [], + "isStatic": false, + "isVirtual": true, + "isPure": false, + "isConst": false + }, { "kind": "constructor", "name": "ToY", @@ -33069,13 +33892,23 @@ "name": "FromScaleX", "kind": "class", "loc": { - "line": 140, + "line": 154, "col": 15 }, "superTypes": [ "FromProperty" ], "members": [ + { + "kind": "method", + "name": "getRTTI", + "returnType": "const RTTI &", + "parameters": [], + "isStatic": false, + "isVirtual": true, + "isPure": false, + "isConst": false + }, { "kind": "constructor", "name": "FromScaleX", @@ -33123,13 +33956,23 @@ "name": "ToScaleX", "kind": "class", "loc": { - "line": 148, + "line": 164, "col": 15 }, "superTypes": [ "ToProperty" ], "members": [ + { + "kind": "method", + "name": "getRTTI", + "returnType": "const RTTI &", + "parameters": [], + "isStatic": false, + "isVirtual": true, + "isPure": false, + "isConst": false + }, { "kind": "constructor", "name": "ToScaleX", @@ -33200,13 +34043,23 @@ "name": "FromScaleY", "kind": "class", "loc": { - "line": 157, + "line": 175, "col": 15 }, "superTypes": [ "FromProperty" ], "members": [ + { + "kind": "method", + "name": "getRTTI", + "returnType": "const RTTI &", + "parameters": [], + "isStatic": false, + "isVirtual": true, + "isPure": false, + "isConst": false + }, { "kind": "constructor", "name": "FromScaleY", @@ -33254,13 +34107,23 @@ "name": "ToScaleY", "kind": "class", "loc": { - "line": 165, + "line": 185, "col": 15 }, "superTypes": [ "ToProperty" ], "members": [ + { + "kind": "method", + "name": "getRTTI", + "returnType": "const RTTI &", + "parameters": [], + "isStatic": false, + "isVirtual": true, + "isPure": false, + "isConst": false + }, { "kind": "constructor", "name": "ToScaleY", @@ -33331,13 +34194,23 @@ "name": "FromShearY", "kind": "class", "loc": { - "line": 174, + "line": 196, "col": 15 }, "superTypes": [ "FromProperty" ], "members": [ + { + "kind": "method", + "name": "getRTTI", + "returnType": "const RTTI &", + "parameters": [], + "isStatic": false, + "isVirtual": true, + "isPure": false, + "isConst": false + }, { "kind": "constructor", "name": "FromShearY", @@ -33385,13 +34258,23 @@ "name": "ToShearY", "kind": "class", "loc": { - "line": 182, + "line": 206, "col": 15 }, "superTypes": [ "ToProperty" ], "members": [ + { + "kind": "method", + "name": "getRTTI", + "returnType": "const RTTI &", + "parameters": [], + "isStatic": false, + "isVirtual": true, + "isPure": false, + "isConst": false + }, { "kind": "constructor", "name": "ToShearY", @@ -33462,7 +34345,7 @@ "name": "TransformConstraintData", "kind": "class", "loc": { - "line": 194, + "line": 220, "col": 15 }, "superTypes": [ @@ -33818,7 +34701,7 @@ }, { "kind": "method", - "name": "isSkinRequired", + "name": "getSkinRequired", "returnType": "bool", "parameters": [], "isStatic": false, diff --git a/spine-c/src/generated/animation_state.cpp b/spine-c/src/generated/animation_state.cpp index 880c35606..e35b7082e 100644 --- a/spine-c/src/generated/animation_state.cpp +++ b/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) { diff --git a/spine-c/src/generated/atlas_region.cpp b/spine-c/src/generated/atlas_region.cpp index 4dd0c5cce..dc02afbe1 100644 --- a/spine-c/src/generated/atlas_region.cpp +++ b/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*)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*)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*)value)); +} + +void spine_atlas_region_set_pads(spine_atlas_region self, spine_array_int value) { + ((AtlasRegion*)self)->setPads(*((const Array*)value)); } void spine_atlas_region_set_values(spine_atlas_region self, spine_array_float value) { - ((AtlasRegion*)self)->values = *((Array*)value); + ((AtlasRegion*)self)->setValues(*((const Array*)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); } diff --git a/spine-c/src/generated/atlas_region.h b/spine-c/src/generated/atlas_region.h index 1b307e7e8..5a2407bf3 100644 --- a/spine-c/src/generated/atlas_region.h +++ b/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 } diff --git a/spine-c/src/generated/bone_data.cpp b/spine-c/src/generated/bone_data.cpp index dd94369be..db8242992 100644 --- a/spine-c/src/generated/bone_data.cpp +++ b/spine-c/src/generated/bone_data.cpp @@ -55,8 +55,8 @@ const char* spine_bone_data_get_name(spine_bone_data self) { return ((PosedDataGeneric*)(BoneData*)self)->getName().buffer(); } -bool spine_bone_data_is_skin_required(spine_bone_data self) { - return ((PosedDataGeneric*)(BoneData*)self)->isSkinRequired(); +bool spine_bone_data_get_skin_required(spine_bone_data self) { + return ((PosedDataGeneric*)(BoneData*)self)->getSkinRequired(); } void spine_bone_data_set_skin_required(spine_bone_data self, bool skinRequired) { diff --git a/spine-c/src/generated/bone_data.h b/spine-c/src/generated/bone_data.h index 7ca342a90..c6a7b9191 100644 --- a/spine-c/src/generated/bone_data.h +++ b/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 diff --git a/spine-c/src/generated/constraint_data.cpp b/spine-c/src/generated/constraint_data.cpp index 6414b3dba..10d9284c7 100644 --- a/spine-c/src/generated/constraint_data.cpp +++ b/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) { diff --git a/spine-c/src/generated/constraint_data.h b/spine-c/src/generated/constraint_data.h index bd14a7c47..01f8be0ea 100644 --- a/spine-c/src/generated/constraint_data.h +++ b/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 diff --git a/spine-c/src/generated/event_data.cpp b/spine-c/src/generated/event_data.cpp index 21967b80e..158a89da4 100644 --- a/spine-c/src/generated/event_data.cpp +++ b/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) { diff --git a/spine-c/src/generated/event_data.h b/spine-c/src/generated/event_data.h index 6e5cbbf33..ace33b3e4 100644 --- a/spine-c/src/generated/event_data.h +++ b/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); diff --git a/spine-c/src/generated/from_property.cpp b/spine-c/src/generated/from_property.cpp index 0835a4838..93f18ac8c 100644 --- a/spine-c/src/generated/from_property.cpp +++ b/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; } diff --git a/spine-c/src/generated/from_property.h b/spine-c/src/generated/from_property.h index 6edc847d8..de8465667 100644 --- a/spine-c/src/generated/from_property.h +++ b/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); diff --git a/spine-c/src/generated/from_rotate.cpp b/spine-c/src/generated/from_rotate.cpp index a0b68b67c..d047f2291 100644 --- a/spine-c/src/generated/from_rotate.cpp +++ b/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; +} diff --git a/spine-c/src/generated/from_rotate.h b/spine-c/src/generated/from_rotate.h index 54aac3de5..b7dcab8b3 100644 --- a/spine-c/src/generated/from_rotate.h +++ b/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 } diff --git a/spine-c/src/generated/from_scale_x.cpp b/spine-c/src/generated/from_scale_x.cpp index 12c66a903..06581595a 100644 --- a/spine-c/src/generated/from_scale_x.cpp +++ b/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; +} diff --git a/spine-c/src/generated/from_scale_x.h b/spine-c/src/generated/from_scale_x.h index 968ac8fcc..9fa705f99 100644 --- a/spine-c/src/generated/from_scale_x.h +++ b/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 } diff --git a/spine-c/src/generated/from_scale_y.cpp b/spine-c/src/generated/from_scale_y.cpp index a849e9c00..e5e036dd7 100644 --- a/spine-c/src/generated/from_scale_y.cpp +++ b/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; +} diff --git a/spine-c/src/generated/from_scale_y.h b/spine-c/src/generated/from_scale_y.h index a4cd071d7..354debef8 100644 --- a/spine-c/src/generated/from_scale_y.h +++ b/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 } diff --git a/spine-c/src/generated/from_shear_y.cpp b/spine-c/src/generated/from_shear_y.cpp index 4dd5a0701..2468199ac 100644 --- a/spine-c/src/generated/from_shear_y.cpp +++ b/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; +} diff --git a/spine-c/src/generated/from_shear_y.h b/spine-c/src/generated/from_shear_y.h index 064a35ec5..6419b89a2 100644 --- a/spine-c/src/generated/from_shear_y.h +++ b/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 } diff --git a/spine-c/src/generated/from_x.cpp b/spine-c/src/generated/from_x.cpp index bdb3f0224..267553452 100644 --- a/spine-c/src/generated/from_x.cpp +++ b/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; +} diff --git a/spine-c/src/generated/from_x.h b/spine-c/src/generated/from_x.h index 3c18c5ee5..d7fa37e20 100644 --- a/spine-c/src/generated/from_x.h +++ b/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 } diff --git a/spine-c/src/generated/from_y.cpp b/spine-c/src/generated/from_y.cpp index dcc6c2956..fba4ea8c8 100644 --- a/spine-c/src/generated/from_y.cpp +++ b/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; +} diff --git a/spine-c/src/generated/from_y.h b/spine-c/src/generated/from_y.h index 5b0f0ada8..315d946f4 100644 --- a/spine-c/src/generated/from_y.h +++ b/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 } diff --git a/spine-c/src/generated/ik_constraint_data.cpp b/spine-c/src/generated/ik_constraint_data.cpp index 67927016d..d7ca55c79 100644 --- a/spine-c/src/generated/ik_constraint_data.cpp +++ b/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*)(IkConstraintData*)self)->getName().buffer(); } -bool spine_ik_constraint_data_is_skin_required(spine_ik_constraint_data self) { - return ((ConstraintDataGeneric*)(IkConstraintData*)self)->isSkinRequired(); +bool spine_ik_constraint_data_get_skin_required(spine_ik_constraint_data self) { + return ((ConstraintDataGeneric*)(IkConstraintData*)self)->getSkinRequired(); } spine_ik_constraint_pose spine_ik_constraint_data_get_setup_pose(spine_ik_constraint_data self) { diff --git a/spine-c/src/generated/ik_constraint_data.h b/spine-c/src/generated/ik_constraint_data.h index 8051a90c7..19417c9ec 100644 --- a/spine-c/src/generated/ik_constraint_data.h +++ b/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); diff --git a/spine-c/src/generated/path_attachment.cpp b/spine-c/src/generated/path_attachment.cpp index b9d078ed5..9a1bf31f3 100644 --- a/spine-c/src/generated/path_attachment.cpp +++ b/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*)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) { diff --git a/spine-c/src/generated/path_attachment.h b/spine-c/src/generated/path_attachment.h index fe20c0cb7..52258f29a 100644 --- a/spine-c/src/generated/path_attachment.h +++ b/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); diff --git a/spine-c/src/generated/path_constraint_data.cpp b/spine-c/src/generated/path_constraint_data.cpp index f6300fda5..0adde3a1a 100644 --- a/spine-c/src/generated/path_constraint_data.cpp +++ b/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*)(PathConstraintData*)self)->getName().buffer(); } -bool spine_path_constraint_data_is_skin_required(spine_path_constraint_data self) { - return ((ConstraintDataGeneric*)(PathConstraintData*)self)->isSkinRequired(); +bool spine_path_constraint_data_get_skin_required(spine_path_constraint_data self) { + return ((ConstraintDataGeneric*)(PathConstraintData*)self)->getSkinRequired(); } spine_path_constraint_pose spine_path_constraint_data_get_setup_pose(spine_path_constraint_data self) { diff --git a/spine-c/src/generated/path_constraint_data.h b/spine-c/src/generated/path_constraint_data.h index 349f4e51f..ff57abdea 100644 --- a/spine-c/src/generated/path_constraint_data.h +++ b/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); diff --git a/spine-c/src/generated/physics_constraint.cpp b/spine-c/src/generated/physics_constraint.cpp index 9089b0b40..962c59d43 100644 --- a/spine-c/src/generated/physics_constraint.cpp +++ b/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*)self)->getData(); +spine_physics_constraint_data spine_physics_constraint_get_data(spine_physics_constraint self) { + return (spine_physics_constraint_data)&((ConstraintGeneric*)(PhysicsConstraint*)self)->getData(); } spine_physics_constraint_pose spine_physics_constraint_get_pose(spine_physics_constraint self) { diff --git a/spine-c/src/generated/physics_constraint.h b/spine-c/src/generated/physics_constraint.h index 36559646c..d212ca63d 100644 --- a/spine-c/src/generated/physics_constraint.h +++ b/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); diff --git a/spine-c/src/generated/physics_constraint_data.cpp b/spine-c/src/generated/physics_constraint_data.cpp index 54d4ac009..d2fc072fc 100644 --- a/spine-c/src/generated/physics_constraint_data.cpp +++ b/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*)(PhysicsConstraintData*)self)->getName().buffer(); } -bool spine_physics_constraint_data_is_skin_required(spine_physics_constraint_data self) { - return ((ConstraintDataGeneric*)(PhysicsConstraintData*)self)->isSkinRequired(); +bool spine_physics_constraint_data_get_skin_required(spine_physics_constraint_data self) { + return ((ConstraintDataGeneric*)(PhysicsConstraintData*)self)->getSkinRequired(); } spine_physics_constraint_pose spine_physics_constraint_data_get_setup_pose(spine_physics_constraint_data self) { diff --git a/spine-c/src/generated/physics_constraint_data.h b/spine-c/src/generated/physics_constraint_data.h index 2d6bdc519..afc02ebc7 100644 --- a/spine-c/src/generated/physics_constraint_data.h +++ b/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); diff --git a/spine-c/src/generated/posed_data.cpp b/spine-c/src/generated/posed_data.cpp index 8df5da80b..db5345516 100644 --- a/spine-c/src/generated/posed_data.cpp +++ b/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) { diff --git a/spine-c/src/generated/posed_data.h b/spine-c/src/generated/posed_data.h index 16fb54a4e..9739d687d 100644 --- a/spine-c/src/generated/posed_data.h +++ b/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 diff --git a/spine-c/src/generated/slider.cpp b/spine-c/src/generated/slider.cpp index 7c96040f7..e0b9f05ab 100644 --- a/spine-c/src/generated/slider.cpp +++ b/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*)self)->getData(); +spine_slider_data spine_slider_get_data(spine_slider self) { + return (spine_slider_data)&((ConstraintGeneric*)(Slider*)self)->getData(); } spine_slider_pose spine_slider_get_pose(spine_slider self) { diff --git a/spine-c/src/generated/slider.h b/spine-c/src/generated/slider.h index cced1a27a..54ed24c87 100644 --- a/spine-c/src/generated/slider.h +++ b/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); diff --git a/spine-c/src/generated/slider_data.cpp b/spine-c/src/generated/slider_data.cpp index 8d1a41c58..32e8c87b4 100644 --- a/spine-c/src/generated/slider_data.cpp +++ b/spine-c/src/generated/slider_data.cpp @@ -87,8 +87,8 @@ const char* spine_slider_data_get_name(spine_slider_data self) { return ((ConstraintDataGeneric*)(SliderData*)self)->getName().buffer(); } -bool spine_slider_data_is_skin_required(spine_slider_data self) { - return ((ConstraintDataGeneric*)(SliderData*)self)->isSkinRequired(); +bool spine_slider_data_get_skin_required(spine_slider_data self) { + return ((ConstraintDataGeneric*)(SliderData*)self)->getSkinRequired(); } spine_slider_pose spine_slider_data_get_setup_pose(spine_slider_data self) { diff --git a/spine-c/src/generated/slider_data.h b/spine-c/src/generated/slider_data.h index 45973dcd7..39b347359 100644 --- a/spine-c/src/generated/slider_data.h +++ b/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); diff --git a/spine-c/src/generated/slot_data.cpp b/spine-c/src/generated/slot_data.cpp index 81b400680..6e529292a 100644 --- a/spine-c/src/generated/slot_data.cpp +++ b/spine-c/src/generated/slot_data.cpp @@ -51,8 +51,8 @@ const char* spine_slot_data_get_name(spine_slot_data self) { return ((PosedDataGeneric*)(SlotData*)self)->getName().buffer(); } -bool spine_slot_data_is_skin_required(spine_slot_data self) { - return ((PosedDataGeneric*)(SlotData*)self)->isSkinRequired(); +bool spine_slot_data_get_skin_required(spine_slot_data self) { + return ((PosedDataGeneric*)(SlotData*)self)->getSkinRequired(); } void spine_slot_data_set_skin_required(spine_slot_data self, bool skinRequired) { diff --git a/spine-c/src/generated/slot_data.h b/spine-c/src/generated/slot_data.h index ad879f26c..61bb2075c 100644 --- a/spine-c/src/generated/slot_data.h +++ b/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 diff --git a/spine-c/src/generated/texture_region.cpp b/spine-c/src/generated/texture_region.cpp index f5eeb2c49..67fcf2d84 100644 --- a/spine-c/src/generated/texture_region.cpp +++ b/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); } diff --git a/spine-c/src/generated/texture_region.h b/spine-c/src/generated/texture_region.h index 2300b3394..cfd52dc5d 100644 --- a/spine-c/src/generated/texture_region.h +++ b/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); diff --git a/spine-c/src/generated/to_property.cpp b/spine-c/src/generated/to_property.cpp index 944bb48d6..3c9f98801 100644 --- a/spine-c/src/generated/to_property.cpp +++ b/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; } diff --git a/spine-c/src/generated/to_property.h b/spine-c/src/generated/to_property.h index f36bca630..d069fda1f 100644 --- a/spine-c/src/generated/to_property.h +++ b/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); diff --git a/spine-c/src/generated/to_rotate.cpp b/spine-c/src/generated/to_rotate.cpp index 54e73f981..c83014638 100644 --- a/spine-c/src/generated/to_rotate.cpp +++ b/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; +} diff --git a/spine-c/src/generated/to_rotate.h b/spine-c/src/generated/to_rotate.h index e4e5a5c43..39bffc098 100644 --- a/spine-c/src/generated/to_rotate.h +++ b/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 } diff --git a/spine-c/src/generated/to_scale_x.cpp b/spine-c/src/generated/to_scale_x.cpp index c091a08fd..26aed2ec5 100644 --- a/spine-c/src/generated/to_scale_x.cpp +++ b/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; +} diff --git a/spine-c/src/generated/to_scale_x.h b/spine-c/src/generated/to_scale_x.h index edf0c91d6..934f464d9 100644 --- a/spine-c/src/generated/to_scale_x.h +++ b/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 } diff --git a/spine-c/src/generated/to_scale_y.cpp b/spine-c/src/generated/to_scale_y.cpp index 6d52769d1..95e3a81c3 100644 --- a/spine-c/src/generated/to_scale_y.cpp +++ b/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; +} diff --git a/spine-c/src/generated/to_scale_y.h b/spine-c/src/generated/to_scale_y.h index 4959b4925..8313bf3cd 100644 --- a/spine-c/src/generated/to_scale_y.h +++ b/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 } diff --git a/spine-c/src/generated/to_shear_y.cpp b/spine-c/src/generated/to_shear_y.cpp index b3d38718b..526b0a82f 100644 --- a/spine-c/src/generated/to_shear_y.cpp +++ b/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; +} diff --git a/spine-c/src/generated/to_shear_y.h b/spine-c/src/generated/to_shear_y.h index 64bc6e3b3..80318bba5 100644 --- a/spine-c/src/generated/to_shear_y.h +++ b/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 } diff --git a/spine-c/src/generated/to_x.cpp b/spine-c/src/generated/to_x.cpp index 20ebca23b..ae555fa68 100644 --- a/spine-c/src/generated/to_x.cpp +++ b/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; +} diff --git a/spine-c/src/generated/to_x.h b/spine-c/src/generated/to_x.h index b45ca8b60..885cad844 100644 --- a/spine-c/src/generated/to_x.h +++ b/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 } diff --git a/spine-c/src/generated/to_y.cpp b/spine-c/src/generated/to_y.cpp index 02e2e0ec3..ab4f09614 100644 --- a/spine-c/src/generated/to_y.cpp +++ b/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; +} diff --git a/spine-c/src/generated/to_y.h b/spine-c/src/generated/to_y.h index 264c7f7af..407ee3d9c 100644 --- a/spine-c/src/generated/to_y.h +++ b/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 } diff --git a/spine-c/src/generated/transform_constraint.cpp b/spine-c/src/generated/transform_constraint.cpp index 0bb97597d..65d573fd7 100644 --- a/spine-c/src/generated/transform_constraint.cpp +++ b/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*)self)->getData(); +spine_transform_constraint_data spine_transform_constraint_get_data(spine_transform_constraint self) { + return (spine_transform_constraint_data)&((ConstraintGeneric*)(TransformConstraint*)self)->getData(); } spine_transform_constraint_pose spine_transform_constraint_get_pose(spine_transform_constraint self) { diff --git a/spine-c/src/generated/transform_constraint.h b/spine-c/src/generated/transform_constraint.h index 547af06b7..1edb56422 100644 --- a/spine-c/src/generated/transform_constraint.h +++ b/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); diff --git a/spine-c/src/generated/transform_constraint_data.cpp b/spine-c/src/generated/transform_constraint_data.cpp index 7cd9e6d8c..bb83cfd64 100644 --- a/spine-c/src/generated/transform_constraint_data.cpp +++ b/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*)(TransformConstraintData*)self)->getName().buffer(); } -bool spine_transform_constraint_data_is_skin_required(spine_transform_constraint_data self) { - return ((ConstraintDataGeneric*)(TransformConstraintData*)self)->isSkinRequired(); +bool spine_transform_constraint_data_get_skin_required(spine_transform_constraint_data self) { + return ((ConstraintDataGeneric*)(TransformConstraintData*)self)->getSkinRequired(); } spine_transform_constraint_pose spine_transform_constraint_data_get_setup_pose(spine_transform_constraint_data self) { diff --git a/spine-c/src/generated/transform_constraint_data.h b/spine-c/src/generated/transform_constraint_data.h index 10ed79be2..6616a36ef 100644 --- a/spine-c/src/generated/transform_constraint_data.h +++ b/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); diff --git a/spine-cpp/include/spine/Atlas.h b/spine-cpp/include/spine/Atlas.h index 3a847e0ea..affcad488 100644 --- a/spine-cpp/include/spine/Atlas.h +++ b/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 splits; - Array pads; - Array names; - Array 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 &getSplits() { return _splits; } + Array &getPads() { return _pads; } + Array &getNames() { return _names; } + Array &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 &value) { _splits = value; } + void setPads(const Array &value) { _pads = value; } + void setNames(const Array &value) { _names = value; } + void setValues(const Array &value) { _values = value; } + private: + AtlasPage *_page; + String _name; + int _index; + int _x, _y; + Array _splits; + Array _pads; + Array _names; + Array _values; }; class TextureLoader; diff --git a/spine-cpp/include/spine/TextureRegion.h b/spine-cpp/include/spine/TextureRegion.h index ea065fae2..36e46282a 100644 --- a/spine-cpp/include/spine/TextureRegion.h +++ b/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; }; } diff --git a/spine-cpp/src/spine/Atlas.cpp b/spine-cpp/src/spine/Atlas.cpp index 41fa1d5fb..61aee794f 100644 --- a/spine-cpp/src/spine/Atlas.cpp +++ b/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 ®ion = *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); } diff --git a/spine-cpp/src/spine/MeshAttachment.cpp b/spine-cpp/src/spine/MeshAttachment.cpp index 95f878a61..565203be8 100644 --- a/spine-cpp/src/spine/MeshAttachment.cpp +++ b/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; diff --git a/spine-cpp/src/spine/RegionAttachment.cpp b/spine-cpp/src/spine/RegionAttachment.cpp index cd5770e27..6e2a2d969 100644 --- a/spine-cpp/src/spine/RegionAttachment.cpp +++ b/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; } } diff --git a/spine-cpp/src/spine/SkeletonRenderer.cpp b/spine-cpp/src/spine/SkeletonRenderer.cpp index 349c060bb..c500a6fc1 100644 --- a/spine-cpp/src/spine/SkeletonRenderer.cpp +++ b/spine-cpp/src/spine/SkeletonRenderer.cpp @@ -182,7 +182,7 @@ RenderCommand *SkeletonRenderer::render(Skeleton &skeleton) { uvs = ®ionAttachment->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();