UnityMirror/spine-runtimes
1
0
Fork 0
mirror of https://github.com/EsotericSoftware/spine-runtimes.git synced 2026-02-19 00:06:42 +08:00
Code Issues Packages Projects Releases Wiki Activity

[formatters] C/C++ formatting

Browse Source
This commit is contained in:
Mario Zechner 2025-07-15 22:56:12 +02:00
parent 587124b66b
commit b544dd99ed
494 changed files with 15243 additions and 12242 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
formatters/.clang-format
View File

@ -8,11 +8,11 @@ AlignOperands: DontAlign
AllowAllArgumentsOnNextLine: true
AllowAllConstructorInitializersOnNextLine: false
AllowAllParametersOfDeclarationOnNextLine: true
AllowShortBlocksOnASingleLine: Always
AllowShortBlocksOnASingleLine: Never
AllowShortCaseLabelsOnASingleLine: false
AllowShortEnumsOnASingleLine: false
AllowShortFunctionsOnASingleLine: All
AllowShortIfStatementsOnASingleLine: Always
AllowShortFunctionsOnASingleLine: None
AllowShortIfStatementsOnASingleLine: WithoutElse
AllowShortLambdasOnASingleLine: All
AllowShortLoopsOnASingleLine: true
AlwaysBreakAfterReturnType: None
@ -39,13 +39,13 @@ BreakBeforeTernaryOperators: true
BreakAfterJavaFieldAnnotations: false
PenaltyBreakBeforeFirstCallParameter: 200
PenaltyBreakAssignment: 1000
PenaltyBreakFirstLessLess: 120
PenaltyBreakFirstLessLess: 150
PenaltyExcessCharacter: 1000000
PenaltyBreakString: 1000
PenaltyReturnTypeOnItsOwnLine: 1000000
BreakConstructorInitializers: BeforeColon
BreakInheritanceList: BeforeColon
ColumnLimit: 120
ColumnLimit: 150
CompactNamespaces: false
ContinuationIndentWidth: 4
DerivePointerAlignment: false

2
spine-c/include/spine-c.h
View File

@ -166,4 +166,4 @@
#include "../src/generated/update.h"
#include "../src/generated/vertex_attachment.h"
#endif // SPINE_C_H
#endif// SPINE_C_H

12
spine-c/src/base.h
View File

@ -56,12 +56,12 @@
#endif
#endif
#define SPINE_OPAQUE_TYPE(name) \
typedef struct name##_wrapper { \
char _dummy; \
} name##_wrapper; \
typedef name##_wrapper *name;
#define SPINE_OPAQUE_TYPE(name) \
typedef struct name##_wrapper { \
char _dummy; \
} name##_wrapper; \
typedef name##_wrapper *name;
typedef long long spine_property_id;
#endif // SPINE_C_BASE_H
#endif// SPINE_C_BASE_H

518
spine-c/src/extensions.cpp
View File

@ -41,60 +41,60 @@ using namespace spine;
// Internal structures
struct _spine_atlas {
void *atlas;
const char **imagePaths;
int32_t numImagePaths;
const char *error;
void *atlas;
const char **imagePaths;
int32_t numImagePaths;
const char *error;
};
struct _spine_skeleton_data_result {
spine_skeleton_data skeletonData;
const char *error;
spine_skeleton_data skeletonData;
const char *error;
};
struct _spine_bounds {
float x, y, width, height;
float x, y, width, height;
};
struct _spine_vector {
float x, y;
float x, y;
};
struct _spine_skeleton_drawable : public SpineObject {
spine_skeleton skeleton;
spine_animation_state animationState;
spine_animation_state_data animationStateData;
spine_animation_state_events animationStateEvents;
SkeletonRenderer *renderer;
spine_skeleton skeleton;
spine_animation_state animationState;
spine_animation_state_data animationStateData;
spine_animation_state_events animationStateEvents;
SkeletonRenderer *renderer;
};
struct _spine_skin_entry {
int32_t slotIndex;
const char *name;
spine_attachment attachment;
int32_t slotIndex;
const char *name;
spine_attachment attachment;
};
struct _spine_skin_entries {
int32_t numEntries;
_spine_skin_entry *entries;
int32_t numEntries;
_spine_skin_entry *entries;
};
// Animation state event tracking
struct AnimationStateEvent {
EventType type;
TrackEntry *entry;
Event *event;
AnimationStateEvent(EventType type, TrackEntry *entry, Event *event) : type(type), entry(entry), event(event){};
EventType type;
TrackEntry *entry;
Event *event;
AnimationStateEvent(EventType type, TrackEntry *entry, Event *event) : type(type), entry(entry), event(event) {};
};
class EventListener : public AnimationStateListenerObject, public SpineObject {
public:
Array<AnimationStateEvent> events;
Array<AnimationStateEvent> events;
void callback(AnimationState *state, EventType type, TrackEntry *entry, Event *event) override {
events.add(AnimationStateEvent(type, entry, event));
SP_UNUSED(state);
}
void callback(AnimationState *state, EventType type, TrackEntry *entry, Event *event) override {
events.add(AnimationStateEvent(type, entry, event));
SP_UNUSED(state);
}
};
// Static variables
@ -103,385 +103,385 @@ static SpineExtension *defaultExtension = nullptr;
static DebugExtension *debugExtension = nullptr;
static void initExtensions() {
if (defaultExtension == nullptr) {
defaultExtension = new DefaultSpineExtension();
debugExtension = new DebugExtension(defaultExtension);
}
if (defaultExtension == nullptr) {
defaultExtension = new DefaultSpineExtension();
debugExtension = new DebugExtension(defaultExtension);
}
}
namespace spine {
SpineExtension *getDefaultExtension() {
initExtensions();
return defaultExtension;
}
SpineExtension *getDefaultExtension() {
initExtensions();
return defaultExtension;
}
}
// Version functions
int32_t spine_major_version() {
return SPINE_MAJOR_VERSION;
return SPINE_MAJOR_VERSION;
}
int32_t spine_minor_version() {
return SPINE_MINOR_VERSION;
return SPINE_MINOR_VERSION;
}
void spine_enable_debug_extension(bool enable) {
initExtensions();
SpineExtension::setInstance(enable ? debugExtension : defaultExtension);
initExtensions();
SpineExtension::setInstance(enable ? debugExtension : defaultExtension);
}
void spine_report_leaks() {
initExtensions();
debugExtension->reportLeaks();
fflush(stdout);
initExtensions();
debugExtension->reportLeaks();
fflush(stdout);
}
// Bounds functions
float spine_bounds_get_x(spine_bounds bounds) {
if (!bounds) return 0;
return ((_spine_bounds *) bounds)->x;
if (!bounds) return 0;
return ((_spine_bounds *) bounds)->x;
}
float spine_bounds_get_y(spine_bounds bounds) {
if (!bounds) return 0;
return ((_spine_bounds *) bounds)->y;
if (!bounds) return 0;
return ((_spine_bounds *) bounds)->y;
}
float spine_bounds_get_width(spine_bounds bounds) {
if (!bounds) return 0;
return ((_spine_bounds *) bounds)->width;
if (!bounds) return 0;
return ((_spine_bounds *) bounds)->width;
}
float spine_bounds_get_height(spine_bounds bounds) {
if (!bounds) return 0;
return ((_spine_bounds *) bounds)->height;
if (!bounds) return 0;
return ((_spine_bounds *) bounds)->height;
}
// Vector functions
float spine_vector_get_x(spine_vector vector) {
if (!vector) return 0;
return ((_spine_vector *) vector)->x;
if (!vector) return 0;
return ((_spine_vector *) vector)->x;
}
float spine_vector_get_y(spine_vector vector) {
if (!vector) return 0;
return ((_spine_vector *) vector)->y;
if (!vector) return 0;
return ((_spine_vector *) vector)->y;
}
// Atlas functions
class LiteTextureLoad : public TextureLoader {
void load(AtlasPage &page, const String &path) {
page.texture = (void *) (intptr_t) page.index;
}
void load(AtlasPage &page, const String &path) {
page.texture = (void *) (intptr_t) page.index;
}
void unload(void *texture) {
}
void unload(void *texture) {
}
};
static LiteTextureLoad liteLoader;
spine_atlas spine_atlas_load(const char *atlasData) {
if (!atlasData) return nullptr;
int32_t length = (int32_t) strlen(atlasData);
auto atlas = new (__FILE__, __LINE__) Atlas(atlasData, length, "", &liteLoader, true);
_spine_atlas *result = SpineExtension::calloc<_spine_atlas>(1, __FILE__, __LINE__);
result->atlas = atlas;
result->numImagePaths = (int32_t) atlas->getPages().size();
result->imagePaths = SpineExtension::calloc<const char *>(result->numImagePaths, __FILE__, __LINE__);
for (int i = 0; i < result->numImagePaths; i++) {
result->imagePaths[i] = atlas->getPages()[i]->texturePath.buffer();
}
return (spine_atlas) result;
if (!atlasData) return nullptr;
int32_t length = (int32_t) strlen(atlasData);
auto atlas = new (__FILE__, __LINE__) Atlas(atlasData, length, "", &liteLoader, true);
_spine_atlas *result = SpineExtension::calloc<_spine_atlas>(1, __FILE__, __LINE__);
result->atlas = atlas;
result->numImagePaths = (int32_t) atlas->getPages().size();
result->imagePaths = SpineExtension::calloc<const char *>(result->numImagePaths, __FILE__, __LINE__);
for (int i = 0; i < result->numImagePaths; i++) {
result->imagePaths[i] = atlas->getPages()[i]->texturePath.buffer();
}
return (spine_atlas) result;
}
class CallbackTextureLoad : public TextureLoader {
spine_texture_loader_load_func loadCb;
spine_texture_loader_unload_func unloadCb;
spine_texture_loader_load_func loadCb;
spine_texture_loader_unload_func unloadCb;
public:
CallbackTextureLoad() : loadCb(nullptr), unloadCb(nullptr) {}
CallbackTextureLoad() : loadCb(nullptr), unloadCb(nullptr) {
}
void setCallbacks(spine_texture_loader_load_func load, spine_texture_loader_unload_func unload) {
loadCb = load;
unloadCb = unload;
}
void setCallbacks(spine_texture_loader_load_func load, spine_texture_loader_unload_func unload) {
loadCb = load;
unloadCb = unload;
}
void load(AtlasPage &page, const String &path) {
page.texture = this->loadCb(path.buffer());
}
void load(AtlasPage &page, const String &path) {
page.texture = this->loadCb(path.buffer());
}
void unload(void *texture) {
this->unloadCb(texture);
}
void unload(void *texture) {
this->unloadCb(texture);
}
};
static CallbackTextureLoad callbackLoader;
spine_atlas spine_atlas_load_callback(const char *atlasData, const char *atlasDir,
spine_texture_loader_load_func load,
spine_texture_loader_unload_func unload) {
if (!atlasData) return nullptr;
int32_t length = (int32_t) strlen(atlasData);
callbackLoader.setCallbacks(load, unload);
auto atlas = new (__FILE__, __LINE__) Atlas(atlasData, length, (const char *) atlasDir, &callbackLoader, true);
_spine_atlas *result = SpineExtension::calloc<_spine_atlas>(1, __FILE__, __LINE__);
result->atlas = atlas;
result->numImagePaths = (int32_t) atlas->getPages().size();
result->imagePaths = SpineExtension::calloc<const char *>(result->numImagePaths, __FILE__, __LINE__);
for (int i = 0; i < result->numImagePaths; i++) {
result->imagePaths[i] = atlas->getPages()[i]->texturePath.buffer();
}
return (spine_atlas) result;
spine_atlas spine_atlas_load_callback(const char *atlasData, const char *atlasDir, spine_texture_loader_load_func load,
spine_texture_loader_unload_func unload) {
if (!atlasData) return nullptr;
int32_t length = (int32_t) strlen(atlasData);
callbackLoader.setCallbacks(load, unload);
auto atlas = new (__FILE__, __LINE__) Atlas(atlasData, length, (const char *) atlasDir, &callbackLoader, true);
_spine_atlas *result = SpineExtension::calloc<_spine_atlas>(1, __FILE__, __LINE__);
result->atlas = atlas;
result->numImagePaths = (int32_t) atlas->getPages().size();
result->imagePaths = SpineExtension::calloc<const char *>(result->numImagePaths, __FILE__, __LINE__);
for (int i = 0; i < result->numImagePaths; i++) {
result->imagePaths[i] = atlas->getPages()[i]->texturePath.buffer();
}
return (spine_atlas) result;
}
int32_t spine_atlas_get_num_image_paths(spine_atlas atlas) {
if (!atlas) return 0;
return ((_spine_atlas *) atlas)->numImagePaths;
if (!atlas) return 0;
return ((_spine_atlas *) atlas)->numImagePaths;
}
const char *spine_atlas_get_image_path(spine_atlas atlas, int32_t index) {
if (!atlas) return nullptr;
_spine_atlas *_atlas = (_spine_atlas *) atlas;
if (index < 0 || index >= _atlas->numImagePaths) return nullptr;
return _atlas->imagePaths[index];
if (!atlas) return nullptr;
_spine_atlas *_atlas = (_spine_atlas *) atlas;
if (index < 0 || index >= _atlas->numImagePaths) return nullptr;
return _atlas->imagePaths[index];
}
bool spine_atlas_is_pma(spine_atlas atlas) {
if (!atlas) return false;
Atlas *_atlas = (Atlas *) ((_spine_atlas *) atlas)->atlas;
for (size_t i = 0; i < _atlas->getPages().size(); i++) {
AtlasPage *page = _atlas->getPages()[i];
if (page->pma) return true;
}
return false;
if (!atlas) return false;
Atlas *_atlas = (Atlas *) ((_spine_atlas *) atlas)->atlas;
for (size_t i = 0; i < _atlas->getPages().size(); i++) {
AtlasPage *page = _atlas->getPages()[i];
if (page->pma) return true;
}
return false;
}
const char *spine_atlas_get_error(spine_atlas atlas) {
if (!atlas) return nullptr;
return ((_spine_atlas *) atlas)->error;
if (!atlas) return nullptr;
return ((_spine_atlas *) atlas)->error;
}
void spine_atlas_dispose(spine_atlas atlas) {
if (!atlas) return;
_spine_atlas *_atlas = (_spine_atlas *) atlas;
if (_atlas->atlas) {
delete (Atlas *) _atlas->atlas;
}
if (_atlas->imagePaths) {
SpineExtension::free(_atlas->imagePaths, __FILE__, __LINE__);
}
if (_atlas->error) {
SpineExtension::free(_atlas->error, __FILE__, __LINE__);
}
SpineExtension::free(_atlas, __FILE__, __LINE__);
if (!atlas) return;
_spine_atlas *_atlas = (_spine_atlas *) atlas;
if (_atlas->atlas) {
delete (Atlas *) _atlas->atlas;
}
if (_atlas->imagePaths) {
SpineExtension::free(_atlas->imagePaths, __FILE__, __LINE__);
}
if (_atlas->error) {
SpineExtension::free(_atlas->error, __FILE__, __LINE__);
}
SpineExtension::free(_atlas, __FILE__, __LINE__);
}
// Skeleton data loading
spine_skeleton_data_result spine_skeleton_data_load_json(spine_atlas atlas, const char *skeletonData, const char *path) {
if (!atlas || !skeletonData) return nullptr;
_spine_skeleton_data_result *result = SpineExtension::calloc<_spine_skeleton_data_result>(1, __FILE__, __LINE__);
SkeletonJson json((Atlas *) ((_spine_atlas *) atlas)->atlas);
json.setScale(1);
if (!atlas || !skeletonData) return nullptr;
_spine_skeleton_data_result *result = SpineExtension::calloc<_spine_skeleton_data_result>(1, __FILE__, __LINE__);
SkeletonJson json((Atlas *) ((_spine_atlas *) atlas)->atlas);
json.setScale(1);
SkeletonData *data = json.readSkeletonData(skeletonData);
if (!data) {
result->error = (const char *) strdup("Failed to load skeleton data");
return (spine_skeleton_data_result) result;
}
SkeletonData *data = json.readSkeletonData(skeletonData);
if (!data) {
result->error = (const char *) strdup("Failed to load skeleton data");
return (spine_skeleton_data_result) result;
}
// Set name from path if provided
if (path != nullptr && data != nullptr) {
String pathStr(path);
// Set name from path if provided
if (path != nullptr && data != nullptr) {
String pathStr(path);
// Extract filename without extension from path
int lastSlash = pathStr.lastIndexOf('/');
int lastBackslash = pathStr.lastIndexOf('\\');
int start = 0;
// Extract filename without extension from path
int lastSlash = pathStr.lastIndexOf('/');
int lastBackslash = pathStr.lastIndexOf('\\');
int start = 0;
if (lastSlash != -1) start = lastSlash + 1;
if (lastBackslash != -1 && lastBackslash > start) start = lastBackslash + 1;
if (lastSlash != -1) start = lastSlash + 1;
if (lastBackslash != -1 && lastBackslash > start) start = lastBackslash + 1;
int lastDot = pathStr.lastIndexOf('.');
if (lastDot != -1 && lastDot > start) {
data->setName(pathStr.substring(start, lastDot - start));
} else {
data->setName(pathStr.substring(start));
}
}
int lastDot = pathStr.lastIndexOf('.');
if (lastDot != -1 && lastDot > start) {
data->setName(pathStr.substring(start, lastDot - start));
} else {
data->setName(pathStr.substring(start));
}
}
result->skeletonData = (spine_skeleton_data) data;
return (spine_skeleton_data_result) result;
result->skeletonData = (spine_skeleton_data) data;
return (spine_skeleton_data_result) result;
}
spine_skeleton_data_result spine_skeleton_data_load_binary(spine_atlas atlas, const uint8_t *skeletonData, int32_t length, const char *path) {
if (!atlas || !skeletonData) return nullptr;
_spine_skeleton_data_result *result = SpineExtension::calloc<_spine_skeleton_data_result>(1, __FILE__, __LINE__);
SkeletonBinary binary((Atlas *) ((_spine_atlas *) atlas)->atlas);
binary.setScale(1);
if (!atlas || !skeletonData) return nullptr;
_spine_skeleton_data_result *result = SpineExtension::calloc<_spine_skeleton_data_result>(1, __FILE__, __LINE__);
SkeletonBinary binary((Atlas *) ((_spine_atlas *) atlas)->atlas);
binary.setScale(1);
SkeletonData *data = binary.readSkeletonData((const unsigned char *) skeletonData, length);
if (!data) {
result->error = (const char *) strdup("Failed to load skeleton data");
return (spine_skeleton_data_result) result;
}
SkeletonData *data = binary.readSkeletonData((const unsigned char *) skeletonData, length);
if (!data) {
result->error = (const char *) strdup("Failed to load skeleton data");
return (spine_skeleton_data_result) result;
}
// Set name from path if provided
if (path != nullptr && data != nullptr) {
String pathStr(path);
// Set name from path if provided
if (path != nullptr && data != nullptr) {
String pathStr(path);
// Extract filename without extension from path
int lastSlash = pathStr.lastIndexOf('/');
int lastBackslash = pathStr.lastIndexOf('\\');
int start = 0;
// Extract filename without extension from path
int lastSlash = pathStr.lastIndexOf('/');
int lastBackslash = pathStr.lastIndexOf('\\');
int start = 0;
if (lastSlash != -1) start = lastSlash + 1;
if (lastBackslash != -1 && lastBackslash > start) start = lastBackslash + 1;
if (lastSlash != -1) start = lastSlash + 1;
if (lastBackslash != -1 && lastBackslash > start) start = lastBackslash + 1;
int lastDot = pathStr.lastIndexOf('.');
if (lastDot != -1 && lastDot > start) {
data->setName(pathStr.substring(start, lastDot - start));
} else {
data->setName(pathStr.substring(start));
}
}
int lastDot = pathStr.lastIndexOf('.');
if (lastDot != -1 && lastDot > start) {
data->setName(pathStr.substring(start, lastDot - start));
} else {
data->setName(pathStr.substring(start));
}
}
result->skeletonData = (spine_skeleton_data) data;
return (spine_skeleton_data_result) result;
result->skeletonData = (spine_skeleton_data) data;
return (spine_skeleton_data_result) result;
}
const char *spine_skeleton_data_result_get_error(spine_skeleton_data_result result) {
if (!result) return nullptr;
return ((_spine_skeleton_data_result *) result)->error;
if (!result) return nullptr;
return ((_spine_skeleton_data_result *) result)->error;
}
spine_skeleton_data spine_skeleton_data_result_get_data(spine_skeleton_data_result result) {
if (!result) return nullptr;
return ((_spine_skeleton_data_result *) result)->skeletonData;
if (!result) return nullptr;
return ((_spine_skeleton_data_result *) result)->skeletonData;
}
void spine_skeleton_data_result_dispose(spine_skeleton_data_result result) {
if (!result) return;
_spine_skeleton_data_result *_result = (_spine_skeleton_data_result *) result;
if (_result->error) {
SpineExtension::free(_result->error, __FILE__, __LINE__);
}
SpineExtension::free(_result, __FILE__, __LINE__);
if (!result) return;
_spine_skeleton_data_result *_result = (_spine_skeleton_data_result *) result;
if (_result->error) {
SpineExtension::free(_result->error, __FILE__, __LINE__);
}
SpineExtension::free(_result, __FILE__, __LINE__);
}
// Skeleton drawable
spine_skeleton_drawable spine_skeleton_drawable_create(spine_skeleton_data skeletonData) {
if (!skeletonData) return nullptr;
_spine_skeleton_drawable *drawable = new (__FILE__, __LINE__) _spine_skeleton_drawable();
if (!skeletonData) return nullptr;
_spine_skeleton_drawable *drawable = new (__FILE__, __LINE__) _spine_skeleton_drawable();
Skeleton *skeleton = new (__FILE__, __LINE__) Skeleton(*((SkeletonData *) skeletonData));
AnimationStateData *stateData = new (__FILE__, __LINE__) AnimationStateData((SkeletonData *) skeletonData);
AnimationState *state = new (__FILE__, __LINE__) AnimationState(stateData);
EventListener *listener = new (__FILE__, __LINE__) EventListener();
state->setListener(listener);
Skeleton *skeleton = new (__FILE__, __LINE__) Skeleton(*((SkeletonData *) skeletonData));
AnimationStateData *stateData = new (__FILE__, __LINE__) AnimationStateData((SkeletonData *) skeletonData);
AnimationState *state = new (__FILE__, __LINE__) AnimationState(stateData);
EventListener *listener = new (__FILE__, __LINE__) EventListener();
state->setListener(listener);
drawable->skeleton = (spine_skeleton) skeleton;
drawable->animationStateData = (spine_animation_state_data) stateData;
drawable->animationState = (spine_animation_state) state;
drawable->animationStateEvents = (spine_animation_state_events) listener;
drawable->renderer = new (__FILE__, __LINE__) SkeletonRenderer();
drawable->skeleton = (spine_skeleton) skeleton;
drawable->animationStateData = (spine_animation_state_data) stateData;
drawable->animationState = (spine_animation_state) state;
drawable->animationStateEvents = (spine_animation_state_events) listener;
drawable->renderer = new (__FILE__, __LINE__) SkeletonRenderer();
return (spine_skeleton_drawable) drawable;
return (spine_skeleton_drawable) drawable;
}
spine_render_command spine_skeleton_drawable_render(spine_skeleton_drawable drawable) {
if (!drawable) return nullptr;
_spine_skeleton_drawable *_drawable = (_spine_skeleton_drawable *) drawable;
Skeleton *skeleton = (Skeleton *) _drawable->skeleton;
SkeletonRenderer *renderer = _drawable->renderer;
if (!drawable) return nullptr;
_spine_skeleton_drawable *_drawable = (_spine_skeleton_drawable *) drawable;
Skeleton *skeleton = (Skeleton *) _drawable->skeleton;
SkeletonRenderer *renderer = _drawable->renderer;
RenderCommand *commands = renderer->render(*skeleton);
return (spine_render_command) commands;
RenderCommand *commands = renderer->render(*skeleton);
return (spine_render_command) commands;
}
void spine_skeleton_drawable_dispose(spine_skeleton_drawable drawable) {
if (!drawable) return;
_spine_skeleton_drawable *_drawable = (_spine_skeleton_drawable *) drawable;
if (!drawable) return;
_spine_skeleton_drawable *_drawable = (_spine_skeleton_drawable *) drawable;
if (_drawable->renderer) {
delete _drawable->renderer;
}
if (_drawable->animationState) {
delete (AnimationState *) _drawable->animationState;
}
if (_drawable->animationStateData) {
delete (AnimationStateData *) _drawable->animationStateData;
}
if (_drawable->skeleton) {
delete (Skeleton *) _drawable->skeleton;
}
if (_drawable->animationStateEvents) {
delete (EventListener *) _drawable->animationStateEvents;
}
if (_drawable->renderer) {
delete _drawable->renderer;
}
if (_drawable->animationState) {
delete (AnimationState *) _drawable->animationState;
}
if (_drawable->animationStateData) {
delete (AnimationStateData *) _drawable->animationStateData;
}
if (_drawable->skeleton) {
delete (Skeleton *) _drawable->skeleton;
}
if (_drawable->animationStateEvents) {
delete (EventListener *) _drawable->animationStateEvents;
}
delete _drawable;
delete _drawable;
}
spine_skeleton spine_skeleton_drawable_get_skeleton(spine_skeleton_drawable drawable) {
if (!drawable) return nullptr;
return ((_spine_skeleton_drawable *) drawable)->skeleton;
if (!drawable) return nullptr;
return ((_spine_skeleton_drawable *) drawable)->skeleton;
}
spine_animation_state spine_skeleton_drawable_get_animation_state(spine_skeleton_drawable drawable) {
if (!drawable) return nullptr;
return ((_spine_skeleton_drawable *) drawable)->animationState;
if (!drawable) return nullptr;
return ((_spine_skeleton_drawable *) drawable)->animationState;
}
spine_animation_state_data spine_skeleton_drawable_get_animation_state_data(spine_skeleton_drawable drawable) {
if (!drawable) return nullptr;
return ((_spine_skeleton_drawable *) drawable)->animationStateData;
if (!drawable) return nullptr;
return ((_spine_skeleton_drawable *) drawable)->animationStateData;
}
spine_animation_state_events spine_skeleton_drawable_get_animation_state_events(spine_skeleton_drawable drawable) {
if (!drawable) return nullptr;
return ((_spine_skeleton_drawable *) drawable)->animationStateEvents;
if (!drawable) return nullptr;
return ((_spine_skeleton_drawable *) drawable)->animationStateEvents;
}
// Skin entries
spine_skin_entries spine_skin_entries_create() {
_spine_skin_entries *entries = SpineExtension::calloc<_spine_skin_entries>(1, __FILE__, __LINE__);
return (spine_skin_entries) entries;
_spine_skin_entries *entries = SpineExtension::calloc<_spine_skin_entries>(1, __FILE__, __LINE__);
return (spine_skin_entries) entries;
}
void spine_skin_entries_dispose(spine_skin_entries entries) {
if (!entries) return;
_spine_skin_entries *_entries = (_spine_skin_entries *) entries;
if (_entries->entries) {
for (int i = 0; i < _entries->numEntries; i++) {
if (_entries->entries[i].name) {
SpineExtension::free(_entries->entries[i].name, __FILE__, __LINE__);
}
}
SpineExtension::free(_entries->entries, __FILE__, __LINE__);
}
SpineExtension::free(_entries, __FILE__, __LINE__);
if (!entries) return;
_spine_skin_entries *_entries = (_spine_skin_entries *) entries;
if (_entries->entries) {
for (int i = 0; i < _entries->numEntries; i++) {
if (_entries->entries[i].name) {
SpineExtension::free(_entries->entries[i].name, __FILE__, __LINE__);
}
}
SpineExtension::free(_entries->entries, __FILE__, __LINE__);
}
SpineExtension::free(_entries, __FILE__, __LINE__);
}
int32_t spine_skin_entries_get_num_entries(spine_skin_entries entries) {
if (!entries) return 0;
return ((_spine_skin_entries *) entries)->numEntries;
if (!entries) return 0;
return ((_spine_skin_entries *) entries)->numEntries;
}
spine_skin_entry spine_skin_entries_get_entry(spine_skin_entries entries, int32_t index) {
if (!entries) return nullptr;
_spine_skin_entries *_entries = (_spine_skin_entries *) entries;
if (index < 0 || index >= _entries->numEntries) return nullptr;
return (spine_skin_entry) &_entries->entries[index];
if (!entries) return nullptr;
_spine_skin_entries *_entries = (_spine_skin_entries *) entries;
if (index < 0 || index >= _entries->numEntries) return nullptr;
return (spine_skin_entry) &_entries->entries[index];
}
int32_t spine_skin_entry_get_slot_index(spine_skin_entry entry) {
if (!entry) return 0;
return ((_spine_skin_entry *) entry)->slotIndex;
if (!entry) return 0;
return ((_spine_skin_entry *) entry)->slotIndex;
}
const char *spine_skin_entry_get_name(spine_skin_entry entry) {
if (!entry) return nullptr;
return ((_spine_skin_entry *) entry)->name;
if (!entry) return nullptr;
return ((_spine_skin_entry *) entry)->name;
}
spine_attachment spine_skin_entry_get_attachment(spine_skin_entry entry) {
if (!entry) return nullptr;
return ((_spine_skin_entry *) entry)->attachment;
if (!entry) return nullptr;
return ((_spine_skin_entry *) entry)->attachment;
}

16
spine-c/src/extensions.h
View File

@ -47,11 +47,11 @@ SPINE_OPAQUE_TYPE(spine_skin_entries)
SPINE_OPAQUE_TYPE(spine_texture_loader)
// Additional types
typedef void* spine_void;
typedef void (*spine_dispose_renderer_object)(void*);
typedef void *spine_void;
typedef void (*spine_dispose_renderer_object)(void *);
// Texture loader callbacks
typedef void* (*spine_texture_loader_load_func)(const char *path);
typedef void *(*spine_texture_loader_load_func)(const char *path);
typedef void (*spine_texture_loader_unload_func)(void *texture);
// Version functions
@ -72,9 +72,8 @@ SPINE_C_API float spine_vector_get_y(spine_vector vector);
// Atlas functions
SPINE_C_API spine_atlas spine_atlas_load(const char *atlasData);
SPINE_C_API spine_atlas spine_atlas_load_callback(const char *atlasData, const char *atlasDir,
spine_texture_loader_load_func load,
spine_texture_loader_unload_func unload);
SPINE_C_API spine_atlas spine_atlas_load_callback(const char *atlasData, const char *atlasDir, spine_texture_loader_load_func load,
spine_texture_loader_unload_func unload);
SPINE_C_API int32_t spine_atlas_get_num_image_paths(spine_atlas atlas);
SPINE_C_API const char *spine_atlas_get_image_path(spine_atlas atlas, int32_t index);
SPINE_C_API bool spine_atlas_is_pma(spine_atlas atlas);
@ -83,7 +82,8 @@ SPINE_C_API void spine_atlas_dispose(spine_atlas atlas);
// Skeleton data functions
SPINE_C_API spine_skeleton_data_result spine_skeleton_data_load_json(spine_atlas atlas, const char *skeletonData, const char *path);
SPINE_C_API spine_skeleton_data_result spine_skeleton_data_load_binary(spine_atlas atlas, const uint8_t *skeletonData, int32_t length, const char *path);
SPINE_C_API spine_skeleton_data_result spine_skeleton_data_load_binary(spine_atlas atlas, const uint8_t *skeletonData, int32_t length,
const char *path);
SPINE_C_API const char *spine_skeleton_data_result_get_error(spine_skeleton_data_result result);
SPINE_C_API spine_skeleton_data spine_skeleton_data_result_get_data(spine_skeleton_data_result result);
SPINE_C_API void spine_skeleton_data_result_dispose(spine_skeleton_data_result result);
@ -112,4 +112,4 @@ SPINE_C_API spine_attachment spine_skin_entry_get_attachment(spine_skin_entry en
}
#endif
#endif // SPINE_C_EXTENSIONS_H
#endif// SPINE_C_EXTENSIONS_H

82
spine-c/src/generated/alpha_timeline.cpp
View File

@ -4,93 +4,119 @@
using namespace spine;
spine_alpha_timeline spine_alpha_timeline_create(size_t frameCount, size_t bezierCount, int slotIndex) {
return (spine_alpha_timeline) new (__FILE__, __LINE__) AlphaTimeline(frameCount, bezierCount, slotIndex);
return (spine_alpha_timeline) new (__FILE__, __LINE__) AlphaTimeline(frameCount, bezierCount, slotIndex);
}
void spine_alpha_timeline_dispose(spine_alpha_timeline self) {
delete (AlphaTimeline*)self;
delete (AlphaTimeline *) self;
}
spine_rtti spine_alpha_timeline_get_rtti(spine_alpha_timeline self) {
return (spine_rtti)&((AlphaTimeline*)self)->getRTTI();
AlphaTimeline *_self = (AlphaTimeline *) self;
return (spine_rtti) &_self->getRTTI();
}
void spine_alpha_timeline_apply(spine_alpha_timeline self, spine_skeleton skeleton, float lastTime, float time, spine_array_event pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction, bool appliedPose) {
((AlphaTimeline*)self)->apply(*((Skeleton*)skeleton), lastTime, time, (Array<Event *> *)pEvents, alpha, (MixBlend)blend, (MixDirection)direction, appliedPose);
void spine_alpha_timeline_apply(spine_alpha_timeline self, spine_skeleton skeleton, float lastTime, float time, spine_array_event pEvents,
float alpha, spine_mix_blend blend, spine_mix_direction direction, bool appliedPose) {
AlphaTimeline *_self = (AlphaTimeline *) self;
_self->apply(*((Skeleton *) skeleton), lastTime, time, (Array<Event *> *) pEvents, alpha, (MixBlend) blend, (MixDirection) direction,
appliedPose);
}
void spine_alpha_timeline_set_frame(spine_alpha_timeline self, size_t frame, float time, float value) {
((CurveTimeline1*)(AlphaTimeline*)self)->setFrame(frame, time, value);
CurveTimeline1 *_self = (CurveTimeline1 *) (AlphaTimeline *) self;
_self->setFrame(frame, time, value);
}
float spine_alpha_timeline_get_curve_value(spine_alpha_timeline self, float time) {
return ((CurveTimeline1*)(AlphaTimeline*)self)->getCurveValue(time);
CurveTimeline1 *_self = (CurveTimeline1 *) (AlphaTimeline *) self;
return _self->getCurveValue(time);
}
float spine_alpha_timeline_get_relative_value(spine_alpha_timeline self, float time, float alpha, spine_mix_blend blend, float current, float setup) {
return ((CurveTimeline1*)(AlphaTimeline*)self)->getRelativeValue(time, alpha, (MixBlend)blend, current, setup);
CurveTimeline1 *_self = (CurveTimeline1 *) (AlphaTimeline *) self;
return _self->getRelativeValue(time, alpha, (MixBlend) blend, current, setup);
}
float spine_alpha_timeline_get_absolute_value_1(spine_alpha_timeline self, float time, float alpha, spine_mix_blend blend, float current, float setup) {
return ((CurveTimeline1*)(AlphaTimeline*)self)->getAbsoluteValue(time, alpha, (MixBlend)blend, current, setup);
float spine_alpha_timeline_get_absolute_value_1(spine_alpha_timeline self, float time, float alpha, spine_mix_blend blend, float current,
float setup) {
CurveTimeline1 *_self = (CurveTimeline1 *) (AlphaTimeline *) self;
return _self->getAbsoluteValue(time, alpha, (MixBlend) blend, current, setup);
}
float spine_alpha_timeline_get_absolute_value_2(spine_alpha_timeline self, float time, float alpha, spine_mix_blend blend, float current, float setup, float value) {
return ((CurveTimeline1*)(AlphaTimeline*)self)->getAbsoluteValue(time, alpha, (MixBlend)blend, current, setup, value);
float spine_alpha_timeline_get_absolute_value_2(spine_alpha_timeline self, float time, float alpha, spine_mix_blend blend, float current, float setup,
float value) {
CurveTimeline1 *_self = (CurveTimeline1 *) (AlphaTimeline *) self;
return _self->getAbsoluteValue(time, alpha, (MixBlend) blend, current, setup, value);
}
float spine_alpha_timeline_get_scale_value(spine_alpha_timeline self, float time, float alpha, spine_mix_blend blend, spine_mix_direction direction, float current, float setup) {
return ((CurveTimeline1*)(AlphaTimeline*)self)->getScaleValue(time, alpha, (MixBlend)blend, (MixDirection)direction, current, setup);
float spine_alpha_timeline_get_scale_value(spine_alpha_timeline self, float time, float alpha, spine_mix_blend blend, spine_mix_direction direction,
float current, float setup) {
CurveTimeline1 *_self = (CurveTimeline1 *) (AlphaTimeline *) self;
return _self->getScaleValue(time, alpha, (MixBlend) blend, (MixDirection) direction, current, setup);
}
void spine_alpha_timeline_set_linear(spine_alpha_timeline self, size_t frame) {
((CurveTimeline1*)(AlphaTimeline*)self)->setLinear(frame);
CurveTimeline1 *_self = (CurveTimeline1 *) (AlphaTimeline *) self;
_self->setLinear(frame);
}
void spine_alpha_timeline_set_stepped(spine_alpha_timeline self, size_t frame) {
((CurveTimeline1*)(AlphaTimeline*)self)->setStepped(frame);
CurveTimeline1 *_self = (CurveTimeline1 *) (AlphaTimeline *) self;
_self->setStepped(frame);
}
void spine_alpha_timeline_set_bezier(spine_alpha_timeline self, size_t bezier, size_t frame, float value, float time1, float value1, float cx1, float cy1, float cx2, float cy2, float time2, float value2) {
((CurveTimeline1*)(AlphaTimeline*)self)->setBezier(bezier, frame, value, time1, value1, cx1, cy1, cx2, cy2, time2, value2);
void spine_alpha_timeline_set_bezier(spine_alpha_timeline self, size_t bezier, size_t frame, float value, float time1, float value1, float cx1,
float cy1, float cx2, float cy2, float time2, float value2) {
CurveTimeline1 *_self = (CurveTimeline1 *) (AlphaTimeline *) self;
_self->setBezier(bezier, frame, value, time1, value1, cx1, cy1, cx2, cy2, time2, value2);
}
float spine_alpha_timeline_get_bezier_value(spine_alpha_timeline self, float time, size_t frame, size_t valueOffset, size_t i) {
return ((CurveTimeline1*)(AlphaTimeline*)self)->getBezierValue(time, frame, valueOffset, i);
CurveTimeline1 *_self = (CurveTimeline1 *) (AlphaTimeline *) self;
return _self->getBezierValue(time, frame, valueOffset, i);
}
spine_array_float spine_alpha_timeline_get_curves(spine_alpha_timeline self) {
return (spine_array_float)&((CurveTimeline1*)(AlphaTimeline*)self)->getCurves();
CurveTimeline1 *_self = (CurveTimeline1 *) (AlphaTimeline *) self;
return (spine_array_float) &_self->getCurves();
}
size_t spine_alpha_timeline_get_frame_entries(spine_alpha_timeline self) {
return ((CurveTimeline1*)(AlphaTimeline*)self)->getFrameEntries();
CurveTimeline1 *_self = (CurveTimeline1 *) (AlphaTimeline *) self;
return _self->getFrameEntries();
}
size_t spine_alpha_timeline_get_frame_count(spine_alpha_timeline self) {
return ((CurveTimeline1*)(AlphaTimeline*)self)->getFrameCount();
CurveTimeline1 *_self = (CurveTimeline1 *) (AlphaTimeline *) self;
return _self->getFrameCount();
}
spine_array_float spine_alpha_timeline_get_frames(spine_alpha_timeline self) {
return (spine_array_float)&((CurveTimeline1*)(AlphaTimeline*)self)->getFrames();
CurveTimeline1 *_self = (CurveTimeline1 *) (AlphaTimeline *) self;
return (spine_array_float) &_self->getFrames();
}
float spine_alpha_timeline_get_duration(spine_alpha_timeline self) {
return ((CurveTimeline1*)(AlphaTimeline*)self)->getDuration();
CurveTimeline1 *_self = (CurveTimeline1 *) (AlphaTimeline *) self;
return _self->getDuration();
}
spine_array_property_id spine_alpha_timeline_get_property_ids(spine_alpha_timeline self) {
return (spine_array_property_id)&((CurveTimeline1*)(AlphaTimeline*)self)->getPropertyIds();
CurveTimeline1 *_self = (CurveTimeline1 *) (AlphaTimeline *) self;
return (spine_array_property_id) &_self->getPropertyIds();
}
int spine_alpha_timeline_get_slot_index(spine_alpha_timeline self) {
return ((SlotTimeline*)(AlphaTimeline*)self)->getSlotIndex();
SlotTimeline *_self = (SlotTimeline *) (AlphaTimeline *) self;
return _self->getSlotIndex();
}
void spine_alpha_timeline_set_slot_index(spine_alpha_timeline self, int inValue) {
((SlotTimeline*)(AlphaTimeline*)self)->setSlotIndex(inValue);
SlotTimeline *_self = (SlotTimeline *) (AlphaTimeline *) self;
_self->setSlotIndex(inValue);
}
spine_rtti spine_alpha_timeline_rtti(void) {
return (spine_rtti)&AlphaTimeline::rtti;
return (spine_rtti) &AlphaTimeline::rtti;
}

18
spine-c/src/generated/alpha_timeline.h
View File

@ -13,16 +13,22 @@ SPINE_C_API spine_alpha_timeline spine_alpha_timeline_create(size_t frameCount,
SPINE_C_API void spine_alpha_timeline_dispose(spine_alpha_timeline self);
SPINE_C_API spine_rtti spine_alpha_timeline_get_rtti(spine_alpha_timeline self);
SPINE_C_API void spine_alpha_timeline_apply(spine_alpha_timeline self, spine_skeleton skeleton, float lastTime, float time, spine_array_event pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction, bool appliedPose);
SPINE_C_API void spine_alpha_timeline_apply(spine_alpha_timeline self, spine_skeleton skeleton, float lastTime, float time, spine_array_event pEvents,
float alpha, spine_mix_blend blend, spine_mix_direction direction, bool appliedPose);
SPINE_C_API void spine_alpha_timeline_set_frame(spine_alpha_timeline self, size_t frame, float time, float value);
SPINE_C_API float spine_alpha_timeline_get_curve_value(spine_alpha_timeline self, float time);
SPINE_C_API float spine_alpha_timeline_get_relative_value(spine_alpha_timeline self, float time, float alpha, spine_mix_blend blend, float current, float setup);
SPINE_C_API float spine_alpha_timeline_get_absolute_value_1(spine_alpha_timeline self, float time, float alpha, spine_mix_blend blend, float current, float setup);
SPINE_C_API float spine_alpha_timeline_get_absolute_value_2(spine_alpha_timeline self, float time, float alpha, spine_mix_blend blend, float current, float setup, float value);
SPINE_C_API float spine_alpha_timeline_get_scale_value(spine_alpha_timeline self, float time, float alpha, spine_mix_blend blend, spine_mix_direction direction, float current, float setup);
SPINE_C_API float spine_alpha_timeline_get_relative_value(spine_alpha_timeline self, float time, float alpha, spine_mix_blend blend, float current,
float setup);
SPINE_C_API float spine_alpha_timeline_get_absolute_value_1(spine_alpha_timeline self, float time, float alpha, spine_mix_blend blend, float current,
float setup);
SPINE_C_API float spine_alpha_timeline_get_absolute_value_2(spine_alpha_timeline self, float time, float alpha, spine_mix_blend blend, float current,
float setup, float value);
SPINE_C_API float spine_alpha_timeline_get_scale_value(spine_alpha_timeline self, float time, float alpha, spine_mix_blend blend,
spine_mix_direction direction, float current, float setup);
SPINE_C_API void spine_alpha_timeline_set_linear(spine_alpha_timeline self, size_t frame);
SPINE_C_API void spine_alpha_timeline_set_stepped(spine_alpha_timeline self, size_t frame);
SPINE_C_API void spine_alpha_timeline_set_bezier(spine_alpha_timeline self, size_t bezier, size_t frame, float value, float time1, float value1, float cx1, float cy1, float cx2, float cy2, float time2, float value2);
SPINE_C_API void spine_alpha_timeline_set_bezier(spine_alpha_timeline self, size_t bezier, size_t frame, float value, float time1, float value1,
float cx1, float cy1, float cx2, float cy2, float time2, float value2);
SPINE_C_API float spine_alpha_timeline_get_bezier_value(spine_alpha_timeline self, float time, size_t frame, size_t valueOffset, size_t i);
SPINE_C_API spine_array_float spine_alpha_timeline_get_curves(spine_alpha_timeline self);
SPINE_C_API size_t spine_alpha_timeline_get_frame_entries(spine_alpha_timeline self);

40
spine-c/src/generated/animation.cpp
View File

@ -3,50 +3,60 @@
using namespace spine;
spine_animation spine_animation_create(const char * name, spine_array_timeline timelines, float duration) {
return (spine_animation) new (__FILE__, __LINE__) Animation(String(name), *((Array<Timeline *>*)timelines), duration);
spine_animation spine_animation_create(const char *name, spine_array_timeline timelines, float duration) {
return (spine_animation) new (__FILE__, __LINE__) Animation(String(name), *((Array<Timeline *> *) timelines), duration);
}
void spine_animation_dispose(spine_animation self) {
delete (Animation*)self;
delete (Animation *) self;
}
spine_array_timeline spine_animation_get_timelines(spine_animation self) {
return (spine_array_timeline)&((Animation*)self)->getTimelines();
Animation *_self = (Animation *) self;
return (spine_array_timeline) &_self->getTimelines();
}
void spine_animation_set_timelines(spine_animation self, spine_array_timeline timelines) {
((Animation*)self)->setTimelines(*((Array<Timeline *>*)timelines));
Animation *_self = (Animation *) self;
_self->setTimelines(*((Array<Timeline *> *) timelines));
}
bool spine_animation_has_timeline(spine_animation self, spine_array_property_id ids) {
return ((Animation*)self)->hasTimeline(*((Array<PropertyId>*)ids));
Animation *_self = (Animation *) self;
return _self->hasTimeline(*((Array<PropertyId> *) ids));
}
float spine_animation_get_duration(spine_animation self) {
return ((Animation*)self)->getDuration();
Animation *_self = (Animation *) self;
return _self->getDuration();
}
void spine_animation_set_duration(spine_animation self, float inValue) {
((Animation*)self)->setDuration(inValue);
Animation *_self = (Animation *) self;
_self->setDuration(inValue);
}
void spine_animation_apply(spine_animation self, spine_skeleton skeleton, float lastTime, float time, bool loop, spine_array_event pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction, bool appliedPose) {
((Animation*)self)->apply(*((Skeleton*)skeleton), lastTime, time, loop, (Array<Event *> *)pEvents, alpha, (MixBlend)blend, (MixDirection)direction, appliedPose);
void spine_animation_apply(spine_animation self, spine_skeleton skeleton, float lastTime, float time, bool loop, spine_array_event pEvents,
float alpha, spine_mix_blend blend, spine_mix_direction direction, bool appliedPose) {
Animation *_self = (Animation *) self;
_self->apply(*((Skeleton *) skeleton), lastTime, time, loop, (Array<Event *> *) pEvents, alpha, (MixBlend) blend, (MixDirection) direction,
appliedPose);
}
const char * spine_animation_get_name(spine_animation self) {
return ((Animation*)self)->getName().buffer();
const char *spine_animation_get_name(spine_animation self) {
Animation *_self = (Animation *) self;
return _self->getName().buffer();
}
spine_array_int spine_animation_get_bones(spine_animation self) {
return (spine_array_int)&((Animation*)self)->getBones();
Animation *_self = (Animation *) self;
return (spine_array_int) &_self->getBones();
}
int spine_animation_search_1(spine_array_float values, float target) {
return Animation::search(*((Array<float>*)values), target);
return Animation::search(*((Array<float> *) values), target);
}
int spine_animation_search_2(spine_array_float values, float target, int step) {
return Animation::search(*((Array<float>*)values), target, step);
return Animation::search(*((Array<float> *) values), target, step);
}

8
spine-c/src/generated/animation.h
View File

@ -8,7 +8,7 @@
extern "C" {
#endif
SPINE_C_API spine_animation spine_animation_create(const char * name, spine_array_timeline timelines, float duration);
SPINE_C_API spine_animation spine_animation_create(const char *name, spine_array_timeline timelines, float duration);
SPINE_C_API void spine_animation_dispose(spine_animation self);
@ -17,8 +17,10 @@ SPINE_C_API void spine_animation_set_timelines(spine_animation self, spine_array
SPINE_C_API bool spine_animation_has_timeline(spine_animation self, spine_array_property_id ids);
SPINE_C_API float spine_animation_get_duration(spine_animation self);
SPINE_C_API void spine_animation_set_duration(spine_animation self, float inValue);
SPINE_C_API void spine_animation_apply(spine_animation self, spine_skeleton skeleton, float lastTime, float time, bool loop, spine_array_event pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction, bool appliedPose);
SPINE_C_API const char * spine_animation_get_name(spine_animation self);
SPINE_C_API void spine_animation_apply(spine_animation self, spine_skeleton skeleton, float lastTime, float time, bool loop,
spine_array_event pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction,
bool appliedPose);
SPINE_C_API const char *spine_animation_get_name(spine_animation self);
SPINE_C_API spine_array_int spine_animation_get_bones(spine_animation self);
SPINE_C_API int spine_animation_search_1(spine_array_float values, float target);
SPINE_C_API int spine_animation_search_2(spine_array_float values, float target, int step);

80
spine-c/src/generated/animation_state.cpp
View File

@ -4,97 +4,121 @@
using namespace spine;
spine_animation_state spine_animation_state_create(spine_animation_state_data data) {
return (spine_animation_state) new (__FILE__, __LINE__) AnimationState((AnimationStateData *)data);
return (spine_animation_state) new (__FILE__, __LINE__) AnimationState((AnimationStateData *) data);
}
void spine_animation_state_dispose(spine_animation_state self) {
delete (AnimationState*)self;
delete (AnimationState *) self;
}
void spine_animation_state_update(spine_animation_state self, float delta) {
((AnimationState*)self)->update(delta);
AnimationState *_self = (AnimationState *) self;
_self->update(delta);
}
bool spine_animation_state_apply(spine_animation_state self, spine_skeleton skeleton) {
return ((AnimationState*)self)->apply(*((Skeleton*)skeleton));
AnimationState *_self = (AnimationState *) self;
return _self->apply(*((Skeleton *) skeleton));
}
void spine_animation_state_clear_tracks(spine_animation_state self) {
((AnimationState*)self)->clearTracks();
AnimationState *_self = (AnimationState *) self;
_self->clearTracks();
}
void spine_animation_state_clear_track(spine_animation_state self, size_t trackIndex) {
((AnimationState*)self)->clearTrack(trackIndex);
AnimationState *_self = (AnimationState *) self;
_self->clearTrack(trackIndex);
}
spine_track_entry spine_animation_state_set_animation_1(spine_animation_state self, size_t trackIndex, const char * animationName, bool loop) {
return (spine_track_entry)((AnimationState*)self)->setAnimation(trackIndex, String(animationName), loop);
spine_track_entry spine_animation_state_set_animation_1(spine_animation_state self, size_t trackIndex, const char *animationName, bool loop) {
AnimationState *_self = (AnimationState *) self;
return (spine_track_entry) _self->setAnimation(trackIndex, String(animationName), loop);
}
spine_track_entry spine_animation_state_set_animation_2(spine_animation_state self, size_t trackIndex, spine_animation animation, bool loop) {
return (spine_track_entry)((AnimationState*)self)->setAnimation(trackIndex, (Animation *)animation, loop);
AnimationState *_self = (AnimationState *) self;
return (spine_track_entry) _self->setAnimation(trackIndex, (Animation *) animation, loop);
}
spine_track_entry spine_animation_state_add_animation_1(spine_animation_state self, size_t trackIndex, const char * animationName, bool loop, float delay) {
return (spine_track_entry)((AnimationState*)self)->addAnimation(trackIndex, String(animationName), loop, delay);
spine_track_entry spine_animation_state_add_animation_1(spine_animation_state self, size_t trackIndex, const char *animationName, bool loop,
float delay) {
AnimationState *_self = (AnimationState *) self;
return (spine_track_entry) _self->addAnimation(trackIndex, String(animationName), loop, delay);
}
spine_track_entry spine_animation_state_add_animation_2(spine_animation_state self, size_t trackIndex, spine_animation animation, bool loop, float delay) {
return (spine_track_entry)((AnimationState*)self)->addAnimation(trackIndex, (Animation *)animation, loop, delay);
spine_track_entry spine_animation_state_add_animation_2(spine_animation_state self, size_t trackIndex, spine_animation animation, bool loop,
float delay) {
AnimationState *_self = (AnimationState *) self;
return (spine_track_entry) _self->addAnimation(trackIndex, (Animation *) animation, loop, delay);
}
spine_track_entry spine_animation_state_set_empty_animation(spine_animation_state self, size_t trackIndex, float mixDuration) {
return (spine_track_entry)((AnimationState*)self)->setEmptyAnimation(trackIndex, mixDuration);
AnimationState *_self = (AnimationState *) self;
return (spine_track_entry) _self->setEmptyAnimation(trackIndex, mixDuration);
}
spine_track_entry spine_animation_state_add_empty_animation(spine_animation_state self, size_t trackIndex, float mixDuration, float delay) {
return (spine_track_entry)((AnimationState*)self)->addEmptyAnimation(trackIndex, mixDuration, delay);
AnimationState *_self = (AnimationState *) self;
return (spine_track_entry) _self->addEmptyAnimation(trackIndex, mixDuration, delay);
}
void spine_animation_state_set_empty_animations(spine_animation_state self, float mixDuration) {
((AnimationState*)self)->setEmptyAnimations(mixDuration);
AnimationState *_self = (AnimationState *) self;
_self->setEmptyAnimations(mixDuration);
}
spine_track_entry spine_animation_state_get_current(spine_animation_state self, size_t trackIndex) {
return (spine_track_entry)((AnimationState*)self)->getCurrent(trackIndex);
AnimationState *_self = (AnimationState *) self;
return (spine_track_entry) _self->getCurrent(trackIndex);
}
spine_animation_state_data spine_animation_state_get_data(spine_animation_state self) {
return (spine_animation_state_data)&((AnimationState*)self)->getData();
AnimationState *_self = (AnimationState *) self;
return (spine_animation_state_data) &_self->getData();
}
spine_array_track_entry spine_animation_state_get_tracks(spine_animation_state self) {
return (spine_array_track_entry)&((AnimationState*)self)->getTracks();
AnimationState *_self = (AnimationState *) self;
return (spine_array_track_entry) &_self->getTracks();
}
float spine_animation_state_get_time_scale(spine_animation_state self) {
return ((AnimationState*)self)->getTimeScale();
AnimationState *_self = (AnimationState *) self;
return _self->getTimeScale();
}
void spine_animation_state_set_time_scale(spine_animation_state self, float inValue) {
((AnimationState*)self)->setTimeScale(inValue);
AnimationState *_self = (AnimationState *) self;
_self->setTimeScale(inValue);
}
void spine_animation_state_disable_queue(spine_animation_state self) {
((AnimationState*)self)->disableQueue();
AnimationState *_self = (AnimationState *) self;
_self->disableQueue();
}
void spine_animation_state_enable_queue(spine_animation_state self) {
((AnimationState*)self)->enableQueue();
AnimationState *_self = (AnimationState *) self;
_self->enableQueue();
}
void spine_animation_state_set_manual_track_entry_disposal(spine_animation_state self, bool inValue) {
((AnimationState*)self)->setManualTrackEntryDisposal(inValue);
AnimationState *_self = (AnimationState *) self;
_self->setManualTrackEntryDisposal(inValue);
}
bool spine_animation_state_get_manual_track_entry_disposal(spine_animation_state self) {
return ((AnimationState*)self)->getManualTrackEntryDisposal();
AnimationState *_self = (AnimationState *) self;
return _self->getManualTrackEntryDisposal();
}
void spine_animation_state_dispose_track_entry(spine_animation_state self, spine_track_entry entry) {
((AnimationState*)self)->disposeTrackEntry((TrackEntry *)entry);
AnimationState *_self = (AnimationState *) self;
_self->disposeTrackEntry((TrackEntry *) entry);
}
void * spine_animation_state_get_renderer_object(spine_animation_state self) {
return ((HasRendererObject*)(AnimationState*)self)->getRendererObject();
void *spine_animation_state_get_renderer_object(spine_animation_state self) {
HasRendererObject *_self = (HasRendererObject *) (AnimationState *) self;
return _self->getRendererObject();
}

17
spine-c/src/generated/animation_state.h
View File

@ -16,12 +16,17 @@ SPINE_C_API void spine_animation_state_update(spine_animation_state self, float
SPINE_C_API bool spine_animation_state_apply(spine_animation_state self, spine_skeleton skeleton);
SPINE_C_API void spine_animation_state_clear_tracks(spine_animation_state self);
SPINE_C_API void spine_animation_state_clear_track(spine_animation_state self, size_t trackIndex);
SPINE_C_API spine_track_entry spine_animation_state_set_animation_1(spine_animation_state self, size_t trackIndex, const char * animationName, bool loop);
SPINE_C_API spine_track_entry spine_animation_state_set_animation_2(spine_animation_state self, size_t trackIndex, spine_animation animation, bool loop);
SPINE_C_API spine_track_entry spine_animation_state_add_animation_1(spine_animation_state self, size_t trackIndex, const char * animationName, bool loop, float delay);
SPINE_C_API spine_track_entry spine_animation_state_add_animation_2(spine_animation_state self, size_t trackIndex, spine_animation animation, bool loop, float delay);
SPINE_C_API spine_track_entry spine_animation_state_set_animation_1(spine_animation_state self, size_t trackIndex, const char *animationName,
bool loop);
SPINE_C_API spine_track_entry spine_animation_state_set_animation_2(spine_animation_state self, size_t trackIndex, spine_animation animation,
bool loop);
SPINE_C_API spine_track_entry spine_animation_state_add_animation_1(spine_animation_state self, size_t trackIndex, const char *animationName,
bool loop, float delay);
SPINE_C_API spine_track_entry spine_animation_state_add_animation_2(spine_animation_state self, size_t trackIndex, spine_animation animation,
bool loop, float delay);
SPINE_C_API spine_track_entry spine_animation_state_set_empty_animation(spine_animation_state self, size_t trackIndex, float mixDuration);
SPINE_C_API spine_track_entry spine_animation_state_add_empty_animation(spine_animation_state self, size_t trackIndex, float mixDuration, float delay);
SPINE_C_API spine_track_entry spine_animation_state_add_empty_animation(spine_animation_state self, size_t trackIndex, float mixDuration,
float delay);
SPINE_C_API void spine_animation_state_set_empty_animations(spine_animation_state self, float mixDuration);
SPINE_C_API spine_track_entry spine_animation_state_get_current(spine_animation_state self, size_t trackIndex);
SPINE_C_API spine_animation_state_data spine_animation_state_get_data(spine_animation_state self);
@ -33,7 +38,7 @@ SPINE_C_API void spine_animation_state_enable_queue(spine_animation_state self);
SPINE_C_API void spine_animation_state_set_manual_track_entry_disposal(spine_animation_state self, bool inValue);
SPINE_C_API bool spine_animation_state_get_manual_track_entry_disposal(spine_animation_state self);
SPINE_C_API void spine_animation_state_dispose_track_entry(spine_animation_state self, spine_track_entry entry);
SPINE_C_API void * spine_animation_state_get_renderer_object(spine_animation_state self);
SPINE_C_API void *spine_animation_state_get_renderer_object(spine_animation_state self);
#ifdef __cplusplus
}

27
spine-c/src/generated/animation_state_data.cpp
View File

@ -4,37 +4,44 @@
using namespace spine;
spine_animation_state_data spine_animation_state_data_create(spine_skeleton_data skeletonData) {
return (spine_animation_state_data) new (__FILE__, __LINE__) AnimationStateData((SkeletonData *)skeletonData);
return (spine_animation_state_data) new (__FILE__, __LINE__) AnimationStateData((SkeletonData *) skeletonData);
}
void spine_animation_state_data_dispose(spine_animation_state_data self) {
delete (AnimationStateData*)self;
delete (AnimationStateData *) self;
}
spine_skeleton_data spine_animation_state_data_get_skeleton_data(spine_animation_state_data self) {
return (spine_skeleton_data)((AnimationStateData*)self)->getSkeletonData();
AnimationStateData *_self = (AnimationStateData *) self;
return (spine_skeleton_data) _self->getSkeletonData();
}
float spine_animation_state_data_get_default_mix(spine_animation_state_data self) {
return ((AnimationStateData*)self)->getDefaultMix();
AnimationStateData *_self = (AnimationStateData *) self;
return _self->getDefaultMix();
}
void spine_animation_state_data_set_default_mix(spine_animation_state_data self, float inValue) {
((AnimationStateData*)self)->setDefaultMix(inValue);
AnimationStateData *_self = (AnimationStateData *) self;
_self->setDefaultMix(inValue);
}
void spine_animation_state_data_set_mix_1(spine_animation_state_data self, const char * fromName, const char * toName, float duration) {
((AnimationStateData*)self)->setMix(String(fromName), String(toName), duration);
void spine_animation_state_data_set_mix_1(spine_animation_state_data self, const char *fromName, const char *toName, float duration) {
AnimationStateData *_self = (AnimationStateData *) self;
_self->setMix(String(fromName), String(toName), duration);
}
void spine_animation_state_data_set_mix_2(spine_animation_state_data self, spine_animation from, spine_animation to, float duration) {
((AnimationStateData*)self)->setMix((Animation *)from, (Animation *)to, duration);
AnimationStateData *_self = (AnimationStateData *) self;
_self->setMix((Animation *) from, (Animation *) to, duration);
}
float spine_animation_state_data_get_mix(spine_animation_state_data self, spine_animation from, spine_animation to) {
return ((AnimationStateData*)self)->getMix((Animation *)from, (Animation *)to);
AnimationStateData *_self = (AnimationStateData *) self;
return _self->getMix((Animation *) from, (Animation *) to);
}
void spine_animation_state_data_clear(spine_animation_state_data self) {
((AnimationStateData*)self)->clear();
AnimationStateData *_self = (AnimationStateData *) self;
_self->clear();
}

2
spine-c/src/generated/animation_state_data.h
View File

@ -15,7 +15,7 @@ SPINE_C_API void spine_animation_state_data_dispose(spine_animation_state_data s
SPINE_C_API spine_skeleton_data spine_animation_state_data_get_skeleton_data(spine_animation_state_data self);
SPINE_C_API float spine_animation_state_data_get_default_mix(spine_animation_state_data self);
SPINE_C_API void spine_animation_state_data_set_default_mix(spine_animation_state_data self, float inValue);
SPINE_C_API void spine_animation_state_data_set_mix_1(spine_animation_state_data self, const char * fromName, const char * toName, float duration);
SPINE_C_API void spine_animation_state_data_set_mix_1(spine_animation_state_data self, const char *fromName, const char *toName, float duration);
SPINE_C_API void spine_animation_state_data_set_mix_2(spine_animation_state_data self, spine_animation from, spine_animation to, float duration);
SPINE_C_API float spine_animation_state_data_get_mix(spine_animation_state_data self, spine_animation from, spine_animation to);
SPINE_C_API void spine_animation_state_data_clear(spine_animation_state_data self);

1195
spine-c/src/generated/arrays.cpp
View File

File diff suppressed because it is too large Load Diff

77
spine-c/src/generated/arrays.h
View File

@ -91,7 +91,7 @@ SPINE_C_API bool spine_array_float_contains(spine_array_float array, float inVal
SPINE_C_API int spine_array_float_index_of(spine_array_float array, float inValue);
SPINE_C_API float * spine_array_float_buffer(spine_array_float array);
SPINE_C_API float *spine_array_float_buffer(spine_array_float array);
SPINE_C_API spine_array_int spine_array_int_create(void);
@ -119,7 +119,7 @@ SPINE_C_API bool spine_array_int_contains(spine_array_int array, int inValue);
SPINE_C_API int spine_array_int_index_of(spine_array_int array, int inValue);
SPINE_C_API int * spine_array_int_buffer(spine_array_int array);
SPINE_C_API int *spine_array_int_buffer(spine_array_int array);
SPINE_C_API spine_array_unsigned_short spine_array_unsigned_short_create(void);
@ -131,7 +131,8 @@ SPINE_C_API size_t spine_array_unsigned_short_get_capacity(spine_array_unsigned_
SPINE_C_API size_t spine_array_unsigned_short_size(spine_array_unsigned_short array);
SPINE_C_API spine_array_unsigned_short spine_array_unsigned_short_set_size(spine_array_unsigned_short array, size_t newSize, unsigned short defaultValue);
SPINE_C_API spine_array_unsigned_short spine_array_unsigned_short_set_size(spine_array_unsigned_short array, size_t newSize,
unsigned short defaultValue);
SPINE_C_API void spine_array_unsigned_short_ensure_capacity(spine_array_unsigned_short array, size_t newCapacity);
@ -147,7 +148,7 @@ SPINE_C_API bool spine_array_unsigned_short_contains(spine_array_unsigned_short
SPINE_C_API int spine_array_unsigned_short_index_of(spine_array_unsigned_short array, unsigned short inValue);
SPINE_C_API unsigned short * spine_array_unsigned_short_buffer(spine_array_unsigned_short array);
SPINE_C_API unsigned short *spine_array_unsigned_short_buffer(spine_array_unsigned_short array);
SPINE_C_API spine_array_property_id spine_array_property_id_create(void);
@ -203,7 +204,7 @@ SPINE_C_API bool spine_array_animation_contains(spine_array_animation array, spi
SPINE_C_API int spine_array_animation_index_of(spine_array_animation array, spine_animation inValue);
SPINE_C_API spine_animation * spine_array_animation_buffer(spine_array_animation array);
SPINE_C_API spine_animation *spine_array_animation_buffer(spine_array_animation array);
SPINE_C_API spine_array_atlas_page spine_array_atlas_page_create(void);
@ -231,7 +232,7 @@ SPINE_C_API bool spine_array_atlas_page_contains(spine_array_atlas_page array, s
SPINE_C_API int spine_array_atlas_page_index_of(spine_array_atlas_page array, spine_atlas_page inValue);
SPINE_C_API spine_atlas_page * spine_array_atlas_page_buffer(spine_array_atlas_page array);
SPINE_C_API spine_atlas_page *spine_array_atlas_page_buffer(spine_array_atlas_page array);
SPINE_C_API spine_array_atlas_region spine_array_atlas_region_create(void);
@ -243,7 +244,8 @@ SPINE_C_API size_t spine_array_atlas_region_get_capacity(spine_array_atlas_regio
SPINE_C_API size_t spine_array_atlas_region_size(spine_array_atlas_region array);
SPINE_C_API spine_array_atlas_region spine_array_atlas_region_set_size(spine_array_atlas_region array, size_t newSize, spine_atlas_region defaultValue);
SPINE_C_API spine_array_atlas_region spine_array_atlas_region_set_size(spine_array_atlas_region array, size_t newSize,
spine_atlas_region defaultValue);
SPINE_C_API void spine_array_atlas_region_ensure_capacity(spine_array_atlas_region array, size_t newCapacity);
@ -259,7 +261,7 @@ SPINE_C_API bool spine_array_atlas_region_contains(spine_array_atlas_region arra
SPINE_C_API int spine_array_atlas_region_index_of(spine_array_atlas_region array, spine_atlas_region inValue);
SPINE_C_API spine_atlas_region * spine_array_atlas_region_buffer(spine_array_atlas_region array);
SPINE_C_API spine_atlas_region *spine_array_atlas_region_buffer(spine_array_atlas_region array);
SPINE_C_API spine_array_attachment spine_array_attachment_create(void);
@ -287,7 +289,7 @@ SPINE_C_API bool spine_array_attachment_contains(spine_array_attachment array, s
SPINE_C_API int spine_array_attachment_index_of(spine_array_attachment array, spine_attachment inValue);
SPINE_C_API spine_attachment * spine_array_attachment_buffer(spine_array_attachment array);
SPINE_C_API spine_attachment *spine_array_attachment_buffer(spine_array_attachment array);
SPINE_C_API spine_array_bone spine_array_bone_create(void);
@ -315,7 +317,7 @@ SPINE_C_API bool spine_array_bone_contains(spine_array_bone array, spine_bone in
SPINE_C_API int spine_array_bone_index_of(spine_array_bone array, spine_bone inValue);
SPINE_C_API spine_bone * spine_array_bone_buffer(spine_array_bone array);
SPINE_C_API spine_bone *spine_array_bone_buffer(spine_array_bone array);
SPINE_C_API spine_array_bone_data spine_array_bone_data_create(void);
@ -343,7 +345,7 @@ SPINE_C_API bool spine_array_bone_data_contains(spine_array_bone_data array, spi
SPINE_C_API int spine_array_bone_data_index_of(spine_array_bone_data array, spine_bone_data inValue);
SPINE_C_API spine_bone_data * spine_array_bone_data_buffer(spine_array_bone_data array);
SPINE_C_API spine_bone_data *spine_array_bone_data_buffer(spine_array_bone_data array);
SPINE_C_API spine_array_bone_pose spine_array_bone_pose_create(void);
@ -371,7 +373,7 @@ SPINE_C_API bool spine_array_bone_pose_contains(spine_array_bone_pose array, spi
SPINE_C_API int spine_array_bone_pose_index_of(spine_array_bone_pose array, spine_bone_pose inValue);
SPINE_C_API spine_bone_pose * spine_array_bone_pose_buffer(spine_array_bone_pose array);
SPINE_C_API spine_bone_pose *spine_array_bone_pose_buffer(spine_array_bone_pose array);
SPINE_C_API spine_array_bounding_box_attachment spine_array_bounding_box_attachment_create(void);
@ -383,7 +385,9 @@ SPINE_C_API size_t spine_array_bounding_box_attachment_get_capacity(spine_array_
SPINE_C_API size_t spine_array_bounding_box_attachment_size(spine_array_bounding_box_attachment array);
SPINE_C_API spine_array_bounding_box_attachment spine_array_bounding_box_attachment_set_size(spine_array_bounding_box_attachment array, size_t newSize, spine_bounding_box_attachment defaultValue);
SPINE_C_API spine_array_bounding_box_attachment spine_array_bounding_box_attachment_set_size(spine_array_bounding_box_attachment array,
size_t newSize,
spine_bounding_box_attachment defaultValue);
SPINE_C_API void spine_array_bounding_box_attachment_ensure_capacity(spine_array_bounding_box_attachment array, size_t newCapacity);
@ -391,7 +395,8 @@ SPINE_C_API void spine_array_bounding_box_attachment_add(spine_array_bounding_bo
SPINE_C_API void spine_array_bounding_box_attachment_add_all(spine_array_bounding_box_attachment array, spine_array_bounding_box_attachment inValue);
SPINE_C_API void spine_array_bounding_box_attachment_clear_and_add_all(spine_array_bounding_box_attachment array, spine_array_bounding_box_attachment inValue);
SPINE_C_API void spine_array_bounding_box_attachment_clear_and_add_all(spine_array_bounding_box_attachment array,
spine_array_bounding_box_attachment inValue);
SPINE_C_API void spine_array_bounding_box_attachment_remove_at(spine_array_bounding_box_attachment array, size_t inIndex);
@ -399,7 +404,7 @@ SPINE_C_API bool spine_array_bounding_box_attachment_contains(spine_array_boundi
SPINE_C_API int spine_array_bounding_box_attachment_index_of(spine_array_bounding_box_attachment array, spine_bounding_box_attachment inValue);
SPINE_C_API spine_bounding_box_attachment * spine_array_bounding_box_attachment_buffer(spine_array_bounding_box_attachment array);
SPINE_C_API spine_bounding_box_attachment *spine_array_bounding_box_attachment_buffer(spine_array_bounding_box_attachment array);
SPINE_C_API spine_array_constraint spine_array_constraint_create(void);
@ -427,7 +432,7 @@ SPINE_C_API bool spine_array_constraint_contains(spine_array_constraint array, s
SPINE_C_API int spine_array_constraint_index_of(spine_array_constraint array, spine_constraint inValue);
SPINE_C_API spine_constraint * spine_array_constraint_buffer(spine_array_constraint array);
SPINE_C_API spine_constraint *spine_array_constraint_buffer(spine_array_constraint array);
SPINE_C_API spine_array_constraint_data spine_array_constraint_data_create(void);
@ -439,7 +444,8 @@ SPINE_C_API size_t spine_array_constraint_data_get_capacity(spine_array_constrai
SPINE_C_API size_t spine_array_constraint_data_size(spine_array_constraint_data array);
SPINE_C_API spine_array_constraint_data spine_array_constraint_data_set_size(spine_array_constraint_data array, size_t newSize, spine_constraint_data defaultValue);
SPINE_C_API spine_array_constraint_data spine_array_constraint_data_set_size(spine_array_constraint_data array, size_t newSize,
spine_constraint_data defaultValue);
SPINE_C_API void spine_array_constraint_data_ensure_capacity(spine_array_constraint_data array, size_t newCapacity);
@ -455,7 +461,7 @@ SPINE_C_API bool spine_array_constraint_data_contains(spine_array_constraint_dat
SPINE_C_API int spine_array_constraint_data_index_of(spine_array_constraint_data array, spine_constraint_data inValue);
SPINE_C_API spine_constraint_data * spine_array_constraint_data_buffer(spine_array_constraint_data array);
SPINE_C_API spine_constraint_data *spine_array_constraint_data_buffer(spine_array_constraint_data array);
SPINE_C_API spine_array_event spine_array_event_create(void);
@ -483,7 +489,7 @@ SPINE_C_API bool spine_array_event_contains(spine_array_event array, spine_event
SPINE_C_API int spine_array_event_index_of(spine_array_event array, spine_event inValue);
SPINE_C_API spine_event * spine_array_event_buffer(spine_array_event array);
SPINE_C_API spine_event *spine_array_event_buffer(spine_array_event array);
SPINE_C_API spine_array_event_data spine_array_event_data_create(void);
@ -511,7 +517,7 @@ SPINE_C_API bool spine_array_event_data_contains(spine_array_event_data array, s
SPINE_C_API int spine_array_event_data_index_of(spine_array_event_data array, spine_event_data inValue);
SPINE_C_API spine_event_data * spine_array_event_data_buffer(spine_array_event_data array);
SPINE_C_API spine_event_data *spine_array_event_data_buffer(spine_array_event_data array);
SPINE_C_API spine_array_from_property spine_array_from_property_create(void);
@ -523,7 +529,8 @@ SPINE_C_API size_t spine_array_from_property_get_capacity(spine_array_from_prope
SPINE_C_API size_t spine_array_from_property_size(spine_array_from_property array);
SPINE_C_API spine_array_from_property spine_array_from_property_set_size(spine_array_from_property array, size_t newSize, spine_from_property defaultValue);
SPINE_C_API spine_array_from_property spine_array_from_property_set_size(spine_array_from_property array, size_t newSize,
spine_from_property defaultValue);
SPINE_C_API void spine_array_from_property_ensure_capacity(spine_array_from_property array, size_t newCapacity);
@ -539,7 +546,7 @@ SPINE_C_API bool spine_array_from_property_contains(spine_array_from_property ar
SPINE_C_API int spine_array_from_property_index_of(spine_array_from_property array, spine_from_property inValue);
SPINE_C_API spine_from_property * spine_array_from_property_buffer(spine_array_from_property array);
SPINE_C_API spine_from_property *spine_array_from_property_buffer(spine_array_from_property array);
SPINE_C_API spine_array_physics_constraint spine_array_physics_constraint_create(void);
@ -551,7 +558,8 @@ SPINE_C_API size_t spine_array_physics_constraint_get_capacity(spine_array_physi
SPINE_C_API size_t spine_array_physics_constraint_size(spine_array_physics_constraint array);
SPINE_C_API spine_array_physics_constraint spine_array_physics_constraint_set_size(spine_array_physics_constraint array, size_t newSize, spine_physics_constraint defaultValue);
SPINE_C_API spine_array_physics_constraint spine_array_physics_constraint_set_size(spine_array_physics_constraint array, size_t newSize,
spine_physics_constraint defaultValue);
SPINE_C_API void spine_array_physics_constraint_ensure_capacity(spine_array_physics_constraint array, size_t newCapacity);
@ -567,7 +575,7 @@ SPINE_C_API bool spine_array_physics_constraint_contains(spine_array_physics_con
SPINE_C_API int spine_array_physics_constraint_index_of(spine_array_physics_constraint array, spine_physics_constraint inValue);
SPINE_C_API spine_physics_constraint * spine_array_physics_constraint_buffer(spine_array_physics_constraint array);
SPINE_C_API spine_physics_constraint *spine_array_physics_constraint_buffer(spine_array_physics_constraint array);
SPINE_C_API spine_array_polygon spine_array_polygon_create(void);
@ -595,7 +603,7 @@ SPINE_C_API bool spine_array_polygon_contains(spine_array_polygon array, spine_p
SPINE_C_API int spine_array_polygon_index_of(spine_array_polygon array, spine_polygon inValue);
SPINE_C_API spine_polygon * spine_array_polygon_buffer(spine_array_polygon array);
SPINE_C_API spine_polygon *spine_array_polygon_buffer(spine_array_polygon array);
SPINE_C_API spine_array_skin spine_array_skin_create(void);
@ -623,7 +631,7 @@ SPINE_C_API bool spine_array_skin_contains(spine_array_skin array, spine_skin in
SPINE_C_API int spine_array_skin_index_of(spine_array_skin array, spine_skin inValue);
SPINE_C_API spine_skin * spine_array_skin_buffer(spine_array_skin array);
SPINE_C_API spine_skin *spine_array_skin_buffer(spine_array_skin array);
SPINE_C_API spine_array_slot spine_array_slot_create(void);
@ -651,7 +659,7 @@ SPINE_C_API bool spine_array_slot_contains(spine_array_slot array, spine_slot in
SPINE_C_API int spine_array_slot_index_of(spine_array_slot array, spine_slot inValue);
SPINE_C_API spine_slot * spine_array_slot_buffer(spine_array_slot array);
SPINE_C_API spine_slot *spine_array_slot_buffer(spine_array_slot array);
SPINE_C_API spine_array_slot_data spine_array_slot_data_create(void);
@ -679,7 +687,7 @@ SPINE_C_API bool spine_array_slot_data_contains(spine_array_slot_data array, spi
SPINE_C_API int spine_array_slot_data_index_of(spine_array_slot_data array, spine_slot_data inValue);
SPINE_C_API spine_slot_data * spine_array_slot_data_buffer(spine_array_slot_data array);
SPINE_C_API spine_slot_data *spine_array_slot_data_buffer(spine_array_slot_data array);
SPINE_C_API spine_array_texture_region spine_array_texture_region_create(void);
@ -691,7 +699,8 @@ SPINE_C_API size_t spine_array_texture_region_get_capacity(spine_array_texture_r
SPINE_C_API size_t spine_array_texture_region_size(spine_array_texture_region array);
SPINE_C_API spine_array_texture_region spine_array_texture_region_set_size(spine_array_texture_region array, size_t newSize, spine_texture_region defaultValue);
SPINE_C_API spine_array_texture_region spine_array_texture_region_set_size(spine_array_texture_region array, size_t newSize,
spine_texture_region defaultValue);
SPINE_C_API void spine_array_texture_region_ensure_capacity(spine_array_texture_region array, size_t newCapacity);
@ -707,7 +716,7 @@ SPINE_C_API bool spine_array_texture_region_contains(spine_array_texture_region
SPINE_C_API int spine_array_texture_region_index_of(spine_array_texture_region array, spine_texture_region inValue);
SPINE_C_API spine_texture_region * spine_array_texture_region_buffer(spine_array_texture_region array);
SPINE_C_API spine_texture_region *spine_array_texture_region_buffer(spine_array_texture_region array);
SPINE_C_API spine_array_timeline spine_array_timeline_create(void);
@ -735,7 +744,7 @@ SPINE_C_API bool spine_array_timeline_contains(spine_array_timeline array, spine
SPINE_C_API int spine_array_timeline_index_of(spine_array_timeline array, spine_timeline inValue);
SPINE_C_API spine_timeline * spine_array_timeline_buffer(spine_array_timeline array);
SPINE_C_API spine_timeline *spine_array_timeline_buffer(spine_array_timeline array);
SPINE_C_API spine_array_to_property spine_array_to_property_create(void);
@ -763,7 +772,7 @@ SPINE_C_API bool spine_array_to_property_contains(spine_array_to_property array,
SPINE_C_API int spine_array_to_property_index_of(spine_array_to_property array, spine_to_property inValue);
SPINE_C_API spine_to_property * spine_array_to_property_buffer(spine_array_to_property array);
SPINE_C_API spine_to_property *spine_array_to_property_buffer(spine_array_to_property array);
SPINE_C_API spine_array_track_entry spine_array_track_entry_create(void);
@ -791,7 +800,7 @@ SPINE_C_API bool spine_array_track_entry_contains(spine_array_track_entry array,
SPINE_C_API int spine_array_track_entry_index_of(spine_array_track_entry array, spine_track_entry inValue);
SPINE_C_API spine_track_entry * spine_array_track_entry_buffer(spine_array_track_entry array);
SPINE_C_API spine_track_entry *spine_array_track_entry_buffer(spine_array_track_entry array);
SPINE_C_API spine_array_update spine_array_update_create(void);
@ -819,7 +828,7 @@ SPINE_C_API bool spine_array_update_contains(spine_array_update array, spine_upd
SPINE_C_API int spine_array_update_index_of(spine_array_update array, spine_update inValue);
SPINE_C_API spine_update * spine_array_update_buffer(spine_array_update array);
SPINE_C_API spine_update *spine_array_update_buffer(spine_array_update array);
#ifdef __cplusplus
}

16
spine-c/src/generated/atlas.cpp
View File

@ -4,21 +4,25 @@
using namespace spine;
void spine_atlas_dispose(spine_atlas self) {
delete (Atlas*)self;
delete (Atlas *) self;
}
void spine_atlas_flip_v(spine_atlas self) {
((Atlas*)self)->flipV();
Atlas *_self = (Atlas *) self;
_self->flipV();
}
spine_atlas_region spine_atlas_find_region(spine_atlas self, const char * name) {
return (spine_atlas_region)((Atlas*)self)->findRegion(String(name));
spine_atlas_region spine_atlas_find_region(spine_atlas self, const char *name) {
Atlas *_self = (Atlas *) self;
return (spine_atlas_region) _self->findRegion(String(name));
}
spine_array_atlas_page spine_atlas_get_pages(spine_atlas self) {
return (spine_array_atlas_page)&((Atlas*)self)->getPages();
Atlas *_self = (Atlas *) self;
return (spine_array_atlas_page) &_self->getPages();
}
spine_array_atlas_region spine_atlas_get_regions(spine_atlas self) {
return (spine_array_atlas_region)&((Atlas*)self)->getRegions();
Atlas *_self = (Atlas *) self;
return (spine_array_atlas_region) &_self->getRegions();
}

2
spine-c/src/generated/atlas.h
View File

@ -11,7 +11,7 @@ extern "C" {
SPINE_C_API void spine_atlas_dispose(spine_atlas self);
SPINE_C_API void spine_atlas_flip_v(spine_atlas self);
SPINE_C_API spine_atlas_region spine_atlas_find_region(spine_atlas self, const char * name);
SPINE_C_API spine_atlas_region spine_atlas_find_region(spine_atlas self, const char *name);
SPINE_C_API spine_array_atlas_page spine_atlas_get_pages(spine_atlas self);
SPINE_C_API spine_array_atlas_region spine_atlas_get_regions(spine_atlas self);

43
spine-c/src/generated/atlas_attachment_loader.cpp
View File

@ -4,37 +4,48 @@
using namespace spine;
spine_atlas_attachment_loader spine_atlas_attachment_loader_create(spine_atlas atlas) {
return (spine_atlas_attachment_loader) new (__FILE__, __LINE__) AtlasAttachmentLoader((Atlas *)atlas);
return (spine_atlas_attachment_loader) new (__FILE__, __LINE__) AtlasAttachmentLoader((Atlas *) atlas);
}
void spine_atlas_attachment_loader_dispose(spine_atlas_attachment_loader self) {
delete (AtlasAttachmentLoader*)self;
delete (AtlasAttachmentLoader *) self;
}
spine_region_attachment spine_atlas_attachment_loader_new_region_attachment(spine_atlas_attachment_loader self, spine_skin skin, const char * name, const char * path, spine_sequence sequence) {
return (spine_region_attachment)((AtlasAttachmentLoader*)self)->newRegionAttachment(*((Skin*)skin), String(name), String(path), (Sequence *)sequence);
spine_region_attachment spine_atlas_attachment_loader_new_region_attachment(spine_atlas_attachment_loader self, spine_skin skin, const char *name,
const char *path, spine_sequence sequence) {
AtlasAttachmentLoader *_self = (AtlasAttachmentLoader *) self;
return (spine_region_attachment) _self->newRegionAttachment(*((Skin *) skin), String(name), String(path), (Sequence *) sequence);
}
spine_mesh_attachment spine_atlas_attachment_loader_new_mesh_attachment(spine_atlas_attachment_loader self, spine_skin skin, const char * name, const char * path, spine_sequence sequence) {
return (spine_mesh_attachment)((AtlasAttachmentLoader*)self)->newMeshAttachment(*((Skin*)skin), String(name), String(path), (Sequence *)sequence);
spine_mesh_attachment spine_atlas_attachment_loader_new_mesh_attachment(spine_atlas_attachment_loader self, spine_skin skin, const char *name,
const char *path, spine_sequence sequence) {
AtlasAttachmentLoader *_self = (AtlasAttachmentLoader *) self;
return (spine_mesh_attachment) _self->newMeshAttachment(*((Skin *) skin), String(name), String(path), (Sequence *) sequence);
}
spine_bounding_box_attachment spine_atlas_attachment_loader_new_bounding_box_attachment(spine_atlas_attachment_loader self, spine_skin skin, const char * name) {
return (spine_bounding_box_attachment)((AtlasAttachmentLoader*)self)->newBoundingBoxAttachment(*((Skin*)skin), String(name));
spine_bounding_box_attachment spine_atlas_attachment_loader_new_bounding_box_attachment(spine_atlas_attachment_loader self, spine_skin skin,
const char *name) {
AtlasAttachmentLoader *_self = (AtlasAttachmentLoader *) self;
return (spine_bounding_box_attachment) _self->newBoundingBoxAttachment(*((Skin *) skin), String(name));
}
spine_path_attachment spine_atlas_attachment_loader_new_path_attachment(spine_atlas_attachment_loader self, spine_skin skin, const char * name) {
return (spine_path_attachment)((AtlasAttachmentLoader*)self)->newPathAttachment(*((Skin*)skin), String(name));
spine_path_attachment spine_atlas_attachment_loader_new_path_attachment(spine_atlas_attachment_loader self, spine_skin skin, const char *name) {
AtlasAttachmentLoader *_self = (AtlasAttachmentLoader *) self;
return (spine_path_attachment) _self->newPathAttachment(*((Skin *) skin), String(name));
}
spine_point_attachment spine_atlas_attachment_loader_new_point_attachment(spine_atlas_attachment_loader self, spine_skin skin, const char * name) {
return (spine_point_attachment)((AtlasAttachmentLoader*)self)->newPointAttachment(*((Skin*)skin), String(name));
spine_point_attachment spine_atlas_attachment_loader_new_point_attachment(spine_atlas_attachment_loader self, spine_skin skin, const char *name) {
AtlasAttachmentLoader *_self = (AtlasAttachmentLoader *) self;
return (spine_point_attachment) _self->newPointAttachment(*((Skin *) skin), String(name));
}
spine_clipping_attachment spine_atlas_attachment_loader_new_clipping_attachment(spine_atlas_attachment_loader self, spine_skin skin, const char * name) {
return (spine_clipping_attachment)((AtlasAttachmentLoader*)self)->newClippingAttachment(*((Skin*)skin), String(name));
spine_clipping_attachment spine_atlas_attachment_loader_new_clipping_attachment(spine_atlas_attachment_loader self, spine_skin skin,
const char *name) {
AtlasAttachmentLoader *_self = (AtlasAttachmentLoader *) self;
return (spine_clipping_attachment) _self->newClippingAttachment(*((Skin *) skin), String(name));
}
spine_atlas_region spine_atlas_attachment_loader_find_region(spine_atlas_attachment_loader self, const char * name) {
return (spine_atlas_region)((AtlasAttachmentLoader*)self)->findRegion(String(name));
spine_atlas_region spine_atlas_attachment_loader_find_region(spine_atlas_attachment_loader self, const char *name) {
AtlasAttachmentLoader *_self = (AtlasAttachmentLoader *) self;
return (spine_atlas_region) _self->findRegion(String(name));
}

20
spine-c/src/generated/atlas_attachment_loader.h
View File

@ -12,13 +12,19 @@ SPINE_C_API spine_atlas_attachment_loader spine_atlas_attachment_loader_create(s
SPINE_C_API void spine_atlas_attachment_loader_dispose(spine_atlas_attachment_loader self);
SPINE_C_API spine_region_attachment spine_atlas_attachment_loader_new_region_attachment(spine_atlas_attachment_loader self, spine_skin skin, const char * name, const char * path, spine_sequence sequence);
SPINE_C_API spine_mesh_attachment spine_atlas_attachment_loader_new_mesh_attachment(spine_atlas_attachment_loader self, spine_skin skin, const char * name, const char * path, spine_sequence sequence);
SPINE_C_API spine_bounding_box_attachment spine_atlas_attachment_loader_new_bounding_box_attachment(spine_atlas_attachment_loader self, spine_skin skin, const char * name);
SPINE_C_API spine_path_attachment spine_atlas_attachment_loader_new_path_attachment(spine_atlas_attachment_loader self, spine_skin skin, const char * name);
SPINE_C_API spine_point_attachment spine_atlas_attachment_loader_new_point_attachment(spine_atlas_attachment_loader self, spine_skin skin, const char * name);
SPINE_C_API spine_clipping_attachment spine_atlas_attachment_loader_new_clipping_attachment(spine_atlas_attachment_loader self, spine_skin skin, const char * name);
SPINE_C_API spine_atlas_region spine_atlas_attachment_loader_find_region(spine_atlas_attachment_loader self, const char * name);
SPINE_C_API spine_region_attachment spine_atlas_attachment_loader_new_region_attachment(spine_atlas_attachment_loader self, spine_skin skin,
const char *name, const char *path, spine_sequence sequence);
SPINE_C_API spine_mesh_attachment spine_atlas_attachment_loader_new_mesh_attachment(spine_atlas_attachment_loader self, spine_skin skin,
const char *name, const char *path, spine_sequence sequence);
SPINE_C_API spine_bounding_box_attachment spine_atlas_attachment_loader_new_bounding_box_attachment(spine_atlas_attachment_loader self,
spine_skin skin, const char *name);
SPINE_C_API spine_path_attachment spine_atlas_attachment_loader_new_path_attachment(spine_atlas_attachment_loader self, spine_skin skin,
const char *name);
SPINE_C_API spine_point_attachment spine_atlas_attachment_loader_new_point_attachment(spine_atlas_attachment_loader self, spine_skin skin,
const char *name);
SPINE_C_API spine_clipping_attachment spine_atlas_attachment_loader_new_clipping_attachment(spine_atlas_attachment_loader self, spine_skin skin,
const char *name);
SPINE_C_API spine_atlas_region spine_atlas_attachment_loader_find_region(spine_atlas_attachment_loader self, const char *name);
#ifdef __cplusplus
}

90
spine-c/src/generated/atlas_page.cpp
View File

@ -3,106 +3,130 @@
using namespace spine;
spine_atlas_page spine_atlas_page_create(const char * inName) {
return (spine_atlas_page) new (__FILE__, __LINE__) AtlasPage(String(inName));
spine_atlas_page spine_atlas_page_create(const char *inName) {
return (spine_atlas_page) new (__FILE__, __LINE__) AtlasPage(String(inName));
}
void spine_atlas_page_dispose(spine_atlas_page self) {
delete (AtlasPage*)self;
delete (AtlasPage *) self;
}
const char * spine_atlas_page_get_name(spine_atlas_page self) {
return ((AtlasPage*)self)->name.buffer();
const char *spine_atlas_page_get_name(spine_atlas_page self) {
AtlasPage *_self = (AtlasPage *) self;
return _self->name.buffer();
}
void spine_atlas_page_set_name(spine_atlas_page self, const char * value) {
((AtlasPage*)self)->name = String(value);
void spine_atlas_page_set_name(spine_atlas_page self, const char *value) {
AtlasPage *_self = (AtlasPage *) self;
_self->name = String(value);
}
const char * spine_atlas_page_get_texture_path(spine_atlas_page self) {
return ((AtlasPage*)self)->texturePath.buffer();
const char *spine_atlas_page_get_texture_path(spine_atlas_page self) {
AtlasPage *_self = (AtlasPage *) self;
return _self->texturePath.buffer();
}
void spine_atlas_page_set_texture_path(spine_atlas_page self, const char * value) {
((AtlasPage*)self)->texturePath = String(value);
void spine_atlas_page_set_texture_path(spine_atlas_page self, const char *value) {
AtlasPage *_self = (AtlasPage *) self;
_self->texturePath = String(value);
}
spine_format spine_atlas_page_get_format(spine_atlas_page self) {
return (spine_format)((AtlasPage*)self)->format;
AtlasPage *_self = (AtlasPage *) self;
return (spine_format) _self->format;
}
void spine_atlas_page_set_format(spine_atlas_page self, spine_format value) {
((AtlasPage*)self)->format = (Format)value;
AtlasPage *_self = (AtlasPage *) self;
_self->format = (Format) value;
}
spine_texture_filter spine_atlas_page_get_min_filter(spine_atlas_page self) {
return (spine_texture_filter)((AtlasPage*)self)->minFilter;
AtlasPage *_self = (AtlasPage *) self;
return (spine_texture_filter) _self->minFilter;
}
void spine_atlas_page_set_min_filter(spine_atlas_page self, spine_texture_filter value) {
((AtlasPage*)self)->minFilter = (TextureFilter)value;
AtlasPage *_self = (AtlasPage *) self;
_self->minFilter = (TextureFilter) value;
}
spine_texture_filter spine_atlas_page_get_mag_filter(spine_atlas_page self) {
return (spine_texture_filter)((AtlasPage*)self)->magFilter;
AtlasPage *_self = (AtlasPage *) self;
return (spine_texture_filter) _self->magFilter;
}
void spine_atlas_page_set_mag_filter(spine_atlas_page self, spine_texture_filter value) {
((AtlasPage*)self)->magFilter = (TextureFilter)value;
AtlasPage *_self = (AtlasPage *) self;
_self->magFilter = (TextureFilter) value;
}
spine_texture_wrap spine_atlas_page_get_u_wrap(spine_atlas_page self) {
return (spine_texture_wrap)((AtlasPage*)self)->uWrap;
AtlasPage *_self = (AtlasPage *) self;
return (spine_texture_wrap) _self->uWrap;
}
void spine_atlas_page_set_u_wrap(spine_atlas_page self, spine_texture_wrap value) {
((AtlasPage*)self)->uWrap = (TextureWrap)value;
AtlasPage *_self = (AtlasPage *) self;
_self->uWrap = (TextureWrap) value;
}
spine_texture_wrap spine_atlas_page_get_v_wrap(spine_atlas_page self) {
return (spine_texture_wrap)((AtlasPage*)self)->vWrap;
AtlasPage *_self = (AtlasPage *) self;
return (spine_texture_wrap) _self->vWrap;
}
void spine_atlas_page_set_v_wrap(spine_atlas_page self, spine_texture_wrap value) {
((AtlasPage*)self)->vWrap = (TextureWrap)value;
AtlasPage *_self = (AtlasPage *) self;
_self->vWrap = (TextureWrap) value;
}
int spine_atlas_page_get_width(spine_atlas_page self) {
return ((AtlasPage*)self)->width;
AtlasPage *_self = (AtlasPage *) self;
return _self->width;
}
void spine_atlas_page_set_width(spine_atlas_page self, int value) {
((AtlasPage*)self)->width = value;
AtlasPage *_self = (AtlasPage *) self;
_self->width = value;
}
int spine_atlas_page_get_height(spine_atlas_page self) {
return ((AtlasPage*)self)->height;
AtlasPage *_self = (AtlasPage *) self;
return _self->height;
}
void spine_atlas_page_set_height(spine_atlas_page self, int value) {
((AtlasPage*)self)->height = value;
AtlasPage *_self = (AtlasPage *) self;
_self->height = value;
}
bool spine_atlas_page_get_pma(spine_atlas_page self) {
return ((AtlasPage*)self)->pma;
AtlasPage *_self = (AtlasPage *) self;
return _self->pma;
}
void spine_atlas_page_set_pma(spine_atlas_page self, bool value) {
((AtlasPage*)self)->pma = value;
AtlasPage *_self = (AtlasPage *) self;
_self->pma = value;
}
int spine_atlas_page_get_index(spine_atlas_page self) {
return ((AtlasPage*)self)->index;
AtlasPage *_self = (AtlasPage *) self;
return _self->index;
}
void spine_atlas_page_set_index(spine_atlas_page self, int value) {
((AtlasPage*)self)->index = value;
AtlasPage *_self = (AtlasPage *) self;
_self->index = value;
}
void * spine_atlas_page_get_texture(spine_atlas_page self) {
return ((AtlasPage*)self)->texture;
void *spine_atlas_page_get_texture(spine_atlas_page self) {
AtlasPage *_self = (AtlasPage *) self;
return _self->texture;
}
void spine_atlas_page_set_texture(spine_atlas_page self, void * value) {
((AtlasPage*)self)->texture = (void*)value;
void spine_atlas_page_set_texture(spine_atlas_page self, void *value) {
AtlasPage *_self = (AtlasPage *) self;
_self->texture = (void *) value;
}

14
spine-c/src/generated/atlas_page.h
View File

@ -8,14 +8,14 @@
extern "C" {
#endif
SPINE_C_API spine_atlas_page spine_atlas_page_create(const char * inName);
SPINE_C_API spine_atlas_page spine_atlas_page_create(const char *inName);
SPINE_C_API void spine_atlas_page_dispose(spine_atlas_page self);
SPINE_C_API const char * spine_atlas_page_get_name(spine_atlas_page self);
SPINE_C_API void spine_atlas_page_set_name(spine_atlas_page self, const char * value);
SPINE_C_API const char * spine_atlas_page_get_texture_path(spine_atlas_page self);
SPINE_C_API void spine_atlas_page_set_texture_path(spine_atlas_page self, const char * value);
SPINE_C_API const char *spine_atlas_page_get_name(spine_atlas_page self);
SPINE_C_API void spine_atlas_page_set_name(spine_atlas_page self, const char *value);
SPINE_C_API const char *spine_atlas_page_get_texture_path(spine_atlas_page self);
SPINE_C_API void spine_atlas_page_set_texture_path(spine_atlas_page self, const char *value);
SPINE_C_API spine_format spine_atlas_page_get_format(spine_atlas_page self);
SPINE_C_API void spine_atlas_page_set_format(spine_atlas_page self, spine_format value);
SPINE_C_API spine_texture_filter spine_atlas_page_get_min_filter(spine_atlas_page self);
@ -34,8 +34,8 @@ SPINE_C_API bool spine_atlas_page_get_pma(spine_atlas_page self);
SPINE_C_API void spine_atlas_page_set_pma(spine_atlas_page self, bool value);
SPINE_C_API int spine_atlas_page_get_index(spine_atlas_page self);
SPINE_C_API void spine_atlas_page_set_index(spine_atlas_page self, int value);
SPINE_C_API void * spine_atlas_page_get_texture(spine_atlas_page self);
SPINE_C_API void spine_atlas_page_set_texture(spine_atlas_page self, void * value);
SPINE_C_API void *spine_atlas_page_get_texture(spine_atlas_page self);
SPINE_C_API void spine_atlas_page_set_texture(spine_atlas_page self, void *value);
#ifdef __cplusplus
}

140
spine-c/src/generated/atlas_region.cpp
View File

@ -4,189 +4,233 @@
using namespace spine;
spine_atlas_region spine_atlas_region_create(void) {
return (spine_atlas_region) new (__FILE__, __LINE__) AtlasRegion();
return (spine_atlas_region) new (__FILE__, __LINE__) AtlasRegion();
}
void spine_atlas_region_dispose(spine_atlas_region self) {
delete (AtlasRegion*)self;
delete (AtlasRegion *) self;
}
spine_rtti spine_atlas_region_get_rtti(spine_atlas_region self) {
return (spine_rtti)&((AtlasRegion*)self)->getRTTI();
AtlasRegion *_self = (AtlasRegion *) self;
return (spine_rtti) &_self->getRTTI();
}
spine_atlas_page spine_atlas_region_get_page(spine_atlas_region self) {
return (spine_atlas_page)((AtlasRegion*)self)->getPage();
AtlasRegion *_self = (AtlasRegion *) self;
return (spine_atlas_page) _self->getPage();
}
int spine_atlas_region_get_index(spine_atlas_region self) {
return ((AtlasRegion*)self)->getIndex();
AtlasRegion *_self = (AtlasRegion *) self;
return _self->getIndex();
}
int spine_atlas_region_get_x(spine_atlas_region self) {
return ((AtlasRegion*)self)->getX();
AtlasRegion *_self = (AtlasRegion *) self;
return _self->getX();
}
int spine_atlas_region_get_y(spine_atlas_region self) {
return ((AtlasRegion*)self)->getY();
AtlasRegion *_self = (AtlasRegion *) self;
return _self->getY();
}
float spine_atlas_region_get_offset_x(spine_atlas_region self) {
return ((AtlasRegion*)self)->getOffsetX();
AtlasRegion *_self = (AtlasRegion *) self;
return _self->getOffsetX();
}
float spine_atlas_region_get_offset_y(spine_atlas_region self) {
return ((AtlasRegion*)self)->getOffsetY();
AtlasRegion *_self = (AtlasRegion *) self;
return _self->getOffsetY();
}
int spine_atlas_region_get_packed_width(spine_atlas_region self) {
return ((AtlasRegion*)self)->getPackedWidth();
AtlasRegion *_self = (AtlasRegion *) self;
return _self->getPackedWidth();
}
int spine_atlas_region_get_packed_height(spine_atlas_region self) {
return ((AtlasRegion*)self)->getPackedHeight();
AtlasRegion *_self = (AtlasRegion *) self;
return _self->getPackedHeight();
}
int spine_atlas_region_get_original_width(spine_atlas_region self) {
return ((AtlasRegion*)self)->getOriginalWidth();
AtlasRegion *_self = (AtlasRegion *) self;
return _self->getOriginalWidth();
}
int spine_atlas_region_get_original_height(spine_atlas_region self) {
return ((AtlasRegion*)self)->getOriginalHeight();
AtlasRegion *_self = (AtlasRegion *) self;
return _self->getOriginalHeight();
}
bool spine_atlas_region_get_rotate(spine_atlas_region self) {
return ((AtlasRegion*)self)->getRotate();
AtlasRegion *_self = (AtlasRegion *) self;
return _self->getRotate();
}
int spine_atlas_region_get_degrees(spine_atlas_region self) {
return ((AtlasRegion*)self)->getDegrees();
AtlasRegion *_self = (AtlasRegion *) self;
return _self->getDegrees();
}
spine_array_int spine_atlas_region_get_splits(spine_atlas_region self) {
return (spine_array_int)&((AtlasRegion*)self)->getSplits();
AtlasRegion *_self = (AtlasRegion *) self;
return (spine_array_int) &_self->getSplits();
}
spine_array_int spine_atlas_region_get_pads(spine_atlas_region self) {
return (spine_array_int)&((AtlasRegion*)self)->getPads();
AtlasRegion *_self = (AtlasRegion *) self;
return (spine_array_int) &_self->getPads();
}
spine_array_float spine_atlas_region_get_values(spine_atlas_region self) {
return (spine_array_float)&((AtlasRegion*)self)->getValues();
AtlasRegion *_self = (AtlasRegion *) self;
return (spine_array_float) &_self->getValues();
}
void spine_atlas_region_set_page(spine_atlas_region self, spine_atlas_page value) {
((AtlasRegion*)self)->setPage((AtlasPage *)value);
AtlasRegion *_self = (AtlasRegion *) self;
_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_name(spine_atlas_region self, const char *value) {
AtlasRegion *_self = (AtlasRegion *) self;
_self->setName(String(value));
}
void spine_atlas_region_set_index(spine_atlas_region self, int value) {
((AtlasRegion*)self)->setIndex(value);
AtlasRegion *_self = (AtlasRegion *) self;
_self->setIndex(value);
}
void spine_atlas_region_set_x(spine_atlas_region self, int value) {
((AtlasRegion*)self)->setX(value);
AtlasRegion *_self = (AtlasRegion *) self;
_self->setX(value);
}
void spine_atlas_region_set_y(spine_atlas_region self, int value) {
((AtlasRegion*)self)->setY(value);
AtlasRegion *_self = (AtlasRegion *) self;
_self->setY(value);
}
void spine_atlas_region_set_offset_x(spine_atlas_region self, float value) {
((AtlasRegion*)self)->setOffsetX(value);
AtlasRegion *_self = (AtlasRegion *) self;
_self->setOffsetX(value);
}
void spine_atlas_region_set_offset_y(spine_atlas_region self, float value) {
((AtlasRegion*)self)->setOffsetY(value);
AtlasRegion *_self = (AtlasRegion *) self;
_self->setOffsetY(value);
}
void spine_atlas_region_set_packed_width(spine_atlas_region self, int value) {
((AtlasRegion*)self)->setPackedWidth(value);
AtlasRegion *_self = (AtlasRegion *) self;
_self->setPackedWidth(value);
}
void spine_atlas_region_set_packed_height(spine_atlas_region self, int value) {
((AtlasRegion*)self)->setPackedHeight(value);
AtlasRegion *_self = (AtlasRegion *) self;
_self->setPackedHeight(value);
}
void spine_atlas_region_set_original_width(spine_atlas_region self, int value) {
((AtlasRegion*)self)->setOriginalWidth(value);
AtlasRegion *_self = (AtlasRegion *) self;
_self->setOriginalWidth(value);
}
void spine_atlas_region_set_original_height(spine_atlas_region self, int value) {
((AtlasRegion*)self)->setOriginalHeight(value);
AtlasRegion *_self = (AtlasRegion *) self;
_self->setOriginalHeight(value);
}
void spine_atlas_region_set_rotate(spine_atlas_region self, bool value) {
((AtlasRegion*)self)->setRotate(value);
AtlasRegion *_self = (AtlasRegion *) self;
_self->setRotate(value);
}
void spine_atlas_region_set_degrees(spine_atlas_region self, int value) {
((AtlasRegion*)self)->setDegrees(value);
AtlasRegion *_self = (AtlasRegion *) self;
_self->setDegrees(value);
}
void spine_atlas_region_set_splits(spine_atlas_region self, spine_array_int value) {
((AtlasRegion*)self)->setSplits(*((const Array<int>*)value));
AtlasRegion *_self = (AtlasRegion *) self;
_self->setSplits(*((const Array<int> *) value));
}
void spine_atlas_region_set_pads(spine_atlas_region self, spine_array_int value) {
((AtlasRegion*)self)->setPads(*((const Array<int>*)value));
AtlasRegion *_self = (AtlasRegion *) self;
_self->setPads(*((const Array<int> *) value));
}
void spine_atlas_region_set_values(spine_atlas_region self, spine_array_float value) {
((AtlasRegion*)self)->setValues(*((const Array<float>*)value));
AtlasRegion *_self = (AtlasRegion *) self;
_self->setValues(*((const Array<float> *) value));
}
float spine_atlas_region_get_u(spine_atlas_region self) {
return ((TextureRegion*)(AtlasRegion*)self)->getU();
TextureRegion *_self = (TextureRegion *) (AtlasRegion *) self;
return _self->getU();
}
void spine_atlas_region_set_u(spine_atlas_region self, float value) {
((TextureRegion*)(AtlasRegion*)self)->setU(value);
TextureRegion *_self = (TextureRegion *) (AtlasRegion *) self;
_self->setU(value);
}
float spine_atlas_region_get_v(spine_atlas_region self) {
return ((TextureRegion*)(AtlasRegion*)self)->getV();
TextureRegion *_self = (TextureRegion *) (AtlasRegion *) self;
return _self->getV();
}
void spine_atlas_region_set_v(spine_atlas_region self, float value) {
((TextureRegion*)(AtlasRegion*)self)->setV(value);
TextureRegion *_self = (TextureRegion *) (AtlasRegion *) self;
_self->setV(value);
}
float spine_atlas_region_get_u2(spine_atlas_region self) {
return ((TextureRegion*)(AtlasRegion*)self)->getU2();
TextureRegion *_self = (TextureRegion *) (AtlasRegion *) self;
return _self->getU2();
}
void spine_atlas_region_set_u2(spine_atlas_region self, float value) {
((TextureRegion*)(AtlasRegion*)self)->setU2(value);
TextureRegion *_self = (TextureRegion *) (AtlasRegion *) self;
_self->setU2(value);
}
float spine_atlas_region_get_v2(spine_atlas_region self) {
return ((TextureRegion*)(AtlasRegion*)self)->getV2();
TextureRegion *_self = (TextureRegion *) (AtlasRegion *) self;
return _self->getV2();
}
void spine_atlas_region_set_v2(spine_atlas_region self, float value) {
((TextureRegion*)(AtlasRegion*)self)->setV2(value);
TextureRegion *_self = (TextureRegion *) (AtlasRegion *) self;
_self->setV2(value);
}
int spine_atlas_region_get_region_width(spine_atlas_region self) {
return ((TextureRegion*)(AtlasRegion*)self)->getRegionWidth();
TextureRegion *_self = (TextureRegion *) (AtlasRegion *) self;
return _self->getRegionWidth();
}
void spine_atlas_region_set_region_width(spine_atlas_region self, int value) {
((TextureRegion*)(AtlasRegion*)self)->setRegionWidth(value);
TextureRegion *_self = (TextureRegion *) (AtlasRegion *) self;
_self->setRegionWidth(value);
}
int spine_atlas_region_get_region_height(spine_atlas_region self) {
return ((TextureRegion*)(AtlasRegion*)self)->getRegionHeight();
TextureRegion *_self = (TextureRegion *) (AtlasRegion *) self;
return _self->getRegionHeight();
}
void spine_atlas_region_set_region_height(spine_atlas_region self, int value) {
((TextureRegion*)(AtlasRegion*)self)->setRegionHeight(value);
TextureRegion *_self = (TextureRegion *) (AtlasRegion *) self;
_self->setRegionHeight(value);
}
spine_rtti spine_atlas_region_rtti(void) {
return (spine_rtti)&AtlasRegion::rtti;
return (spine_rtti) &AtlasRegion::rtti;
}

2
spine-c/src/generated/atlas_region.h
View File

@ -29,7 +29,7 @@ SPINE_C_API spine_array_int spine_atlas_region_get_splits(spine_atlas_region sel
SPINE_C_API spine_array_int spine_atlas_region_get_pads(spine_atlas_region self);
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_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);

24
spine-c/src/generated/attachment.cpp
View File

@ -4,33 +4,39 @@
using namespace spine;
void spine_attachment_dispose(spine_attachment self) {
delete (Attachment*)self;
delete (Attachment *) self;
}
spine_rtti spine_attachment_get_rtti(spine_attachment self) {
return (spine_rtti)&((Attachment*)self)->getRTTI();
Attachment *_self = (Attachment *) self;
return (spine_rtti) &_self->getRTTI();
}
const char * spine_attachment_get_name(spine_attachment self) {
return ((Attachment*)self)->getName().buffer();
const char *spine_attachment_get_name(spine_attachment self) {
Attachment *_self = (Attachment *) self;
return _self->getName().buffer();
}
spine_attachment spine_attachment_copy(spine_attachment self) {
return (spine_attachment)((Attachment*)self)->copy();
Attachment *_self = (Attachment *) self;
return (spine_attachment) _self->copy();
}
int spine_attachment_get_ref_count(spine_attachment self) {
return ((Attachment*)self)->getRefCount();
Attachment *_self = (Attachment *) self;
return _self->getRefCount();
}
void spine_attachment_reference(spine_attachment self) {
((Attachment*)self)->reference();
Attachment *_self = (Attachment *) self;
_self->reference();
}
void spine_attachment_dereference(spine_attachment self) {
((Attachment*)self)->dereference();
Attachment *_self = (Attachment *) self;
_self->dereference();
}
spine_rtti spine_attachment_rtti(void) {
return (spine_rtti)&Attachment::rtti;
return (spine_rtti) &Attachment::rtti;
}

2
spine-c/src/generated/attachment.h
View File

@ -11,7 +11,7 @@ extern "C" {
SPINE_C_API void spine_attachment_dispose(spine_attachment self);
SPINE_C_API spine_rtti spine_attachment_get_rtti(spine_attachment self);
SPINE_C_API const char * spine_attachment_get_name(spine_attachment self);
SPINE_C_API const char *spine_attachment_get_name(spine_attachment self);
SPINE_C_API spine_attachment spine_attachment_copy(spine_attachment self);
SPINE_C_API int spine_attachment_get_ref_count(spine_attachment self);
SPINE_C_API void spine_attachment_reference(spine_attachment self);

34
spine-c/src/generated/attachment_loader.cpp
View File

@ -4,29 +4,37 @@
using namespace spine;
void spine_attachment_loader_dispose(spine_attachment_loader self) {
delete (AttachmentLoader*)self;
delete (AttachmentLoader *) self;
}
spine_region_attachment spine_attachment_loader_new_region_attachment(spine_attachment_loader self, spine_skin skin, const char * name, const char * path, spine_sequence sequence) {
return (spine_region_attachment)((AttachmentLoader*)self)->newRegionAttachment(*((Skin*)skin), String(name), String(path), (Sequence *)sequence);
spine_region_attachment spine_attachment_loader_new_region_attachment(spine_attachment_loader self, spine_skin skin, const char *name,
const char *path, spine_sequence sequence) {
AttachmentLoader *_self = (AttachmentLoader *) self;
return (spine_region_attachment) _self->newRegionAttachment(*((Skin *) skin), String(name), String(path), (Sequence *) sequence);
}
spine_mesh_attachment spine_attachment_loader_new_mesh_attachment(spine_attachment_loader self, spine_skin skin, const char * name, const char * path, spine_sequence sequence) {
return (spine_mesh_attachment)((AttachmentLoader*)self)->newMeshAttachment(*((Skin*)skin), String(name), String(path), (Sequence *)sequence);
spine_mesh_attachment spine_attachment_loader_new_mesh_attachment(spine_attachment_loader self, spine_skin skin, const char *name, const char *path,
spine_sequence sequence) {
AttachmentLoader *_self = (AttachmentLoader *) self;
return (spine_mesh_attachment) _self->newMeshAttachment(*((Skin *) skin), String(name), String(path), (Sequence *) sequence);
}
spine_bounding_box_attachment spine_attachment_loader_new_bounding_box_attachment(spine_attachment_loader self, spine_skin skin, const char * name) {
return (spine_bounding_box_attachment)((AttachmentLoader*)self)->newBoundingBoxAttachment(*((Skin*)skin), String(name));
spine_bounding_box_attachment spine_attachment_loader_new_bounding_box_attachment(spine_attachment_loader self, spine_skin skin, const char *name) {
AttachmentLoader *_self = (AttachmentLoader *) self;
return (spine_bounding_box_attachment) _self->newBoundingBoxAttachment(*((Skin *) skin), String(name));
}
spine_path_attachment spine_attachment_loader_new_path_attachment(spine_attachment_loader self, spine_skin skin, const char * name) {
return (spine_path_attachment)((AttachmentLoader*)self)->newPathAttachment(*((Skin*)skin), String(name));
spine_path_attachment spine_attachment_loader_new_path_attachment(spine_attachment_loader self, spine_skin skin, const char *name) {
AttachmentLoader *_self = (AttachmentLoader *) self;
return (spine_path_attachment) _self->newPathAttachment(*((Skin *) skin), String(name));
}
spine_point_attachment spine_attachment_loader_new_point_attachment(spine_attachment_loader self, spine_skin skin, const char * name) {
return (spine_point_attachment)((AttachmentLoader*)self)->newPointAttachment(*((Skin*)skin), String(name));
spine_point_attachment spine_attachment_loader_new_point_attachment(spine_attachment_loader self, spine_skin skin, const char *name) {
AttachmentLoader *_self = (AttachmentLoader *) self;
return (spine_point_attachment) _self->newPointAttachment(*((Skin *) skin), String(name));
}
spine_clipping_attachment spine_attachment_loader_new_clipping_attachment(spine_attachment_loader self, spine_skin skin, const char * name) {
return (spine_clipping_attachment)((AttachmentLoader*)self)->newClippingAttachment(*((Skin*)skin), String(name));
spine_clipping_attachment spine_attachment_loader_new_clipping_attachment(spine_attachment_loader self, spine_skin skin, const char *name) {
AttachmentLoader *_self = (AttachmentLoader *) self;
return (spine_clipping_attachment) _self->newClippingAttachment(*((Skin *) skin), String(name));
}

16
spine-c/src/generated/attachment_loader.h
View File

@ -10,12 +10,16 @@ extern "C" {
SPINE_C_API void spine_attachment_loader_dispose(spine_attachment_loader self);
SPINE_C_API spine_region_attachment spine_attachment_loader_new_region_attachment(spine_attachment_loader self, spine_skin skin, const char * name, const char * path, spine_sequence sequence);
SPINE_C_API spine_mesh_attachment spine_attachment_loader_new_mesh_attachment(spine_attachment_loader self, spine_skin skin, const char * name, const char * path, spine_sequence sequence);
SPINE_C_API spine_bounding_box_attachment spine_attachment_loader_new_bounding_box_attachment(spine_attachment_loader self, spine_skin skin, const char * name);
SPINE_C_API spine_path_attachment spine_attachment_loader_new_path_attachment(spine_attachment_loader self, spine_skin skin, const char * name);
SPINE_C_API spine_point_attachment spine_attachment_loader_new_point_attachment(spine_attachment_loader self, spine_skin skin, const char * name);
SPINE_C_API spine_clipping_attachment spine_attachment_loader_new_clipping_attachment(spine_attachment_loader self, spine_skin skin, const char * name);
SPINE_C_API spine_region_attachment spine_attachment_loader_new_region_attachment(spine_attachment_loader self, spine_skin skin, const char *name,
const char *path, spine_sequence sequence);
SPINE_C_API spine_mesh_attachment spine_attachment_loader_new_mesh_attachment(spine_attachment_loader self, spine_skin skin, const char *name,
const char *path, spine_sequence sequence);
SPINE_C_API spine_bounding_box_attachment spine_attachment_loader_new_bounding_box_attachment(spine_attachment_loader self, spine_skin skin,
const char *name);
SPINE_C_API spine_path_attachment spine_attachment_loader_new_path_attachment(spine_attachment_loader self, spine_skin skin, const char *name);
SPINE_C_API spine_point_attachment spine_attachment_loader_new_point_attachment(spine_attachment_loader self, spine_skin skin, const char *name);
SPINE_C_API spine_clipping_attachment spine_attachment_loader_new_clipping_attachment(spine_attachment_loader self, spine_skin skin,
const char *name);
#ifdef __cplusplus
}

42
spine-c/src/generated/attachment_timeline.cpp
View File

@ -4,53 +4,65 @@
using namespace spine;
spine_attachment_timeline spine_attachment_timeline_create(size_t frameCount, int slotIndex) {
return (spine_attachment_timeline) new (__FILE__, __LINE__) AttachmentTimeline(frameCount, slotIndex);
return (spine_attachment_timeline) new (__FILE__, __LINE__) AttachmentTimeline(frameCount, slotIndex);
}
void spine_attachment_timeline_dispose(spine_attachment_timeline self) {
delete (AttachmentTimeline*)self;
delete (AttachmentTimeline *) self;
}
spine_rtti spine_attachment_timeline_get_rtti(spine_attachment_timeline self) {
return (spine_rtti)&((AttachmentTimeline*)self)->getRTTI();
AttachmentTimeline *_self = (AttachmentTimeline *) self;
return (spine_rtti) &_self->getRTTI();
}
void spine_attachment_timeline_apply(spine_attachment_timeline self, spine_skeleton skeleton, float lastTime, float time, spine_array_event pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction, bool appliedPose) {
((AttachmentTimeline*)self)->apply(*((Skeleton*)skeleton), lastTime, time, (Array<Event *> *)pEvents, alpha, (MixBlend)blend, (MixDirection)direction, appliedPose);
void spine_attachment_timeline_apply(spine_attachment_timeline self, spine_skeleton skeleton, float lastTime, float time, spine_array_event pEvents,
float alpha, spine_mix_blend blend, spine_mix_direction direction, bool appliedPose) {
AttachmentTimeline *_self = (AttachmentTimeline *) self;
_self->apply(*((Skeleton *) skeleton), lastTime, time, (Array<Event *> *) pEvents, alpha, (MixBlend) blend, (MixDirection) direction,
appliedPose);
}
void spine_attachment_timeline_set_frame(spine_attachment_timeline self, int frame, float time, const char * attachmentName) {
((AttachmentTimeline*)self)->setFrame(frame, time, String(attachmentName));
void spine_attachment_timeline_set_frame(spine_attachment_timeline self, int frame, float time, const char *attachmentName) {
AttachmentTimeline *_self = (AttachmentTimeline *) self;
_self->setFrame(frame, time, String(attachmentName));
}
size_t spine_attachment_timeline_get_frame_entries(spine_attachment_timeline self) {
return ((Timeline*)(AttachmentTimeline*)self)->getFrameEntries();
Timeline *_self = (Timeline *) (AttachmentTimeline *) self;
return _self->getFrameEntries();
}
size_t spine_attachment_timeline_get_frame_count(spine_attachment_timeline self) {
return ((Timeline*)(AttachmentTimeline*)self)->getFrameCount();
Timeline *_self = (Timeline *) (AttachmentTimeline *) self;
return _self->getFrameCount();
}
spine_array_float spine_attachment_timeline_get_frames(spine_attachment_timeline self) {
return (spine_array_float)&((Timeline*)(AttachmentTimeline*)self)->getFrames();
Timeline *_self = (Timeline *) (AttachmentTimeline *) self;
return (spine_array_float) &_self->getFrames();
}
float spine_attachment_timeline_get_duration(spine_attachment_timeline self) {
return ((Timeline*)(AttachmentTimeline*)self)->getDuration();
Timeline *_self = (Timeline *) (AttachmentTimeline *) self;
return _self->getDuration();
}
spine_array_property_id spine_attachment_timeline_get_property_ids(spine_attachment_timeline self) {
return (spine_array_property_id)&((Timeline*)(AttachmentTimeline*)self)->getPropertyIds();
Timeline *_self = (Timeline *) (AttachmentTimeline *) self;
return (spine_array_property_id) &_self->getPropertyIds();
}
int spine_attachment_timeline_get_slot_index(spine_attachment_timeline self) {
return ((SlotTimeline*)(AttachmentTimeline*)self)->getSlotIndex();
SlotTimeline *_self = (SlotTimeline *) (AttachmentTimeline *) self;
return _self->getSlotIndex();
}
void spine_attachment_timeline_set_slot_index(spine_attachment_timeline self, int inValue) {
((SlotTimeline*)(AttachmentTimeline*)self)->setSlotIndex(inValue);
SlotTimeline *_self = (SlotTimeline *) (AttachmentTimeline *) self;
_self->setSlotIndex(inValue);
}
spine_rtti spine_attachment_timeline_rtti(void) {
return (spine_rtti)&AttachmentTimeline::rtti;
return (spine_rtti) &AttachmentTimeline::rtti;
}

6
spine-c/src/generated/attachment_timeline.h
View File

@ -13,8 +13,10 @@ SPINE_C_API spine_attachment_timeline spine_attachment_timeline_create(size_t fr
SPINE_C_API void spine_attachment_timeline_dispose(spine_attachment_timeline self);
SPINE_C_API spine_rtti spine_attachment_timeline_get_rtti(spine_attachment_timeline self);
SPINE_C_API void spine_attachment_timeline_apply(spine_attachment_timeline self, spine_skeleton skeleton, float lastTime, float time, spine_array_event pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction, bool appliedPose);
SPINE_C_API void spine_attachment_timeline_set_frame(spine_attachment_timeline self, int frame, float time, const char * attachmentName);
SPINE_C_API void spine_attachment_timeline_apply(spine_attachment_timeline self, spine_skeleton skeleton, float lastTime, float time,
spine_array_event pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction,
bool appliedPose);
SPINE_C_API void spine_attachment_timeline_set_frame(spine_attachment_timeline self, int frame, float time, const char *attachmentName);
SPINE_C_API size_t spine_attachment_timeline_get_frame_entries(spine_attachment_timeline self);
SPINE_C_API size_t spine_attachment_timeline_get_frame_count(spine_attachment_timeline self);
SPINE_C_API spine_array_float spine_attachment_timeline_get_frames(spine_attachment_timeline self);

14
spine-c/src/generated/attachment_type.h
View File

@ -6,13 +6,13 @@ extern "C" {
#endif
typedef enum spine_attachment_type {
SPINE_ATTACHMENT_TYPE_REGION,
SPINE_ATTACHMENT_TYPE_BOUNDINGBOX,
SPINE_ATTACHMENT_TYPE_MESH,
SPINE_ATTACHMENT_TYPE_LINKEDMESH,
SPINE_ATTACHMENT_TYPE_PATH,
SPINE_ATTACHMENT_TYPE_POINT,
SPINE_ATTACHMENT_TYPE_CLIPPING
SPINE_ATTACHMENT_TYPE_REGION,
SPINE_ATTACHMENT_TYPE_BOUNDINGBOX,
SPINE_ATTACHMENT_TYPE_MESH,
SPINE_ATTACHMENT_TYPE_LINKEDMESH,
SPINE_ATTACHMENT_TYPE_PATH,
SPINE_ATTACHMENT_TYPE_POINT,
SPINE_ATTACHMENT_TYPE_CLIPPING
} spine_attachment_type;
#ifdef __cplusplus

8
spine-c/src/generated/blend_mode.h
View File

@ -6,10 +6,10 @@ extern "C" {
#endif
typedef enum spine_blend_mode {
SPINE_BLEND_MODE_NORMAL = 0,
SPINE_BLEND_MODE_ADDITIVE,
SPINE_BLEND_MODE_MULTIPLY,
SPINE_BLEND_MODE_SCREEN
SPINE_BLEND_MODE_NORMAL = 0,
SPINE_BLEND_MODE_ADDITIVE,
SPINE_BLEND_MODE_MULTIPLY,
SPINE_BLEND_MODE_SCREEN
} spine_blend_mode;
#ifdef __cplusplus

48
spine-c/src/generated/bone.cpp
View File

@ -4,73 +4,85 @@
using namespace spine;
spine_bone spine_bone_create(spine_bone_data data, spine_bone parent) {
return (spine_bone) new (__FILE__, __LINE__) Bone(*((BoneData*)data), (Bone *)parent);
return (spine_bone) new (__FILE__, __LINE__) Bone(*((BoneData *) data), (Bone *) parent);
}
spine_bone spine_bone_create2(spine_bone bone, spine_bone parent) {
return (spine_bone) new (__FILE__, __LINE__) Bone(*((Bone*)bone), (Bone *)parent);
return (spine_bone) new (__FILE__, __LINE__) Bone(*((Bone *) bone), (Bone *) parent);
}
void spine_bone_dispose(spine_bone self) {
delete (Bone*)self;
delete (Bone *) self;
}
spine_rtti spine_bone_get_rtti(spine_bone self) {
return (spine_rtti)&((Bone*)self)->getRTTI();
Bone *_self = (Bone *) self;
return (spine_rtti) &_self->getRTTI();
}
spine_bone spine_bone_get_parent(spine_bone self) {
return (spine_bone)((Bone*)self)->getParent();
Bone *_self = (Bone *) self;
return (spine_bone) _self->getParent();
}
spine_array_bone spine_bone_get_children(spine_bone self) {
return (spine_array_bone)&((Bone*)self)->getChildren();
Bone *_self = (Bone *) self;
return (spine_array_bone) &_self->getChildren();
}
bool spine_bone_is_y_down(void) {
return Bone::isYDown();
return Bone::isYDown();
}
void spine_bone_set_y_down(bool value) {
Bone::setYDown(value);
Bone::setYDown(value);
}
void spine_bone_update(spine_bone self, spine_skeleton skeleton, spine_physics physics) {
((Bone*)self)->update(*((Skeleton*)skeleton), (Physics)physics);
Bone *_self = (Bone *) self;
_self->update(*((Skeleton *) skeleton), (Physics) physics);
}
spine_bone_data spine_bone_get_data(spine_bone self) {
return (spine_bone_data)&((PosedGeneric<BoneData, BoneLocal, BonePose>*)(Bone*)self)->getData();
PosedGeneric<BoneData, BoneLocal, BonePose> *_self = (PosedGeneric<BoneData, BoneLocal, BonePose> *) (Bone *) self;
return (spine_bone_data) &_self->getData();
}
spine_bone_local spine_bone_get_pose(spine_bone self) {
return (spine_bone_local)&((PosedGeneric<BoneData, BoneLocal, BonePose>*)(Bone*)self)->getPose();
PosedGeneric<BoneData, BoneLocal, BonePose> *_self = (PosedGeneric<BoneData, BoneLocal, BonePose> *) (Bone *) self;
return (spine_bone_local) &_self->getPose();
}
spine_bone_pose spine_bone_get_applied_pose(spine_bone self) {
return (spine_bone_pose)&((PosedGeneric<BoneData, BoneLocal, BonePose>*)(Bone*)self)->getAppliedPose();
PosedGeneric<BoneData, BoneLocal, BonePose> *_self = (PosedGeneric<BoneData, BoneLocal, BonePose> *) (Bone *) self;
return (spine_bone_pose) &_self->getAppliedPose();
}
void spine_bone_reset_constrained(spine_bone self) {
((PosedGeneric<BoneData, BoneLocal, BonePose>*)(Bone*)self)->resetConstrained();
PosedGeneric<BoneData, BoneLocal, BonePose> *_self = (PosedGeneric<BoneData, BoneLocal, BonePose> *) (Bone *) self;
_self->resetConstrained();
}
void spine_bone_constrained(spine_bone self) {
((PosedGeneric<BoneData, BoneLocal, BonePose>*)(Bone*)self)->constrained();
PosedGeneric<BoneData, BoneLocal, BonePose> *_self = (PosedGeneric<BoneData, BoneLocal, BonePose> *) (Bone *) self;
_self->constrained();
}
bool spine_bone_is_pose_equal_to_applied(spine_bone self) {
return ((PosedGeneric<BoneData, BoneLocal, BonePose>*)(Bone*)self)->isPoseEqualToApplied();
PosedGeneric<BoneData, BoneLocal, BonePose> *_self = (PosedGeneric<BoneData, BoneLocal, BonePose> *) (Bone *) self;
return _self->isPoseEqualToApplied();
}
bool spine_bone_is_active(spine_bone self) {
return ((PosedActive*)(Bone*)self)->isActive();
PosedActive *_self = (PosedActive *) (Bone *) self;
return _self->isActive();
}
void spine_bone_set_active(spine_bone self, bool active) {
((PosedActive*)(Bone*)self)->setActive(active);
PosedActive *_self = (PosedActive *) (Bone *) self;
_self->setActive(active);
}
spine_rtti spine_bone_rtti(void) {
return (spine_rtti)&Bone::rtti;
return (spine_rtti) &Bone::rtti;
}

51
spine-c/src/generated/bone_data.cpp
View File

@ -3,62 +3,75 @@
using namespace spine;
spine_bone_data spine_bone_data_create(int index, const char * name, spine_bone_data parent) {
return (spine_bone_data) new (__FILE__, __LINE__) BoneData(index, String(name), (BoneData *)parent);
spine_bone_data spine_bone_data_create(int index, const char *name, spine_bone_data parent) {
return (spine_bone_data) new (__FILE__, __LINE__) BoneData(index, String(name), (BoneData *) parent);
}
void spine_bone_data_dispose(spine_bone_data self) {
delete (BoneData*)self;
delete (BoneData *) self;
}
int spine_bone_data_get_index(spine_bone_data self) {
return ((BoneData*)self)->getIndex();
BoneData *_self = (BoneData *) self;
return _self->getIndex();
}
spine_bone_data spine_bone_data_get_parent(spine_bone_data self) {
return (spine_bone_data)((BoneData*)self)->getParent();
BoneData *_self = (BoneData *) self;
return (spine_bone_data) _self->getParent();
}
float spine_bone_data_get_length(spine_bone_data self) {
return ((BoneData*)self)->getLength();
BoneData *_self = (BoneData *) self;
return _self->getLength();
}
void spine_bone_data_set_length(spine_bone_data self, float inValue) {
((BoneData*)self)->setLength(inValue);
BoneData *_self = (BoneData *) self;
_self->setLength(inValue);
}
spine_color spine_bone_data_get_color(spine_bone_data self) {
return (spine_color)&((BoneData*)self)->getColor();
BoneData *_self = (BoneData *) self;
return (spine_color) &_self->getColor();
}
const char * spine_bone_data_get_icon(spine_bone_data self) {
return ((BoneData*)self)->getIcon().buffer();
const char *spine_bone_data_get_icon(spine_bone_data self) {
BoneData *_self = (BoneData *) self;
return _self->getIcon().buffer();
}
void spine_bone_data_set_icon(spine_bone_data self, const char * icon) {
((BoneData*)self)->setIcon(String(icon));
void spine_bone_data_set_icon(spine_bone_data self, const char *icon) {
BoneData *_self = (BoneData *) self;
_self->setIcon(String(icon));
}
bool spine_bone_data_get_visible(spine_bone_data self) {
return ((BoneData*)self)->getVisible();
BoneData *_self = (BoneData *) self;
return _self->getVisible();
}
void spine_bone_data_set_visible(spine_bone_data self, bool inValue) {
((BoneData*)self)->setVisible(inValue);
BoneData *_self = (BoneData *) self;
_self->setVisible(inValue);
}
spine_bone_local spine_bone_data_get_setup_pose(spine_bone_data self) {
return (spine_bone_local)&((PosedDataGeneric<BoneLocal>*)(BoneData*)self)->getSetupPose();
PosedDataGeneric<BoneLocal> *_self = (PosedDataGeneric<BoneLocal> *) (BoneData *) self;
return (spine_bone_local) &_self->getSetupPose();
}
const char * spine_bone_data_get_name(spine_bone_data self) {
return ((PosedDataGeneric<BoneLocal>*)(BoneData*)self)->getName().buffer();
const char *spine_bone_data_get_name(spine_bone_data self) {
PosedDataGeneric<BoneLocal> *_self = (PosedDataGeneric<BoneLocal> *) (BoneData *) self;
return _self->getName().buffer();
}
bool spine_bone_data_get_skin_required(spine_bone_data self) {
return ((PosedDataGeneric<BoneLocal>*)(BoneData*)self)->getSkinRequired();
PosedDataGeneric<BoneLocal> *_self = (PosedDataGeneric<BoneLocal> *) (BoneData *) self;
return _self->getSkinRequired();
}
void spine_bone_data_set_skin_required(spine_bone_data self, bool skinRequired) {
((PosedDataGeneric<BoneLocal>*)(BoneData*)self)->setSkinRequired(skinRequired);
PosedDataGeneric<BoneLocal> *_self = (PosedDataGeneric<BoneLocal> *) (BoneData *) self;
_self->setSkinRequired(skinRequired);
}

8
spine-c/src/generated/bone_data.h
View File

@ -8,7 +8,7 @@
extern "C" {
#endif
SPINE_C_API spine_bone_data spine_bone_data_create(int index, const char * name, spine_bone_data parent);
SPINE_C_API spine_bone_data spine_bone_data_create(int index, const char *name, spine_bone_data parent);
SPINE_C_API void spine_bone_data_dispose(spine_bone_data self);
@ -17,12 +17,12 @@ SPINE_C_API spine_bone_data spine_bone_data_get_parent(spine_bone_data self);
SPINE_C_API float spine_bone_data_get_length(spine_bone_data self);
SPINE_C_API void spine_bone_data_set_length(spine_bone_data self, float inValue);
SPINE_C_API spine_color spine_bone_data_get_color(spine_bone_data self);
SPINE_C_API const char * spine_bone_data_get_icon(spine_bone_data self);
SPINE_C_API void spine_bone_data_set_icon(spine_bone_data self, const char * icon);
SPINE_C_API const char *spine_bone_data_get_icon(spine_bone_data self);
SPINE_C_API void spine_bone_data_set_icon(spine_bone_data self, const char *icon);
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 const char *spine_bone_data_get_name(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);

64
spine-c/src/generated/bone_local.cpp
View File

@ -4,89 +4,109 @@
using namespace spine;
spine_bone_local spine_bone_local_create(void) {
return (spine_bone_local) new (__FILE__, __LINE__) BoneLocal();
return (spine_bone_local) new (__FILE__, __LINE__) BoneLocal();
}
void spine_bone_local_dispose(spine_bone_local self) {
delete (BoneLocal*)self;
delete (BoneLocal *) self;
}
void spine_bone_local_set(spine_bone_local self, spine_bone_local pose) {
((BoneLocal*)self)->set(*((BoneLocal*)pose));
BoneLocal *_self = (BoneLocal *) self;
_self->set(*((BoneLocal *) pose));
}
float spine_bone_local_get_x(spine_bone_local self) {
return ((BoneLocal*)self)->getX();
BoneLocal *_self = (BoneLocal *) self;
return _self->getX();
}
void spine_bone_local_set_x(spine_bone_local self, float x) {
((BoneLocal*)self)->setX(x);
BoneLocal *_self = (BoneLocal *) self;
_self->setX(x);
}
float spine_bone_local_get_y(spine_bone_local self) {
return ((BoneLocal*)self)->getY();
BoneLocal *_self = (BoneLocal *) self;
return _self->getY();
}
void spine_bone_local_set_y(spine_bone_local self, float y) {
((BoneLocal*)self)->setY(y);
BoneLocal *_self = (BoneLocal *) self;
_self->setY(y);
}
void spine_bone_local_set_position(spine_bone_local self, float x, float y) {
((BoneLocal*)self)->setPosition(x, y);
BoneLocal *_self = (BoneLocal *) self;
_self->setPosition(x, y);
}
float spine_bone_local_get_rotation(spine_bone_local self) {
return ((BoneLocal*)self)->getRotation();
BoneLocal *_self = (BoneLocal *) self;
return _self->getRotation();
}
void spine_bone_local_set_rotation(spine_bone_local self, float rotation) {
((BoneLocal*)self)->setRotation(rotation);
BoneLocal *_self = (BoneLocal *) self;
_self->setRotation(rotation);
}
float spine_bone_local_get_scale_x(spine_bone_local self) {
return ((BoneLocal*)self)->getScaleX();
BoneLocal *_self = (BoneLocal *) self;
return _self->getScaleX();
}
void spine_bone_local_set_scale_x(spine_bone_local self, float scaleX) {
((BoneLocal*)self)->setScaleX(scaleX);
BoneLocal *_self = (BoneLocal *) self;
_self->setScaleX(scaleX);
}
float spine_bone_local_get_scale_y(spine_bone_local self) {
return ((BoneLocal*)self)->getScaleY();
BoneLocal *_self = (BoneLocal *) self;
return _self->getScaleY();
}
void spine_bone_local_set_scale_y(spine_bone_local self, float scaleY) {
((BoneLocal*)self)->setScaleY(scaleY);
BoneLocal *_self = (BoneLocal *) self;
_self->setScaleY(scaleY);
}
void spine_bone_local_set_scale_1(spine_bone_local self, float scaleX, float scaleY) {
((BoneLocal*)self)->setScale(scaleX, scaleY);
BoneLocal *_self = (BoneLocal *) self;
_self->setScale(scaleX, scaleY);
}
void spine_bone_local_set_scale_2(spine_bone_local self, float scale) {
((BoneLocal*)self)->setScale(scale);
BoneLocal *_self = (BoneLocal *) self;
_self->setScale(scale);
}
float spine_bone_local_get_shear_x(spine_bone_local self) {
return ((BoneLocal*)self)->getShearX();
BoneLocal *_self = (BoneLocal *) self;
return _self->getShearX();
}
void spine_bone_local_set_shear_x(spine_bone_local self, float shearX) {
((BoneLocal*)self)->setShearX(shearX);
BoneLocal *_self = (BoneLocal *) self;
_self->setShearX(shearX);
}
float spine_bone_local_get_shear_y(spine_bone_local self) {
return ((BoneLocal*)self)->getShearY();
BoneLocal *_self = (BoneLocal *) self;
return _self->getShearY();
}
void spine_bone_local_set_shear_y(spine_bone_local self, float shearY) {
((BoneLocal*)self)->setShearY(shearY);
BoneLocal *_self = (BoneLocal *) self;
_self->setShearY(shearY);
}
spine_inherit spine_bone_local_get_inherit(spine_bone_local self) {
return (spine_inherit)((BoneLocal*)self)->getInherit();
BoneLocal *_self = (BoneLocal *) self;
return (spine_inherit) _self->getInherit();
}
void spine_bone_local_set_inherit(spine_bone_local self, spine_inherit inherit) {
((BoneLocal*)self)->setInherit((Inherit)inherit);
BoneLocal *_self = (BoneLocal *) self;
_self->setInherit((Inherit) inherit);
}

167
spine-c/src/generated/bone_pose.cpp
View File

@ -4,217 +4,268 @@
using namespace spine;
spine_bone_pose spine_bone_pose_create(void) {
return (spine_bone_pose) new (__FILE__, __LINE__) BonePose();
return (spine_bone_pose) new (__FILE__, __LINE__) BonePose();
}
void spine_bone_pose_dispose(spine_bone_pose self) {
delete (BonePose*)self;
delete (BonePose *) self;
}
void spine_bone_pose_update(spine_bone_pose self, spine_skeleton skeleton, spine_physics physics) {
((BonePose*)self)->update(*((Skeleton*)skeleton), (Physics)physics);
BonePose *_self = (BonePose *) self;
_self->update(*((Skeleton *) skeleton), (Physics) physics);
}
void spine_bone_pose_update_world_transform(spine_bone_pose self, spine_skeleton skeleton) {
((BonePose*)self)->updateWorldTransform(*((Skeleton*)skeleton));
BonePose *_self = (BonePose *) self;
_self->updateWorldTransform(*((Skeleton *) skeleton));
}
void spine_bone_pose_update_local_transform(spine_bone_pose self, spine_skeleton skeleton) {
((BonePose*)self)->updateLocalTransform(*((Skeleton*)skeleton));
BonePose *_self = (BonePose *) self;
_self->updateLocalTransform(*((Skeleton *) skeleton));
}
void spine_bone_pose_validate_local_transform(spine_bone_pose self, spine_skeleton skeleton) {
((BonePose*)self)->validateLocalTransform(*((Skeleton*)skeleton));
BonePose *_self = (BonePose *) self;
_self->validateLocalTransform(*((Skeleton *) skeleton));
}
void spine_bone_pose_modify_local(spine_bone_pose self, spine_skeleton skeleton) {
((BonePose*)self)->modifyLocal(*((Skeleton*)skeleton));
BonePose *_self = (BonePose *) self;
_self->modifyLocal(*((Skeleton *) skeleton));
}
void spine_bone_pose_modify_world(spine_bone_pose self, int update) {
((BonePose*)self)->modifyWorld(update);
BonePose *_self = (BonePose *) self;
_self->modifyWorld(update);
}
void spine_bone_pose_reset_world(spine_bone_pose self, int update) {
((BonePose*)self)->resetWorld(update);
BonePose *_self = (BonePose *) self;
_self->resetWorld(update);
}
float spine_bone_pose_get_a(spine_bone_pose self) {
return ((BonePose*)self)->getA();
BonePose *_self = (BonePose *) self;
return _self->getA();
}
void spine_bone_pose_set_a(spine_bone_pose self, float a) {
((BonePose*)self)->setA(a);
BonePose *_self = (BonePose *) self;
_self->setA(a);
}
float spine_bone_pose_get_b(spine_bone_pose self) {
return ((BonePose*)self)->getB();
BonePose *_self = (BonePose *) self;
return _self->getB();
}
void spine_bone_pose_set_b(spine_bone_pose self, float b) {
((BonePose*)self)->setB(b);
BonePose *_self = (BonePose *) self;
_self->setB(b);
}
float spine_bone_pose_get_c(spine_bone_pose self) {
return ((BonePose*)self)->getC();
BonePose *_self = (BonePose *) self;
return _self->getC();
}
void spine_bone_pose_set_c(spine_bone_pose self, float c) {
((BonePose*)self)->setC(c);
BonePose *_self = (BonePose *) self;
_self->setC(c);
}
float spine_bone_pose_get_d(spine_bone_pose self) {
return ((BonePose*)self)->getD();
BonePose *_self = (BonePose *) self;
return _self->getD();
}
void spine_bone_pose_set_d(spine_bone_pose self, float d) {
((BonePose*)self)->setD(d);
BonePose *_self = (BonePose *) self;
_self->setD(d);
}
float spine_bone_pose_get_world_x(spine_bone_pose self) {
return ((BonePose*)self)->getWorldX();
BonePose *_self = (BonePose *) self;
return _self->getWorldX();
}
void spine_bone_pose_set_world_x(spine_bone_pose self, float worldX) {
((BonePose*)self)->setWorldX(worldX);
BonePose *_self = (BonePose *) self;
_self->setWorldX(worldX);
}
float spine_bone_pose_get_world_y(spine_bone_pose self) {
return ((BonePose*)self)->getWorldY();
BonePose *_self = (BonePose *) self;
return _self->getWorldY();
}
void spine_bone_pose_set_world_y(spine_bone_pose self, float worldY) {
((BonePose*)self)->setWorldY(worldY);
BonePose *_self = (BonePose *) self;
_self->setWorldY(worldY);
}
float spine_bone_pose_get_world_rotation_x(spine_bone_pose self) {
return ((BonePose*)self)->getWorldRotationX();
BonePose *_self = (BonePose *) self;
return _self->getWorldRotationX();
}
float spine_bone_pose_get_world_rotation_y(spine_bone_pose self) {
return ((BonePose*)self)->getWorldRotationY();
BonePose *_self = (BonePose *) self;
return _self->getWorldRotationY();
}
float spine_bone_pose_get_world_scale_x(spine_bone_pose self) {
return ((BonePose*)self)->getWorldScaleX();
BonePose *_self = (BonePose *) self;
return _self->getWorldScaleX();
}
float spine_bone_pose_get_world_scale_y(spine_bone_pose self) {
return ((BonePose*)self)->getWorldScaleY();
BonePose *_self = (BonePose *) self;
return _self->getWorldScaleY();
}
void spine_bone_pose_world_to_local(spine_bone_pose self, float worldX, float worldY, float * outLocalX, float * outLocalY) {
((BonePose*)self)->worldToLocal(worldX, worldY, *outLocalX, *outLocalY);
void spine_bone_pose_world_to_local(spine_bone_pose self, float worldX, float worldY, float *outLocalX, float *outLocalY) {
BonePose *_self = (BonePose *) self;
_self->worldToLocal(worldX, worldY, *outLocalX, *outLocalY);
}
void spine_bone_pose_local_to_world(spine_bone_pose self, float localX, float localY, float * outWorldX, float * outWorldY) {
((BonePose*)self)->localToWorld(localX, localY, *outWorldX, *outWorldY);
void spine_bone_pose_local_to_world(spine_bone_pose self, float localX, float localY, float *outWorldX, float *outWorldY) {
BonePose *_self = (BonePose *) self;
_self->localToWorld(localX, localY, *outWorldX, *outWorldY);
}
void spine_bone_pose_world_to_parent(spine_bone_pose self, float worldX, float worldY, float * outParentX, float * outParentY) {
((BonePose*)self)->worldToParent(worldX, worldY, *outParentX, *outParentY);
void spine_bone_pose_world_to_parent(spine_bone_pose self, float worldX, float worldY, float *outParentX, float *outParentY) {
BonePose *_self = (BonePose *) self;
_self->worldToParent(worldX, worldY, *outParentX, *outParentY);
}
void spine_bone_pose_parent_to_world(spine_bone_pose self, float parentX, float parentY, float * outWorldX, float * outWorldY) {
((BonePose*)self)->parentToWorld(parentX, parentY, *outWorldX, *outWorldY);
void spine_bone_pose_parent_to_world(spine_bone_pose self, float parentX, float parentY, float *outWorldX, float *outWorldY) {
BonePose *_self = (BonePose *) self;
_self->parentToWorld(parentX, parentY, *outWorldX, *outWorldY);
}
float spine_bone_pose_world_to_local_rotation(spine_bone_pose self, float worldRotation) {
return ((BonePose*)self)->worldToLocalRotation(worldRotation);
BonePose *_self = (BonePose *) self;
return _self->worldToLocalRotation(worldRotation);
}
float spine_bone_pose_local_to_world_rotation(spine_bone_pose self, float localRotation) {
return ((BonePose*)self)->localToWorldRotation(localRotation);
BonePose *_self = (BonePose *) self;
return _self->localToWorldRotation(localRotation);
}
void spine_bone_pose_rotate_world(spine_bone_pose self, float degrees) {
((BonePose*)self)->rotateWorld(degrees);
BonePose *_self = (BonePose *) self;
_self->rotateWorld(degrees);
}
void spine_bone_pose_set(spine_bone_pose self, spine_bone_local pose) {
((BoneLocal*)(BonePose*)self)->set(*((BoneLocal*)pose));
BoneLocal *_self = (BoneLocal *) (BonePose *) self;
_self->set(*((BoneLocal *) pose));
}
float spine_bone_pose_get_x(spine_bone_pose self) {
return ((BoneLocal*)(BonePose*)self)->getX();
BoneLocal *_self = (BoneLocal *) (BonePose *) self;
return _self->getX();
}
void spine_bone_pose_set_x(spine_bone_pose self, float x) {
((BoneLocal*)(BonePose*)self)->setX(x);
BoneLocal *_self = (BoneLocal *) (BonePose *) self;
_self->setX(x);
}
float spine_bone_pose_get_y(spine_bone_pose self) {
return ((BoneLocal*)(BonePose*)self)->getY();
BoneLocal *_self = (BoneLocal *) (BonePose *) self;
return _self->getY();
}
void spine_bone_pose_set_y(spine_bone_pose self, float y) {
((BoneLocal*)(BonePose*)self)->setY(y);
BoneLocal *_self = (BoneLocal *) (BonePose *) self;
_self->setY(y);
}
void spine_bone_pose_set_position(spine_bone_pose self, float x, float y) {
((BoneLocal*)(BonePose*)self)->setPosition(x, y);
BoneLocal *_self = (BoneLocal *) (BonePose *) self;
_self->setPosition(x, y);
}
float spine_bone_pose_get_rotation(spine_bone_pose self) {
return ((BoneLocal*)(BonePose*)self)->getRotation();
BoneLocal *_self = (BoneLocal *) (BonePose *) self;
return _self->getRotation();
}
void spine_bone_pose_set_rotation(spine_bone_pose self, float rotation) {
((BoneLocal*)(BonePose*)self)->setRotation(rotation);
BoneLocal *_self = (BoneLocal *) (BonePose *) self;
_self->setRotation(rotation);
}
float spine_bone_pose_get_scale_x(spine_bone_pose self) {
return ((BoneLocal*)(BonePose*)self)->getScaleX();
BoneLocal *_self = (BoneLocal *) (BonePose *) self;
return _self->getScaleX();
}
void spine_bone_pose_set_scale_x(spine_bone_pose self, float scaleX) {
((BoneLocal*)(BonePose*)self)->setScaleX(scaleX);
BoneLocal *_self = (BoneLocal *) (BonePose *) self;
_self->setScaleX(scaleX);
}
float spine_bone_pose_get_scale_y(spine_bone_pose self) {
return ((BoneLocal*)(BonePose*)self)->getScaleY();
BoneLocal *_self = (BoneLocal *) (BonePose *) self;
return _self->getScaleY();
}
void spine_bone_pose_set_scale_y(spine_bone_pose self, float scaleY) {
((BoneLocal*)(BonePose*)self)->setScaleY(scaleY);
BoneLocal *_self = (BoneLocal *) (BonePose *) self;
_self->setScaleY(scaleY);
}
void spine_bone_pose_set_scale_1(spine_bone_pose self, float scaleX, float scaleY) {
((BoneLocal*)(BonePose*)self)->setScale(scaleX, scaleY);
BoneLocal *_self = (BoneLocal *) (BonePose *) self;
_self->setScale(scaleX, scaleY);
}
void spine_bone_pose_set_scale_2(spine_bone_pose self, float scale) {
((BoneLocal*)(BonePose*)self)->setScale(scale);
BoneLocal *_self = (BoneLocal *) (BonePose *) self;
_self->setScale(scale);
}
float spine_bone_pose_get_shear_x(spine_bone_pose self) {
return ((BoneLocal*)(BonePose*)self)->getShearX();
BoneLocal *_self = (BoneLocal *) (BonePose *) self;
return _self->getShearX();
}
void spine_bone_pose_set_shear_x(spine_bone_pose self, float shearX) {
((BoneLocal*)(BonePose*)self)->setShearX(shearX);
BoneLocal *_self = (BoneLocal *) (BonePose *) self;
_self->setShearX(shearX);
}
float spine_bone_pose_get_shear_y(spine_bone_pose self) {
return ((BoneLocal*)(BonePose*)self)->getShearY();
BoneLocal *_self = (BoneLocal *) (BonePose *) self;
return _self->getShearY();
}
void spine_bone_pose_set_shear_y(spine_bone_pose self, float shearY) {
((BoneLocal*)(BonePose*)self)->setShearY(shearY);
BoneLocal *_self = (BoneLocal *) (BonePose *) self;
_self->setShearY(shearY);
}
spine_inherit spine_bone_pose_get_inherit(spine_bone_pose self) {
return (spine_inherit)((BoneLocal*)(BonePose*)self)->getInherit();
BoneLocal *_self = (BoneLocal *) (BonePose *) self;
return (spine_inherit) _self->getInherit();
}
void spine_bone_pose_set_inherit(spine_bone_pose self, spine_inherit inherit) {
((BoneLocal*)(BonePose*)self)->setInherit((Inherit)inherit);
BoneLocal *_self = (BoneLocal *) (BonePose *) self;
_self->setInherit((Inherit) inherit);
}
spine_rtti spine_bone_pose_get_rtti(spine_bone_pose self) {
return (spine_rtti)&((Update*)(BonePose*)self)->getRTTI();
Update *_self = (Update *) (BonePose *) self;
return (spine_rtti) &_self->getRTTI();
}
spine_rtti spine_bone_pose_rtti(void) {
return (spine_rtti)&BonePose::rtti;
return (spine_rtti) &BonePose::rtti;
}

8
spine-c/src/generated/bone_pose.h
View File

@ -35,10 +35,10 @@ SPINE_C_API float spine_bone_pose_get_world_rotation_x(spine_bone_pose self);
SPINE_C_API float spine_bone_pose_get_world_rotation_y(spine_bone_pose self);
SPINE_C_API float spine_bone_pose_get_world_scale_x(spine_bone_pose self);
SPINE_C_API float spine_bone_pose_get_world_scale_y(spine_bone_pose self);
SPINE_C_API void spine_bone_pose_world_to_local(spine_bone_pose self, float worldX, float worldY, float * outLocalX, float * outLocalY);
SPINE_C_API void spine_bone_pose_local_to_world(spine_bone_pose self, float localX, float localY, float * outWorldX, float * outWorldY);
SPINE_C_API void spine_bone_pose_world_to_parent(spine_bone_pose self, float worldX, float worldY, float * outParentX, float * outParentY);
SPINE_C_API void spine_bone_pose_parent_to_world(spine_bone_pose self, float parentX, float parentY, float * outWorldX, float * outWorldY);
SPINE_C_API void spine_bone_pose_world_to_local(spine_bone_pose self, float worldX, float worldY, float *outLocalX, float *outLocalY);
SPINE_C_API void spine_bone_pose_local_to_world(spine_bone_pose self, float localX, float localY, float *outWorldX, float *outWorldY);
SPINE_C_API void spine_bone_pose_world_to_parent(spine_bone_pose self, float worldX, float worldY, float *outParentX, float *outParentY);
SPINE_C_API void spine_bone_pose_parent_to_world(spine_bone_pose self, float parentX, float parentY, float *outWorldX, float *outWorldY);
SPINE_C_API float spine_bone_pose_world_to_local_rotation(spine_bone_pose self, float worldRotation);
SPINE_C_API float spine_bone_pose_local_to_world_rotation(spine_bone_pose self, float localRotation);
SPINE_C_API void spine_bone_pose_rotate_world(spine_bone_pose self, float degrees);

13
spine-c/src/generated/bone_timeline.cpp
View File

@ -4,21 +4,24 @@
using namespace spine;
void spine_bone_timeline_dispose(spine_bone_timeline self) {
delete (BoneTimeline*)self;
delete (BoneTimeline *) self;
}
spine_rtti spine_bone_timeline_get_rtti(spine_bone_timeline self) {
return (spine_rtti)&((BoneTimeline*)self)->getRTTI();
BoneTimeline *_self = (BoneTimeline *) self;
return (spine_rtti) &_self->getRTTI();
}
int spine_bone_timeline_get_bone_index(spine_bone_timeline self) {
return ((BoneTimeline*)self)->getBoneIndex();
BoneTimeline *_self = (BoneTimeline *) self;
return _self->getBoneIndex();
}
void spine_bone_timeline_set_bone_index(spine_bone_timeline self, int inValue) {
((BoneTimeline*)self)->setBoneIndex(inValue);
BoneTimeline *_self = (BoneTimeline *) self;
_self->setBoneIndex(inValue);
}
spine_rtti spine_bone_timeline_rtti(void) {
return (spine_rtti)&BoneTimeline::rtti;
return (spine_rtti) &BoneTimeline::rtti;
}

80
spine-c/src/generated/bone_timeline1.cpp
View File

@ -4,89 +4,115 @@
using namespace spine;
void spine_bone_timeline1_dispose(spine_bone_timeline1 self) {
delete (BoneTimeline1*)self;
delete (BoneTimeline1 *) self;
}
spine_rtti spine_bone_timeline1_get_rtti(spine_bone_timeline1 self) {
return (spine_rtti)&((BoneTimeline1*)self)->getRTTI();
BoneTimeline1 *_self = (BoneTimeline1 *) self;
return (spine_rtti) &_self->getRTTI();
}
void spine_bone_timeline1_apply(spine_bone_timeline1 self, spine_skeleton skeleton, float lastTime, float time, spine_array_event pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction, bool appliedPose) {
((BoneTimeline1*)self)->apply(*((Skeleton*)skeleton), lastTime, time, (Array<Event *> *)pEvents, alpha, (MixBlend)blend, (MixDirection)direction, appliedPose);
void spine_bone_timeline1_apply(spine_bone_timeline1 self, spine_skeleton skeleton, float lastTime, float time, spine_array_event pEvents,
float alpha, spine_mix_blend blend, spine_mix_direction direction, bool appliedPose) {
BoneTimeline1 *_self = (BoneTimeline1 *) self;
_self->apply(*((Skeleton *) skeleton), lastTime, time, (Array<Event *> *) pEvents, alpha, (MixBlend) blend, (MixDirection) direction,
appliedPose);
}
void spine_bone_timeline1_set_frame(spine_bone_timeline1 self, size_t frame, float time, float value) {
((CurveTimeline1*)(BoneTimeline1*)self)->setFrame(frame, time, value);
CurveTimeline1 *_self = (CurveTimeline1 *) (BoneTimeline1 *) self;
_self->setFrame(frame, time, value);
}
float spine_bone_timeline1_get_curve_value(spine_bone_timeline1 self, float time) {
return ((CurveTimeline1*)(BoneTimeline1*)self)->getCurveValue(time);
CurveTimeline1 *_self = (CurveTimeline1 *) (BoneTimeline1 *) self;
return _self->getCurveValue(time);
}
float spine_bone_timeline1_get_relative_value(spine_bone_timeline1 self, float time, float alpha, spine_mix_blend blend, float current, float setup) {
return ((CurveTimeline1*)(BoneTimeline1*)self)->getRelativeValue(time, alpha, (MixBlend)blend, current, setup);
CurveTimeline1 *_self = (CurveTimeline1 *) (BoneTimeline1 *) self;
return _self->getRelativeValue(time, alpha, (MixBlend) blend, current, setup);
}
float spine_bone_timeline1_get_absolute_value_1(spine_bone_timeline1 self, float time, float alpha, spine_mix_blend blend, float current, float setup) {
return ((CurveTimeline1*)(BoneTimeline1*)self)->getAbsoluteValue(time, alpha, (MixBlend)blend, current, setup);
float spine_bone_timeline1_get_absolute_value_1(spine_bone_timeline1 self, float time, float alpha, spine_mix_blend blend, float current,
float setup) {
CurveTimeline1 *_self = (CurveTimeline1 *) (BoneTimeline1 *) self;
return _self->getAbsoluteValue(time, alpha, (MixBlend) blend, current, setup);
}
float spine_bone_timeline1_get_absolute_value_2(spine_bone_timeline1 self, float time, float alpha, spine_mix_blend blend, float current, float setup, float value) {
return ((CurveTimeline1*)(BoneTimeline1*)self)->getAbsoluteValue(time, alpha, (MixBlend)blend, current, setup, value);
float spine_bone_timeline1_get_absolute_value_2(spine_bone_timeline1 self, float time, float alpha, spine_mix_blend blend, float current, float setup,
float value) {
CurveTimeline1 *_self = (CurveTimeline1 *) (BoneTimeline1 *) self;
return _self->getAbsoluteValue(time, alpha, (MixBlend) blend, current, setup, value);
}
float spine_bone_timeline1_get_scale_value(spine_bone_timeline1 self, float time, float alpha, spine_mix_blend blend, spine_mix_direction direction, float current, float setup) {
return ((CurveTimeline1*)(BoneTimeline1*)self)->getScaleValue(time, alpha, (MixBlend)blend, (MixDirection)direction, current, setup);
float spine_bone_timeline1_get_scale_value(spine_bone_timeline1 self, float time, float alpha, spine_mix_blend blend, spine_mix_direction direction,
float current, float setup) {
CurveTimeline1 *_self = (CurveTimeline1 *) (BoneTimeline1 *) self;
return _self->getScaleValue(time, alpha, (MixBlend) blend, (MixDirection) direction, current, setup);
}
void spine_bone_timeline1_set_linear(spine_bone_timeline1 self, size_t frame) {
((CurveTimeline1*)(BoneTimeline1*)self)->setLinear(frame);
CurveTimeline1 *_self = (CurveTimeline1 *) (BoneTimeline1 *) self;
_self->setLinear(frame);
}
void spine_bone_timeline1_set_stepped(spine_bone_timeline1 self, size_t frame) {
((CurveTimeline1*)(BoneTimeline1*)self)->setStepped(frame);
CurveTimeline1 *_self = (CurveTimeline1 *) (BoneTimeline1 *) self;
_self->setStepped(frame);
}
void spine_bone_timeline1_set_bezier(spine_bone_timeline1 self, size_t bezier, size_t frame, float value, float time1, float value1, float cx1, float cy1, float cx2, float cy2, float time2, float value2) {
((CurveTimeline1*)(BoneTimeline1*)self)->setBezier(bezier, frame, value, time1, value1, cx1, cy1, cx2, cy2, time2, value2);
void spine_bone_timeline1_set_bezier(spine_bone_timeline1 self, size_t bezier, size_t frame, float value, float time1, float value1, float cx1,
float cy1, float cx2, float cy2, float time2, float value2) {
CurveTimeline1 *_self = (CurveTimeline1 *) (BoneTimeline1 *) self;
_self->setBezier(bezier, frame, value, time1, value1, cx1, cy1, cx2, cy2, time2, value2);
}
float spine_bone_timeline1_get_bezier_value(spine_bone_timeline1 self, float time, size_t frame, size_t valueOffset, size_t i) {
return ((CurveTimeline1*)(BoneTimeline1*)self)->getBezierValue(time, frame, valueOffset, i);
CurveTimeline1 *_self = (CurveTimeline1 *) (BoneTimeline1 *) self;
return _self->getBezierValue(time, frame, valueOffset, i);
}
spine_array_float spine_bone_timeline1_get_curves(spine_bone_timeline1 self) {
return (spine_array_float)&((CurveTimeline1*)(BoneTimeline1*)self)->getCurves();
CurveTimeline1 *_self = (CurveTimeline1 *) (BoneTimeline1 *) self;
return (spine_array_float) &_self->getCurves();
}
size_t spine_bone_timeline1_get_frame_entries(spine_bone_timeline1 self) {
return ((CurveTimeline1*)(BoneTimeline1*)self)->getFrameEntries();
CurveTimeline1 *_self = (CurveTimeline1 *) (BoneTimeline1 *) self;
return _self->getFrameEntries();
}
size_t spine_bone_timeline1_get_frame_count(spine_bone_timeline1 self) {
return ((CurveTimeline1*)(BoneTimeline1*)self)->getFrameCount();
CurveTimeline1 *_self = (CurveTimeline1 *) (BoneTimeline1 *) self;
return _self->getFrameCount();
}
spine_array_float spine_bone_timeline1_get_frames(spine_bone_timeline1 self) {
return (spine_array_float)&((CurveTimeline1*)(BoneTimeline1*)self)->getFrames();
CurveTimeline1 *_self = (CurveTimeline1 *) (BoneTimeline1 *) self;
return (spine_array_float) &_self->getFrames();
}
float spine_bone_timeline1_get_duration(spine_bone_timeline1 self) {
return ((CurveTimeline1*)(BoneTimeline1*)self)->getDuration();
CurveTimeline1 *_self = (CurveTimeline1 *) (BoneTimeline1 *) self;
return _self->getDuration();
}
spine_array_property_id spine_bone_timeline1_get_property_ids(spine_bone_timeline1 self) {
return (spine_array_property_id)&((CurveTimeline1*)(BoneTimeline1*)self)->getPropertyIds();
CurveTimeline1 *_self = (CurveTimeline1 *) (BoneTimeline1 *) self;
return (spine_array_property_id) &_self->getPropertyIds();
}
int spine_bone_timeline1_get_bone_index(spine_bone_timeline1 self) {
return ((BoneTimeline*)(BoneTimeline1*)self)->getBoneIndex();
BoneTimeline *_self = (BoneTimeline *) (BoneTimeline1 *) self;
return _self->getBoneIndex();
}
void spine_bone_timeline1_set_bone_index(spine_bone_timeline1 self, int inValue) {
((BoneTimeline*)(BoneTimeline1*)self)->setBoneIndex(inValue);
BoneTimeline *_self = (BoneTimeline *) (BoneTimeline1 *) self;
_self->setBoneIndex(inValue);
}
spine_rtti spine_bone_timeline1_rtti(void) {
return (spine_rtti)&BoneTimeline1::rtti;
return (spine_rtti) &BoneTimeline1::rtti;
}

18
spine-c/src/generated/bone_timeline1.h
View File

@ -11,16 +11,22 @@ extern "C" {
SPINE_C_API void spine_bone_timeline1_dispose(spine_bone_timeline1 self);
SPINE_C_API spine_rtti spine_bone_timeline1_get_rtti(spine_bone_timeline1 self);
SPINE_C_API void spine_bone_timeline1_apply(spine_bone_timeline1 self, spine_skeleton skeleton, float lastTime, float time, spine_array_event pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction, bool appliedPose);
SPINE_C_API void spine_bone_timeline1_apply(spine_bone_timeline1 self, spine_skeleton skeleton, float lastTime, float time, spine_array_event pEvents,
float alpha, spine_mix_blend blend, spine_mix_direction direction, bool appliedPose);
SPINE_C_API void spine_bone_timeline1_set_frame(spine_bone_timeline1 self, size_t frame, float time, float value);
SPINE_C_API float spine_bone_timeline1_get_curve_value(spine_bone_timeline1 self, float time);
SPINE_C_API float spine_bone_timeline1_get_relative_value(spine_bone_timeline1 self, float time, float alpha, spine_mix_blend blend, float current, float setup);
SPINE_C_API float spine_bone_timeline1_get_absolute_value_1(spine_bone_timeline1 self, float time, float alpha, spine_mix_blend blend, float current, float setup);
SPINE_C_API float spine_bone_timeline1_get_absolute_value_2(spine_bone_timeline1 self, float time, float alpha, spine_mix_blend blend, float current, float setup, float value);
SPINE_C_API float spine_bone_timeline1_get_scale_value(spine_bone_timeline1 self, float time, float alpha, spine_mix_blend blend, spine_mix_direction direction, float current, float setup);
SPINE_C_API float spine_bone_timeline1_get_relative_value(spine_bone_timeline1 self, float time, float alpha, spine_mix_blend blend, float current,
float setup);
SPINE_C_API float spine_bone_timeline1_get_absolute_value_1(spine_bone_timeline1 self, float time, float alpha, spine_mix_blend blend, float current,
float setup);
SPINE_C_API float spine_bone_timeline1_get_absolute_value_2(spine_bone_timeline1 self, float time, float alpha, spine_mix_blend blend, float current,
float setup, float value);
SPINE_C_API float spine_bone_timeline1_get_scale_value(spine_bone_timeline1 self, float time, float alpha, spine_mix_blend blend,
spine_mix_direction direction, float current, float setup);
SPINE_C_API void spine_bone_timeline1_set_linear(spine_bone_timeline1 self, size_t frame);
SPINE_C_API void spine_bone_timeline1_set_stepped(spine_bone_timeline1 self, size_t frame);
SPINE_C_API void spine_bone_timeline1_set_bezier(spine_bone_timeline1 self, size_t bezier, size_t frame, float value, float time1, float value1, float cx1, float cy1, float cx2, float cy2, float time2, float value2);
SPINE_C_API void spine_bone_timeline1_set_bezier(spine_bone_timeline1 self, size_t bezier, size_t frame, float value, float time1, float value1,
float cx1, float cy1, float cx2, float cy2, float time2, float value2);
SPINE_C_API float spine_bone_timeline1_get_bezier_value(spine_bone_timeline1 self, float time, size_t frame, size_t valueOffset, size_t i);
SPINE_C_API spine_array_float spine_bone_timeline1_get_curves(spine_bone_timeline1 self);
SPINE_C_API size_t spine_bone_timeline1_get_frame_entries(spine_bone_timeline1 self);

59
spine-c/src/generated/bone_timeline2.cpp
View File

@ -4,73 +4,92 @@
using namespace spine;
void spine_bone_timeline2_dispose(spine_bone_timeline2 self) {
delete (BoneTimeline2*)self;
delete (BoneTimeline2 *) self;
}
spine_rtti spine_bone_timeline2_get_rtti(spine_bone_timeline2 self) {
return (spine_rtti)&((BoneTimeline2*)self)->getRTTI();
BoneTimeline2 *_self = (BoneTimeline2 *) self;
return (spine_rtti) &_self->getRTTI();
}
void spine_bone_timeline2_apply(spine_bone_timeline2 self, spine_skeleton skeleton, float lastTime, float time, spine_array_event pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction, bool appliedPose) {
((BoneTimeline2*)self)->apply(*((Skeleton*)skeleton), lastTime, time, (Array<Event *> *)pEvents, alpha, (MixBlend)blend, (MixDirection)direction, appliedPose);
void spine_bone_timeline2_apply(spine_bone_timeline2 self, spine_skeleton skeleton, float lastTime, float time, spine_array_event pEvents,
float alpha, spine_mix_blend blend, spine_mix_direction direction, bool appliedPose) {
BoneTimeline2 *_self = (BoneTimeline2 *) self;
_self->apply(*((Skeleton *) skeleton), lastTime, time, (Array<Event *> *) pEvents, alpha, (MixBlend) blend, (MixDirection) direction,
appliedPose);
}
void spine_bone_timeline2_set_frame(spine_bone_timeline2 self, size_t frame, float time, float value1, float value2) {
((CurveTimeline2*)(BoneTimeline2*)self)->setFrame(frame, time, value1, value2);
CurveTimeline2 *_self = (CurveTimeline2 *) (BoneTimeline2 *) self;
_self->setFrame(frame, time, value1, value2);
}
float spine_bone_timeline2_get_curve_value(spine_bone_timeline2 self, float time) {
return ((CurveTimeline2*)(BoneTimeline2*)self)->getCurveValue(time);
CurveTimeline2 *_self = (CurveTimeline2 *) (BoneTimeline2 *) self;
return _self->getCurveValue(time);
}
void spine_bone_timeline2_set_linear(spine_bone_timeline2 self, size_t frame) {
((CurveTimeline2*)(BoneTimeline2*)self)->setLinear(frame);
CurveTimeline2 *_self = (CurveTimeline2 *) (BoneTimeline2 *) self;
_self->setLinear(frame);
}
void spine_bone_timeline2_set_stepped(spine_bone_timeline2 self, size_t frame) {
((CurveTimeline2*)(BoneTimeline2*)self)->setStepped(frame);
CurveTimeline2 *_self = (CurveTimeline2 *) (BoneTimeline2 *) self;
_self->setStepped(frame);
}
void spine_bone_timeline2_set_bezier(spine_bone_timeline2 self, size_t bezier, size_t frame, float value, float time1, float value1, float cx1, float cy1, float cx2, float cy2, float time2, float value2) {
((CurveTimeline2*)(BoneTimeline2*)self)->setBezier(bezier, frame, value, time1, value1, cx1, cy1, cx2, cy2, time2, value2);
void spine_bone_timeline2_set_bezier(spine_bone_timeline2 self, size_t bezier, size_t frame, float value, float time1, float value1, float cx1,
float cy1, float cx2, float cy2, float time2, float value2) {
CurveTimeline2 *_self = (CurveTimeline2 *) (BoneTimeline2 *) self;
_self->setBezier(bezier, frame, value, time1, value1, cx1, cy1, cx2, cy2, time2, value2);
}
float spine_bone_timeline2_get_bezier_value(spine_bone_timeline2 self, float time, size_t frame, size_t valueOffset, size_t i) {
return ((CurveTimeline2*)(BoneTimeline2*)self)->getBezierValue(time, frame, valueOffset, i);
CurveTimeline2 *_self = (CurveTimeline2 *) (BoneTimeline2 *) self;
return _self->getBezierValue(time, frame, valueOffset, i);
}
spine_array_float spine_bone_timeline2_get_curves(spine_bone_timeline2 self) {
return (spine_array_float)&((CurveTimeline2*)(BoneTimeline2*)self)->getCurves();
CurveTimeline2 *_self = (CurveTimeline2 *) (BoneTimeline2 *) self;
return (spine_array_float) &_self->getCurves();
}
size_t spine_bone_timeline2_get_frame_entries(spine_bone_timeline2 self) {
return ((CurveTimeline2*)(BoneTimeline2*)self)->getFrameEntries();
CurveTimeline2 *_self = (CurveTimeline2 *) (BoneTimeline2 *) self;
return _self->getFrameEntries();
}
size_t spine_bone_timeline2_get_frame_count(spine_bone_timeline2 self) {
return ((CurveTimeline2*)(BoneTimeline2*)self)->getFrameCount();
CurveTimeline2 *_self = (CurveTimeline2 *) (BoneTimeline2 *) self;
return _self->getFrameCount();
}
spine_array_float spine_bone_timeline2_get_frames(spine_bone_timeline2 self) {
return (spine_array_float)&((CurveTimeline2*)(BoneTimeline2*)self)->getFrames();
CurveTimeline2 *_self = (CurveTimeline2 *) (BoneTimeline2 *) self;
return (spine_array_float) &_self->getFrames();
}
float spine_bone_timeline2_get_duration(spine_bone_timeline2 self) {
return ((CurveTimeline2*)(BoneTimeline2*)self)->getDuration();
CurveTimeline2 *_self = (CurveTimeline2 *) (BoneTimeline2 *) self;
return _self->getDuration();
}
spine_array_property_id spine_bone_timeline2_get_property_ids(spine_bone_timeline2 self) {
return (spine_array_property_id)&((CurveTimeline2*)(BoneTimeline2*)self)->getPropertyIds();
CurveTimeline2 *_self = (CurveTimeline2 *) (BoneTimeline2 *) self;
return (spine_array_property_id) &_self->getPropertyIds();
}
int spine_bone_timeline2_get_bone_index(spine_bone_timeline2 self) {
return ((BoneTimeline*)(BoneTimeline2*)self)->getBoneIndex();
BoneTimeline *_self = (BoneTimeline *) (BoneTimeline2 *) self;
return _self->getBoneIndex();
}
void spine_bone_timeline2_set_bone_index(spine_bone_timeline2 self, int inValue) {
((BoneTimeline*)(BoneTimeline2*)self)->setBoneIndex(inValue);
BoneTimeline *_self = (BoneTimeline *) (BoneTimeline2 *) self;
_self->setBoneIndex(inValue);
}
spine_rtti spine_bone_timeline2_rtti(void) {
return (spine_rtti)&BoneTimeline2::rtti;
return (spine_rtti) &BoneTimeline2::rtti;
}

6
spine-c/src/generated/bone_timeline2.h
View File

@ -11,12 +11,14 @@ extern "C" {
SPINE_C_API void spine_bone_timeline2_dispose(spine_bone_timeline2 self);
SPINE_C_API spine_rtti spine_bone_timeline2_get_rtti(spine_bone_timeline2 self);
SPINE_C_API void spine_bone_timeline2_apply(spine_bone_timeline2 self, spine_skeleton skeleton, float lastTime, float time, spine_array_event pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction, bool appliedPose);
SPINE_C_API void spine_bone_timeline2_apply(spine_bone_timeline2 self, spine_skeleton skeleton, float lastTime, float time, spine_array_event pEvents,
float alpha, spine_mix_blend blend, spine_mix_direction direction, bool appliedPose);
SPINE_C_API void spine_bone_timeline2_set_frame(spine_bone_timeline2 self, size_t frame, float time, float value1, float value2);
SPINE_C_API float spine_bone_timeline2_get_curve_value(spine_bone_timeline2 self, float time);
SPINE_C_API void spine_bone_timeline2_set_linear(spine_bone_timeline2 self, size_t frame);
SPINE_C_API void spine_bone_timeline2_set_stepped(spine_bone_timeline2 self, size_t frame);
SPINE_C_API void spine_bone_timeline2_set_bezier(spine_bone_timeline2 self, size_t bezier, size_t frame, float value, float time1, float value1, float cx1, float cy1, float cx2, float cy2, float time2, float value2);
SPINE_C_API void spine_bone_timeline2_set_bezier(spine_bone_timeline2 self, size_t bezier, size_t frame, float value, float time1, float value1,
float cx1, float cy1, float cx2, float cy2, float time2, float value2);
SPINE_C_API float spine_bone_timeline2_get_bezier_value(spine_bone_timeline2 self, float time, size_t frame, size_t valueOffset, size_t i);
SPINE_C_API spine_array_float spine_bone_timeline2_get_curves(spine_bone_timeline2 self);
SPINE_C_API size_t spine_bone_timeline2_get_frame_entries(spine_bone_timeline2 self);

74
spine-c/src/generated/bounding_box_attachment.cpp
View File

@ -3,90 +3,112 @@
using namespace spine;
spine_bounding_box_attachment spine_bounding_box_attachment_create(const char * name) {
return (spine_bounding_box_attachment) new (__FILE__, __LINE__) BoundingBoxAttachment(String(name));
spine_bounding_box_attachment spine_bounding_box_attachment_create(const char *name) {
return (spine_bounding_box_attachment) new (__FILE__, __LINE__) BoundingBoxAttachment(String(name));
}
void spine_bounding_box_attachment_dispose(spine_bounding_box_attachment self) {
delete (BoundingBoxAttachment*)self;
delete (BoundingBoxAttachment *) self;
}
spine_rtti spine_bounding_box_attachment_get_rtti(spine_bounding_box_attachment self) {
return (spine_rtti)&((BoundingBoxAttachment*)self)->getRTTI();
BoundingBoxAttachment *_self = (BoundingBoxAttachment *) self;
return (spine_rtti) &_self->getRTTI();
}
spine_color spine_bounding_box_attachment_get_color(spine_bounding_box_attachment self) {
return (spine_color)&((BoundingBoxAttachment*)self)->getColor();
BoundingBoxAttachment *_self = (BoundingBoxAttachment *) self;
return (spine_color) &_self->getColor();
}
spine_attachment spine_bounding_box_attachment_copy(spine_bounding_box_attachment self) {
return (spine_attachment)((BoundingBoxAttachment*)self)->copy();
BoundingBoxAttachment *_self = (BoundingBoxAttachment *) self;
return (spine_attachment) _self->copy();
}
void spine_bounding_box_attachment_compute_world_vertices_1(spine_bounding_box_attachment self, spine_skeleton skeleton, spine_slot slot, size_t start, size_t count, float * worldVertices, size_t offset, size_t stride) {
((VertexAttachment*)(BoundingBoxAttachment*)self)->computeWorldVertices(*((Skeleton*)skeleton), *((Slot*)slot), start, count, worldVertices, offset, stride);
void spine_bounding_box_attachment_compute_world_vertices_1(spine_bounding_box_attachment self, spine_skeleton skeleton, spine_slot slot,
size_t start, size_t count, float *worldVertices, size_t offset, size_t stride) {
VertexAttachment *_self = (VertexAttachment *) (BoundingBoxAttachment *) self;
_self->computeWorldVertices(*((Skeleton *) skeleton), *((Slot *) slot), start, count, worldVertices, offset, stride);
}
void spine_bounding_box_attachment_compute_world_vertices_2(spine_bounding_box_attachment self, spine_skeleton skeleton, spine_slot slot, size_t start, size_t count, spine_array_float worldVertices, size_t offset, size_t stride) {
((VertexAttachment*)(BoundingBoxAttachment*)self)->computeWorldVertices(*((Skeleton*)skeleton), *((Slot*)slot), start, count, *((Array<float>*)worldVertices), offset, stride);
void spine_bounding_box_attachment_compute_world_vertices_2(spine_bounding_box_attachment self, spine_skeleton skeleton, spine_slot slot,
size_t start, size_t count, spine_array_float worldVertices, size_t offset,
size_t stride) {
VertexAttachment *_self = (VertexAttachment *) (BoundingBoxAttachment *) self;
_self->computeWorldVertices(*((Skeleton *) skeleton), *((Slot *) slot), start, count, *((Array<float> *) worldVertices), offset, stride);
}
int spine_bounding_box_attachment_get_id(spine_bounding_box_attachment self) {
return ((VertexAttachment*)(BoundingBoxAttachment*)self)->getId();
VertexAttachment *_self = (VertexAttachment *) (BoundingBoxAttachment *) self;
return _self->getId();
}
spine_array_int spine_bounding_box_attachment_get_bones(spine_bounding_box_attachment self) {
return (spine_array_int)&((VertexAttachment*)(BoundingBoxAttachment*)self)->getBones();
VertexAttachment *_self = (VertexAttachment *) (BoundingBoxAttachment *) self;
return (spine_array_int) &_self->getBones();
}
void spine_bounding_box_attachment_set_bones(spine_bounding_box_attachment self, spine_array_int bones) {
((VertexAttachment*)(BoundingBoxAttachment*)self)->setBones(*((Array<int>*)bones));
VertexAttachment *_self = (VertexAttachment *) (BoundingBoxAttachment *) self;
_self->setBones(*((Array<int> *) bones));
}
spine_array_float spine_bounding_box_attachment_get_vertices(spine_bounding_box_attachment self) {
return (spine_array_float)&((VertexAttachment*)(BoundingBoxAttachment*)self)->getVertices();
VertexAttachment *_self = (VertexAttachment *) (BoundingBoxAttachment *) self;
return (spine_array_float) &_self->getVertices();
}
void spine_bounding_box_attachment_set_vertices(spine_bounding_box_attachment self, spine_array_float vertices) {
((VertexAttachment*)(BoundingBoxAttachment*)self)->setVertices(*((Array<float>*)vertices));
VertexAttachment *_self = (VertexAttachment *) (BoundingBoxAttachment *) self;
_self->setVertices(*((Array<float> *) vertices));
}
size_t spine_bounding_box_attachment_get_world_vertices_length(spine_bounding_box_attachment self) {
return ((VertexAttachment*)(BoundingBoxAttachment*)self)->getWorldVerticesLength();
VertexAttachment *_self = (VertexAttachment *) (BoundingBoxAttachment *) self;
return _self->getWorldVerticesLength();
}
void spine_bounding_box_attachment_set_world_vertices_length(spine_bounding_box_attachment self, size_t inValue) {
((VertexAttachment*)(BoundingBoxAttachment*)self)->setWorldVerticesLength(inValue);
VertexAttachment *_self = (VertexAttachment *) (BoundingBoxAttachment *) self;
_self->setWorldVerticesLength(inValue);
}
spine_attachment spine_bounding_box_attachment_get_timeline_attachment(spine_bounding_box_attachment self) {
return (spine_attachment)((VertexAttachment*)(BoundingBoxAttachment*)self)->getTimelineAttachment();
VertexAttachment *_self = (VertexAttachment *) (BoundingBoxAttachment *) self;
return (spine_attachment) _self->getTimelineAttachment();
}
void spine_bounding_box_attachment_set_timeline_attachment(spine_bounding_box_attachment self, spine_attachment attachment) {
((VertexAttachment*)(BoundingBoxAttachment*)self)->setTimelineAttachment((Attachment *)attachment);
VertexAttachment *_self = (VertexAttachment *) (BoundingBoxAttachment *) self;
_self->setTimelineAttachment((Attachment *) attachment);
}
void spine_bounding_box_attachment_copy_to(spine_bounding_box_attachment self, spine_vertex_attachment other) {
((VertexAttachment*)(BoundingBoxAttachment*)self)->copyTo((VertexAttachment *)other);
VertexAttachment *_self = (VertexAttachment *) (BoundingBoxAttachment *) self;
_self->copyTo((VertexAttachment *) other);
}
const char * spine_bounding_box_attachment_get_name(spine_bounding_box_attachment self) {
return ((VertexAttachment*)(BoundingBoxAttachment*)self)->getName().buffer();
const char *spine_bounding_box_attachment_get_name(spine_bounding_box_attachment self) {
VertexAttachment *_self = (VertexAttachment *) (BoundingBoxAttachment *) self;
return _self->getName().buffer();
}
int spine_bounding_box_attachment_get_ref_count(spine_bounding_box_attachment self) {
return ((VertexAttachment*)(BoundingBoxAttachment*)self)->getRefCount();
VertexAttachment *_self = (VertexAttachment *) (BoundingBoxAttachment *) self;
return _self->getRefCount();
}
void spine_bounding_box_attachment_reference(spine_bounding_box_attachment self) {
((VertexAttachment*)(BoundingBoxAttachment*)self)->reference();
VertexAttachment *_self = (VertexAttachment *) (BoundingBoxAttachment *) self;
_self->reference();
}
void spine_bounding_box_attachment_dereference(spine_bounding_box_attachment self) {
((VertexAttachment*)(BoundingBoxAttachment*)self)->dereference();
VertexAttachment *_self = (VertexAttachment *) (BoundingBoxAttachment *) self;
_self->dereference();
}
spine_rtti spine_bounding_box_attachment_rtti(void) {
return (spine_rtti)&BoundingBoxAttachment::rtti;
return (spine_rtti) &BoundingBoxAttachment::rtti;
}

12
spine-c/src/generated/bounding_box_attachment.h
View File

@ -8,15 +8,19 @@
extern "C" {
#endif
SPINE_C_API spine_bounding_box_attachment spine_bounding_box_attachment_create(const char * name);
SPINE_C_API spine_bounding_box_attachment spine_bounding_box_attachment_create(const char *name);
SPINE_C_API void spine_bounding_box_attachment_dispose(spine_bounding_box_attachment self);
SPINE_C_API spine_rtti spine_bounding_box_attachment_get_rtti(spine_bounding_box_attachment self);
SPINE_C_API spine_color spine_bounding_box_attachment_get_color(spine_bounding_box_attachment self);
SPINE_C_API spine_attachment spine_bounding_box_attachment_copy(spine_bounding_box_attachment self);
SPINE_C_API void spine_bounding_box_attachment_compute_world_vertices_1(spine_bounding_box_attachment self, spine_skeleton skeleton, spine_slot slot, size_t start, size_t count, float * worldVertices, size_t offset, size_t stride);
SPINE_C_API void spine_bounding_box_attachment_compute_world_vertices_2(spine_bounding_box_attachment self, spine_skeleton skeleton, spine_slot slot, size_t start, size_t count, spine_array_float worldVertices, size_t offset, size_t stride);
SPINE_C_API void spine_bounding_box_attachment_compute_world_vertices_1(spine_bounding_box_attachment self, spine_skeleton skeleton, spine_slot slot,
size_t start, size_t count, float *worldVertices, size_t offset,
size_t stride);
SPINE_C_API void spine_bounding_box_attachment_compute_world_vertices_2(spine_bounding_box_attachment self, spine_skeleton skeleton, spine_slot slot,
size_t start, size_t count, spine_array_float worldVertices, size_t offset,
size_t stride);
SPINE_C_API int spine_bounding_box_attachment_get_id(spine_bounding_box_attachment self);
SPINE_C_API spine_array_int spine_bounding_box_attachment_get_bones(spine_bounding_box_attachment self);
SPINE_C_API void spine_bounding_box_attachment_set_bones(spine_bounding_box_attachment self, spine_array_int bones);
@ -27,7 +31,7 @@ SPINE_C_API void spine_bounding_box_attachment_set_world_vertices_length(spine_b
SPINE_C_API spine_attachment spine_bounding_box_attachment_get_timeline_attachment(spine_bounding_box_attachment self);
SPINE_C_API void spine_bounding_box_attachment_set_timeline_attachment(spine_bounding_box_attachment self, spine_attachment attachment);
SPINE_C_API void spine_bounding_box_attachment_copy_to(spine_bounding_box_attachment self, spine_vertex_attachment other);
SPINE_C_API const char * spine_bounding_box_attachment_get_name(spine_bounding_box_attachment self);
SPINE_C_API const char *spine_bounding_box_attachment_get_name(spine_bounding_box_attachment self);
SPINE_C_API int spine_bounding_box_attachment_get_ref_count(spine_bounding_box_attachment self);
SPINE_C_API void spine_bounding_box_attachment_reference(spine_bounding_box_attachment self);
SPINE_C_API void spine_bounding_box_attachment_dereference(spine_bounding_box_attachment self);

79
spine-c/src/generated/clipping_attachment.cpp
View File

@ -3,98 +3,121 @@
using namespace spine;
spine_clipping_attachment spine_clipping_attachment_create(const char * name) {
return (spine_clipping_attachment) new (__FILE__, __LINE__) ClippingAttachment(String(name));
spine_clipping_attachment spine_clipping_attachment_create(const char *name) {
return (spine_clipping_attachment) new (__FILE__, __LINE__) ClippingAttachment(String(name));
}
void spine_clipping_attachment_dispose(spine_clipping_attachment self) {
delete (ClippingAttachment*)self;
delete (ClippingAttachment *) self;
}
spine_rtti spine_clipping_attachment_get_rtti(spine_clipping_attachment self) {
return (spine_rtti)&((ClippingAttachment*)self)->getRTTI();
ClippingAttachment *_self = (ClippingAttachment *) self;
return (spine_rtti) &_self->getRTTI();
}
spine_slot_data spine_clipping_attachment_get_end_slot(spine_clipping_attachment self) {
return (spine_slot_data)((ClippingAttachment*)self)->getEndSlot();
ClippingAttachment *_self = (ClippingAttachment *) self;
return (spine_slot_data) _self->getEndSlot();
}
void spine_clipping_attachment_set_end_slot(spine_clipping_attachment self, spine_slot_data inValue) {
((ClippingAttachment*)self)->setEndSlot((SlotData *)inValue);
ClippingAttachment *_self = (ClippingAttachment *) self;
_self->setEndSlot((SlotData *) inValue);
}
spine_color spine_clipping_attachment_get_color(spine_clipping_attachment self) {
return (spine_color)&((ClippingAttachment*)self)->getColor();
ClippingAttachment *_self = (ClippingAttachment *) self;
return (spine_color) &_self->getColor();
}
spine_attachment spine_clipping_attachment_copy(spine_clipping_attachment self) {
return (spine_attachment)((ClippingAttachment*)self)->copy();
ClippingAttachment *_self = (ClippingAttachment *) self;
return (spine_attachment) _self->copy();
}
void spine_clipping_attachment_compute_world_vertices_1(spine_clipping_attachment self, spine_skeleton skeleton, spine_slot slot, size_t start, size_t count, float * worldVertices, size_t offset, size_t stride) {
((VertexAttachment*)(ClippingAttachment*)self)->computeWorldVertices(*((Skeleton*)skeleton), *((Slot*)slot), start, count, worldVertices, offset, stride);
void spine_clipping_attachment_compute_world_vertices_1(spine_clipping_attachment self, spine_skeleton skeleton, spine_slot slot, size_t start,
size_t count, float *worldVertices, size_t offset, size_t stride) {
VertexAttachment *_self = (VertexAttachment *) (ClippingAttachment *) self;
_self->computeWorldVertices(*((Skeleton *) skeleton), *((Slot *) slot), start, count, worldVertices, offset, stride);
}
void spine_clipping_attachment_compute_world_vertices_2(spine_clipping_attachment self, spine_skeleton skeleton, spine_slot slot, size_t start, size_t count, spine_array_float worldVertices, size_t offset, size_t stride) {
((VertexAttachment*)(ClippingAttachment*)self)->computeWorldVertices(*((Skeleton*)skeleton), *((Slot*)slot), start, count, *((Array<float>*)worldVertices), offset, stride);
void spine_clipping_attachment_compute_world_vertices_2(spine_clipping_attachment self, spine_skeleton skeleton, spine_slot slot, size_t start,
size_t count, spine_array_float worldVertices, size_t offset, size_t stride) {
VertexAttachment *_self = (VertexAttachment *) (ClippingAttachment *) self;
_self->computeWorldVertices(*((Skeleton *) skeleton), *((Slot *) slot), start, count, *((Array<float> *) worldVertices), offset, stride);
}
int spine_clipping_attachment_get_id(spine_clipping_attachment self) {
return ((VertexAttachment*)(ClippingAttachment*)self)->getId();
VertexAttachment *_self = (VertexAttachment *) (ClippingAttachment *) self;
return _self->getId();
}
spine_array_int spine_clipping_attachment_get_bones(spine_clipping_attachment self) {
return (spine_array_int)&((VertexAttachment*)(ClippingAttachment*)self)->getBones();
VertexAttachment *_self = (VertexAttachment *) (ClippingAttachment *) self;
return (spine_array_int) &_self->getBones();
}
void spine_clipping_attachment_set_bones(spine_clipping_attachment self, spine_array_int bones) {
((VertexAttachment*)(ClippingAttachment*)self)->setBones(*((Array<int>*)bones));
VertexAttachment *_self = (VertexAttachment *) (ClippingAttachment *) self;
_self->setBones(*((Array<int> *) bones));
}
spine_array_float spine_clipping_attachment_get_vertices(spine_clipping_attachment self) {
return (spine_array_float)&((VertexAttachment*)(ClippingAttachment*)self)->getVertices();
VertexAttachment *_self = (VertexAttachment *) (ClippingAttachment *) self;
return (spine_array_float) &_self->getVertices();
}
void spine_clipping_attachment_set_vertices(spine_clipping_attachment self, spine_array_float vertices) {
((VertexAttachment*)(ClippingAttachment*)self)->setVertices(*((Array<float>*)vertices));
VertexAttachment *_self = (VertexAttachment *) (ClippingAttachment *) self;
_self->setVertices(*((Array<float> *) vertices));
}
size_t spine_clipping_attachment_get_world_vertices_length(spine_clipping_attachment self) {
return ((VertexAttachment*)(ClippingAttachment*)self)->getWorldVerticesLength();
VertexAttachment *_self = (VertexAttachment *) (ClippingAttachment *) self;
return _self->getWorldVerticesLength();
}
void spine_clipping_attachment_set_world_vertices_length(spine_clipping_attachment self, size_t inValue) {
((VertexAttachment*)(ClippingAttachment*)self)->setWorldVerticesLength(inValue);
VertexAttachment *_self = (VertexAttachment *) (ClippingAttachment *) self;
_self->setWorldVerticesLength(inValue);
}
spine_attachment spine_clipping_attachment_get_timeline_attachment(spine_clipping_attachment self) {
return (spine_attachment)((VertexAttachment*)(ClippingAttachment*)self)->getTimelineAttachment();
VertexAttachment *_self = (VertexAttachment *) (ClippingAttachment *) self;
return (spine_attachment) _self->getTimelineAttachment();
}
void spine_clipping_attachment_set_timeline_attachment(spine_clipping_attachment self, spine_attachment attachment) {
((VertexAttachment*)(ClippingAttachment*)self)->setTimelineAttachment((Attachment *)attachment);
VertexAttachment *_self = (VertexAttachment *) (ClippingAttachment *) self;
_self->setTimelineAttachment((Attachment *) attachment);
}
void spine_clipping_attachment_copy_to(spine_clipping_attachment self, spine_vertex_attachment other) {
((VertexAttachment*)(ClippingAttachment*)self)->copyTo((VertexAttachment *)other);
VertexAttachment *_self = (VertexAttachment *) (ClippingAttachment *) self;
_self->copyTo((VertexAttachment *) other);
}
const char * spine_clipping_attachment_get_name(spine_clipping_attachment self) {
return ((VertexAttachment*)(ClippingAttachment*)self)->getName().buffer();
const char *spine_clipping_attachment_get_name(spine_clipping_attachment self) {
VertexAttachment *_self = (VertexAttachment *) (ClippingAttachment *) self;
return _self->getName().buffer();
}
int spine_clipping_attachment_get_ref_count(spine_clipping_attachment self) {
return ((VertexAttachment*)(ClippingAttachment*)self)->getRefCount();
VertexAttachment *_self = (VertexAttachment *) (ClippingAttachment *) self;
return _self->getRefCount();
}
void spine_clipping_attachment_reference(spine_clipping_attachment self) {
((VertexAttachment*)(ClippingAttachment*)self)->reference();
VertexAttachment *_self = (VertexAttachment *) (ClippingAttachment *) self;
_self->reference();
}
void spine_clipping_attachment_dereference(spine_clipping_attachment self) {
((VertexAttachment*)(ClippingAttachment*)self)->dereference();
VertexAttachment *_self = (VertexAttachment *) (ClippingAttachment *) self;
_self->dereference();
}
spine_rtti spine_clipping_attachment_rtti(void) {
return (spine_rtti)&ClippingAttachment::rtti;
return (spine_rtti) &ClippingAttachment::rtti;
}

11
spine-c/src/generated/clipping_attachment.h
View File

@ -8,7 +8,7 @@
extern "C" {
#endif
SPINE_C_API spine_clipping_attachment spine_clipping_attachment_create(const char * name);
SPINE_C_API spine_clipping_attachment spine_clipping_attachment_create(const char *name);
SPINE_C_API void spine_clipping_attachment_dispose(spine_clipping_attachment self);
@ -17,8 +17,11 @@ SPINE_C_API spine_slot_data spine_clipping_attachment_get_end_slot(spine_clippin
SPINE_C_API void spine_clipping_attachment_set_end_slot(spine_clipping_attachment self, spine_slot_data inValue);
SPINE_C_API spine_color spine_clipping_attachment_get_color(spine_clipping_attachment self);
SPINE_C_API spine_attachment spine_clipping_attachment_copy(spine_clipping_attachment self);
SPINE_C_API void spine_clipping_attachment_compute_world_vertices_1(spine_clipping_attachment self, spine_skeleton skeleton, spine_slot slot, size_t start, size_t count, float * worldVertices, size_t offset, size_t stride);
SPINE_C_API void spine_clipping_attachment_compute_world_vertices_2(spine_clipping_attachment self, spine_skeleton skeleton, spine_slot slot, size_t start, size_t count, spine_array_float worldVertices, size_t offset, size_t stride);
SPINE_C_API void spine_clipping_attachment_compute_world_vertices_1(spine_clipping_attachment self, spine_skeleton skeleton, spine_slot slot,
size_t start, size_t count, float *worldVertices, size_t offset, size_t stride);
SPINE_C_API void spine_clipping_attachment_compute_world_vertices_2(spine_clipping_attachment self, spine_skeleton skeleton, spine_slot slot,
size_t start, size_t count, spine_array_float worldVertices, size_t offset,
size_t stride);
SPINE_C_API int spine_clipping_attachment_get_id(spine_clipping_attachment self);
SPINE_C_API spine_array_int spine_clipping_attachment_get_bones(spine_clipping_attachment self);
SPINE_C_API void spine_clipping_attachment_set_bones(spine_clipping_attachment self, spine_array_int bones);
@ -29,7 +32,7 @@ SPINE_C_API void spine_clipping_attachment_set_world_vertices_length(spine_clipp
SPINE_C_API spine_attachment spine_clipping_attachment_get_timeline_attachment(spine_clipping_attachment self);
SPINE_C_API void spine_clipping_attachment_set_timeline_attachment(spine_clipping_attachment self, spine_attachment attachment);
SPINE_C_API void spine_clipping_attachment_copy_to(spine_clipping_attachment self, spine_vertex_attachment other);
SPINE_C_API const char * spine_clipping_attachment_get_name(spine_clipping_attachment self);
SPINE_C_API const char *spine_clipping_attachment_get_name(spine_clipping_attachment self);
SPINE_C_API int spine_clipping_attachment_get_ref_count(spine_clipping_attachment self);
SPINE_C_API void spine_clipping_attachment_reference(spine_clipping_attachment self);
SPINE_C_API void spine_clipping_attachment_dereference(spine_clipping_attachment self);

59
spine-c/src/generated/color.cpp
View File

@ -4,85 +4,100 @@
using namespace spine;
spine_color spine_color_create(void) {
return (spine_color) new (__FILE__, __LINE__) Color();
return (spine_color) new (__FILE__, __LINE__) Color();
}
spine_color spine_color_create2(float r, float g, float b, float a) {
return (spine_color) new (__FILE__, __LINE__) Color(r, g, b, a);
return (spine_color) new (__FILE__, __LINE__) Color(r, g, b, a);
}
void spine_color_dispose(spine_color self) {
delete (Color*)self;
delete (Color *) self;
}
spine_color spine_color_set_1(spine_color self, float _r, float _g, float _b, float _a) {
return (spine_color)&((Color*)self)->set(_r, _g, _b, _a);
Color *_self = (Color *) self;
return (spine_color) &_self->set(_r, _g, _b, _a);
}
spine_color spine_color_set_2(spine_color self, float _r, float _g, float _b) {
return (spine_color)&((Color*)self)->set(_r, _g, _b);
Color *_self = (Color *) self;
return (spine_color) &_self->set(_r, _g, _b);
}
spine_color spine_color_set_3(spine_color self, spine_color other) {
return (spine_color)&((Color*)self)->set(*((const Color*)other));
Color *_self = (Color *) self;
return (spine_color) &_self->set(*((const Color *) other));
}
spine_color spine_color_add_1(spine_color self, float _r, float _g, float _b, float _a) {
return (spine_color)&((Color*)self)->add(_r, _g, _b, _a);
Color *_self = (Color *) self;
return (spine_color) &_self->add(_r, _g, _b, _a);
}
spine_color spine_color_add_2(spine_color self, float _r, float _g, float _b) {
return (spine_color)&((Color*)self)->add(_r, _g, _b);
Color *_self = (Color *) self;
return (spine_color) &_self->add(_r, _g, _b);
}
spine_color spine_color_add_3(spine_color self, spine_color other) {
return (spine_color)&((Color*)self)->add(*((const Color*)other));
Color *_self = (Color *) self;
return (spine_color) &_self->add(*((const Color *) other));
}
spine_color spine_color_clamp(spine_color self) {
return (spine_color)&((Color*)self)->clamp();
Color *_self = (Color *) self;
return (spine_color) &_self->clamp();
}
float spine_color_parse_hex(const char * value, size_t index) {
return Color::parseHex(value, index);
float spine_color_parse_hex(const char *value, size_t index) {
return Color::parseHex(value, index);
}
void spine_color_rgba8888_to_color(spine_color color, int value) {
Color::rgba8888ToColor(*((Color*)color), value);
Color::rgba8888ToColor(*((Color *) color), value);
}
void spine_color_rgb888_to_color(spine_color color, int value) {
Color::rgb888ToColor(*((Color*)color), value);
Color::rgb888ToColor(*((Color *) color), value);
}
float spine_color_get_r(spine_color self) {
return ((Color*)self)->r;
Color *_self = (Color *) self;
return _self->r;
}
void spine_color_set_r(spine_color self, float value) {
((Color*)self)->r = value;
Color *_self = (Color *) self;
_self->r = value;
}
float spine_color_get_g(spine_color self) {
return ((Color*)self)->g;
Color *_self = (Color *) self;
return _self->g;
}
void spine_color_set_g(spine_color self, float value) {
((Color*)self)->g = value;
Color *_self = (Color *) self;
_self->g = value;
}
float spine_color_get_b(spine_color self) {
return ((Color*)self)->b;
Color *_self = (Color *) self;
return _self->b;
}
void spine_color_set_b(spine_color self, float value) {
((Color*)self)->b = value;
Color *_self = (Color *) self;
_self->b = value;
}
float spine_color_get_a(spine_color self) {
return ((Color*)self)->a;
Color *_self = (Color *) self;
return _self->a;
}
void spine_color_set_a(spine_color self, float value) {
((Color*)self)->a = value;
Color *_self = (Color *) self;
_self->a = value;
}

2
spine-c/src/generated/color.h
View File

@ -20,7 +20,7 @@ SPINE_C_API spine_color spine_color_add_1(spine_color self, float _r, float _g,
SPINE_C_API spine_color spine_color_add_2(spine_color self, float _r, float _g, float _b);
SPINE_C_API spine_color spine_color_add_3(spine_color self, spine_color other);
SPINE_C_API spine_color spine_color_clamp(spine_color self);
SPINE_C_API float spine_color_parse_hex(const char * value, size_t index);
SPINE_C_API float spine_color_parse_hex(const char *value, size_t index);
SPINE_C_API void spine_color_rgba8888_to_color(spine_color color, int value);
SPINE_C_API void spine_color_rgb888_to_color(spine_color color, int value);
SPINE_C_API float spine_color_get_r(spine_color self);

19
spine-c/src/generated/constraint.cpp
View File

@ -4,29 +4,34 @@
using namespace spine;
void spine_constraint_dispose(spine_constraint self) {
delete (Constraint*)self;
delete (Constraint *) self;
}
spine_rtti spine_constraint_get_rtti(spine_constraint self) {
return (spine_rtti)&((Constraint*)self)->getRTTI();
Constraint *_self = (Constraint *) self;
return (spine_rtti) &_self->getRTTI();
}
spine_constraint_data spine_constraint_get_data(spine_constraint self) {
return (spine_constraint_data)&((Constraint*)self)->getData();
Constraint *_self = (Constraint *) self;
return (spine_constraint_data) &_self->getData();
}
void spine_constraint_sort(spine_constraint self, spine_skeleton skeleton) {
((Constraint*)self)->sort(*((Skeleton*)skeleton));
Constraint *_self = (Constraint *) self;
_self->sort(*((Skeleton *) skeleton));
}
bool spine_constraint_is_source_active(spine_constraint self) {
return ((Constraint*)self)->isSourceActive();
Constraint *_self = (Constraint *) self;
return _self->isSourceActive();
}
void spine_constraint_update(spine_constraint self, spine_skeleton skeleton, spine_physics physics) {
((Constraint*)self)->update(*((Skeleton*)skeleton), (Physics)physics);
Constraint *_self = (Constraint *) self;
_self->update(*((Skeleton *) skeleton), (Physics) physics);
}
spine_rtti spine_constraint_rtti(void) {
return (spine_rtti)&Constraint::rtti;
return (spine_rtti) &Constraint::rtti;
}

18
spine-c/src/generated/constraint_data.cpp
View File

@ -4,25 +4,29 @@
using namespace spine;
void spine_constraint_data_dispose(spine_constraint_data self) {
delete (ConstraintData*)self;
delete (ConstraintData *) self;
}
spine_rtti spine_constraint_data_get_rtti(spine_constraint_data self) {
return (spine_rtti)&((ConstraintData*)self)->getRTTI();
ConstraintData *_self = (ConstraintData *) self;
return (spine_rtti) &_self->getRTTI();
}
spine_constraint spine_constraint_data_create_method(spine_constraint_data self, spine_skeleton skeleton) {
return (spine_constraint)((ConstraintData*)self)->create(*((Skeleton*)skeleton));
ConstraintData *_self = (ConstraintData *) self;
return (spine_constraint) _self->create(*((Skeleton *) skeleton));
}
const char * spine_constraint_data_get_name(spine_constraint_data self) {
return ((ConstraintData*)self)->getName().buffer();
const char *spine_constraint_data_get_name(spine_constraint_data self) {
ConstraintData *_self = (ConstraintData *) self;
return _self->getName().buffer();
}
bool spine_constraint_data_get_skin_required(spine_constraint_data self) {
return ((ConstraintData*)self)->getSkinRequired();
ConstraintData *_self = (ConstraintData *) self;
return _self->getSkinRequired();
}
spine_rtti spine_constraint_data_rtti(void) {
return (spine_rtti)&ConstraintData::rtti;
return (spine_rtti) &ConstraintData::rtti;
}

2
spine-c/src/generated/constraint_data.h
View File

@ -12,7 +12,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 const char *spine_constraint_data_get_name(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);

13
spine-c/src/generated/constraint_timeline.cpp
View File

@ -4,21 +4,24 @@
using namespace spine;
void spine_constraint_timeline_dispose(spine_constraint_timeline self) {
delete (ConstraintTimeline*)self;
delete (ConstraintTimeline *) self;
}
spine_rtti spine_constraint_timeline_get_rtti(spine_constraint_timeline self) {
return (spine_rtti)&((ConstraintTimeline*)self)->getRTTI();
ConstraintTimeline *_self = (ConstraintTimeline *) self;
return (spine_rtti) &_self->getRTTI();
}
int spine_constraint_timeline_get_constraint_index(spine_constraint_timeline self) {
return ((ConstraintTimeline*)self)->getConstraintIndex();
ConstraintTimeline *_self = (ConstraintTimeline *) self;
return _self->getConstraintIndex();
}
void spine_constraint_timeline_set_constraint_index(spine_constraint_timeline self, int inValue) {
((ConstraintTimeline*)self)->setConstraintIndex(inValue);
ConstraintTimeline *_self = (ConstraintTimeline *) self;
_self->setConstraintIndex(inValue);
}
spine_rtti spine_constraint_timeline_rtti(void) {
return (spine_rtti)&ConstraintTimeline::rtti;
return (spine_rtti) &ConstraintTimeline::rtti;
}

83
spine-c/src/generated/constraint_timeline1.cpp
View File

@ -4,89 +4,116 @@
using namespace spine;
void spine_constraint_timeline1_dispose(spine_constraint_timeline1 self) {
delete (ConstraintTimeline1*)self;
delete (ConstraintTimeline1 *) self;
}
spine_rtti spine_constraint_timeline1_get_rtti(spine_constraint_timeline1 self) {
return (spine_rtti)&((ConstraintTimeline1*)self)->getRTTI();
ConstraintTimeline1 *_self = (ConstraintTimeline1 *) self;
return (spine_rtti) &_self->getRTTI();
}
void spine_constraint_timeline1_set_frame(spine_constraint_timeline1 self, size_t frame, float time, float value) {
((CurveTimeline1*)(ConstraintTimeline1*)self)->setFrame(frame, time, value);
CurveTimeline1 *_self = (CurveTimeline1 *) (ConstraintTimeline1 *) self;
_self->setFrame(frame, time, value);
}
float spine_constraint_timeline1_get_curve_value(spine_constraint_timeline1 self, float time) {
return ((CurveTimeline1*)(ConstraintTimeline1*)self)->getCurveValue(time);
CurveTimeline1 *_self = (CurveTimeline1 *) (ConstraintTimeline1 *) self;
return _self->getCurveValue(time);
}
float spine_constraint_timeline1_get_relative_value(spine_constraint_timeline1 self, float time, float alpha, spine_mix_blend blend, float current, float setup) {
return ((CurveTimeline1*)(ConstraintTimeline1*)self)->getRelativeValue(time, alpha, (MixBlend)blend, current, setup);
float spine_constraint_timeline1_get_relative_value(spine_constraint_timeline1 self, float time, float alpha, spine_mix_blend blend, float current,
float setup) {
CurveTimeline1 *_self = (CurveTimeline1 *) (ConstraintTimeline1 *) self;
return _self->getRelativeValue(time, alpha, (MixBlend) blend, current, setup);
}
float spine_constraint_timeline1_get_absolute_value_1(spine_constraint_timeline1 self, float time, float alpha, spine_mix_blend blend, float current, float setup) {
return ((CurveTimeline1*)(ConstraintTimeline1*)self)->getAbsoluteValue(time, alpha, (MixBlend)blend, current, setup);
float spine_constraint_timeline1_get_absolute_value_1(spine_constraint_timeline1 self, float time, float alpha, spine_mix_blend blend, float current,
float setup) {
CurveTimeline1 *_self = (CurveTimeline1 *) (ConstraintTimeline1 *) self;
return _self->getAbsoluteValue(time, alpha, (MixBlend) blend, current, setup);
}
float spine_constraint_timeline1_get_absolute_value_2(spine_constraint_timeline1 self, float time, float alpha, spine_mix_blend blend, float current, float setup, float value) {
return ((CurveTimeline1*)(ConstraintTimeline1*)self)->getAbsoluteValue(time, alpha, (MixBlend)blend, current, setup, value);
float spine_constraint_timeline1_get_absolute_value_2(spine_constraint_timeline1 self, float time, float alpha, spine_mix_blend blend, float current,
float setup, float value) {
CurveTimeline1 *_self = (CurveTimeline1 *) (ConstraintTimeline1 *) self;
return _self->getAbsoluteValue(time, alpha, (MixBlend) blend, current, setup, value);
}
float spine_constraint_timeline1_get_scale_value(spine_constraint_timeline1 self, float time, float alpha, spine_mix_blend blend, spine_mix_direction direction, float current, float setup) {
return ((CurveTimeline1*)(ConstraintTimeline1*)self)->getScaleValue(time, alpha, (MixBlend)blend, (MixDirection)direction, current, setup);
float spine_constraint_timeline1_get_scale_value(spine_constraint_timeline1 self, float time, float alpha, spine_mix_blend blend,
spine_mix_direction direction, float current, float setup) {
CurveTimeline1 *_self = (CurveTimeline1 *) (ConstraintTimeline1 *) self;
return _self->getScaleValue(time, alpha, (MixBlend) blend, (MixDirection) direction, current, setup);
}
void spine_constraint_timeline1_set_linear(spine_constraint_timeline1 self, size_t frame) {
((CurveTimeline1*)(ConstraintTimeline1*)self)->setLinear(frame);
CurveTimeline1 *_self = (CurveTimeline1 *) (ConstraintTimeline1 *) self;
_self->setLinear(frame);
}
void spine_constraint_timeline1_set_stepped(spine_constraint_timeline1 self, size_t frame) {
((CurveTimeline1*)(ConstraintTimeline1*)self)->setStepped(frame);
CurveTimeline1 *_self = (CurveTimeline1 *) (ConstraintTimeline1 *) self;
_self->setStepped(frame);
}
void spine_constraint_timeline1_set_bezier(spine_constraint_timeline1 self, size_t bezier, size_t frame, float value, float time1, float value1, float cx1, float cy1, float cx2, float cy2, float time2, float value2) {
((CurveTimeline1*)(ConstraintTimeline1*)self)->setBezier(bezier, frame, value, time1, value1, cx1, cy1, cx2, cy2, time2, value2);
void spine_constraint_timeline1_set_bezier(spine_constraint_timeline1 self, size_t bezier, size_t frame, float value, float time1, float value1,
float cx1, float cy1, float cx2, float cy2, float time2, float value2) {
CurveTimeline1 *_self = (CurveTimeline1 *) (ConstraintTimeline1 *) self;
_self->setBezier(bezier, frame, value, time1, value1, cx1, cy1, cx2, cy2, time2, value2);
}
float spine_constraint_timeline1_get_bezier_value(spine_constraint_timeline1 self, float time, size_t frame, size_t valueOffset, size_t i) {
return ((CurveTimeline1*)(ConstraintTimeline1*)self)->getBezierValue(time, frame, valueOffset, i);
CurveTimeline1 *_self = (CurveTimeline1 *) (ConstraintTimeline1 *) self;
return _self->getBezierValue(time, frame, valueOffset, i);
}
spine_array_float spine_constraint_timeline1_get_curves(spine_constraint_timeline1 self) {
return (spine_array_float)&((CurveTimeline1*)(ConstraintTimeline1*)self)->getCurves();
CurveTimeline1 *_self = (CurveTimeline1 *) (ConstraintTimeline1 *) self;
return (spine_array_float) &_self->getCurves();
}
void spine_constraint_timeline1_apply(spine_constraint_timeline1 self, spine_skeleton skeleton, float lastTime, float time, spine_array_event pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction, bool appliedPose) {
((CurveTimeline1*)(ConstraintTimeline1*)self)->apply(*((Skeleton*)skeleton), lastTime, time, (Array<Event *> *)pEvents, alpha, (MixBlend)blend, (MixDirection)direction, appliedPose);
void spine_constraint_timeline1_apply(spine_constraint_timeline1 self, spine_skeleton skeleton, float lastTime, float time, spine_array_event pEvents,
float alpha, spine_mix_blend blend, spine_mix_direction direction, bool appliedPose) {
CurveTimeline1 *_self = (CurveTimeline1 *) (ConstraintTimeline1 *) self;
_self->apply(*((Skeleton *) skeleton), lastTime, time, (Array<Event *> *) pEvents, alpha, (MixBlend) blend, (MixDirection) direction,
appliedPose);
}
size_t spine_constraint_timeline1_get_frame_entries(spine_constraint_timeline1 self) {
return ((CurveTimeline1*)(ConstraintTimeline1*)self)->getFrameEntries();
CurveTimeline1 *_self = (CurveTimeline1 *) (ConstraintTimeline1 *) self;
return _self->getFrameEntries();
}
size_t spine_constraint_timeline1_get_frame_count(spine_constraint_timeline1 self) {
return ((CurveTimeline1*)(ConstraintTimeline1*)self)->getFrameCount();
CurveTimeline1 *_self = (CurveTimeline1 *) (ConstraintTimeline1 *) self;
return _self->getFrameCount();
}
spine_array_float spine_constraint_timeline1_get_frames(spine_constraint_timeline1 self) {
return (spine_array_float)&((CurveTimeline1*)(ConstraintTimeline1*)self)->getFrames();
CurveTimeline1 *_self = (CurveTimeline1 *) (ConstraintTimeline1 *) self;
return (spine_array_float) &_self->getFrames();
}
float spine_constraint_timeline1_get_duration(spine_constraint_timeline1 self) {
return ((CurveTimeline1*)(ConstraintTimeline1*)self)->getDuration();
CurveTimeline1 *_self = (CurveTimeline1 *) (ConstraintTimeline1 *) self;
return _self->getDuration();
}
spine_array_property_id spine_constraint_timeline1_get_property_ids(spine_constraint_timeline1 self) {
return (spine_array_property_id)&((CurveTimeline1*)(ConstraintTimeline1*)self)->getPropertyIds();
CurveTimeline1 *_self = (CurveTimeline1 *) (ConstraintTimeline1 *) self;
return (spine_array_property_id) &_self->getPropertyIds();
}
int spine_constraint_timeline1_get_constraint_index(spine_constraint_timeline1 self) {
return ((ConstraintTimeline*)(ConstraintTimeline1*)self)->getConstraintIndex();
ConstraintTimeline *_self = (ConstraintTimeline *) (ConstraintTimeline1 *) self;
return _self->getConstraintIndex();
}
void spine_constraint_timeline1_set_constraint_index(spine_constraint_timeline1 self, int inValue) {
((ConstraintTimeline*)(ConstraintTimeline1*)self)->setConstraintIndex(inValue);
ConstraintTimeline *_self = (ConstraintTimeline *) (ConstraintTimeline1 *) self;
_self->setConstraintIndex(inValue);
}
spine_rtti spine_constraint_timeline1_rtti(void) {
return (spine_rtti)&ConstraintTimeline1::rtti;
return (spine_rtti) &ConstraintTimeline1::rtti;
}

22
spine-c/src/generated/constraint_timeline1.h
View File

@ -13,16 +13,24 @@ SPINE_C_API void spine_constraint_timeline1_dispose(spine_constraint_timeline1 s
SPINE_C_API spine_rtti spine_constraint_timeline1_get_rtti(spine_constraint_timeline1 self);
SPINE_C_API void spine_constraint_timeline1_set_frame(spine_constraint_timeline1 self, size_t frame, float time, float value);
SPINE_C_API float spine_constraint_timeline1_get_curve_value(spine_constraint_timeline1 self, float time);
SPINE_C_API float spine_constraint_timeline1_get_relative_value(spine_constraint_timeline1 self, float time, float alpha, spine_mix_blend blend, float current, float setup);
SPINE_C_API float spine_constraint_timeline1_get_absolute_value_1(spine_constraint_timeline1 self, float time, float alpha, spine_mix_blend blend, float current, float setup);
SPINE_C_API float spine_constraint_timeline1_get_absolute_value_2(spine_constraint_timeline1 self, float time, float alpha, spine_mix_blend blend, float current, float setup, float value);
SPINE_C_API float spine_constraint_timeline1_get_scale_value(spine_constraint_timeline1 self, float time, float alpha, spine_mix_blend blend, spine_mix_direction direction, float current, float setup);
SPINE_C_API float spine_constraint_timeline1_get_relative_value(spine_constraint_timeline1 self, float time, float alpha, spine_mix_blend blend,
float current, float setup);
SPINE_C_API float spine_constraint_timeline1_get_absolute_value_1(spine_constraint_timeline1 self, float time, float alpha, spine_mix_blend blend,
float current, float setup);
SPINE_C_API float spine_constraint_timeline1_get_absolute_value_2(spine_constraint_timeline1 self, float time, float alpha, spine_mix_blend blend,
float current, float setup, float value);
SPINE_C_API float spine_constraint_timeline1_get_scale_value(spine_constraint_timeline1 self, float time, float alpha, spine_mix_blend blend,
spine_mix_direction direction, float current, float setup);
SPINE_C_API void spine_constraint_timeline1_set_linear(spine_constraint_timeline1 self, size_t frame);
SPINE_C_API void spine_constraint_timeline1_set_stepped(spine_constraint_timeline1 self, size_t frame);
SPINE_C_API void spine_constraint_timeline1_set_bezier(spine_constraint_timeline1 self, size_t bezier, size_t frame, float value, float time1, float value1, float cx1, float cy1, float cx2, float cy2, float time2, float value2);
SPINE_C_API float spine_constraint_timeline1_get_bezier_value(spine_constraint_timeline1 self, float time, size_t frame, size_t valueOffset, size_t i);
SPINE_C_API void spine_constraint_timeline1_set_bezier(spine_constraint_timeline1 self, size_t bezier, size_t frame, float value, float time1,
float value1, float cx1, float cy1, float cx2, float cy2, float time2, float value2);
SPINE_C_API float spine_constraint_timeline1_get_bezier_value(spine_constraint_timeline1 self, float time, size_t frame, size_t valueOffset,
size_t i);
SPINE_C_API spine_array_float spine_constraint_timeline1_get_curves(spine_constraint_timeline1 self);
SPINE_C_API void spine_constraint_timeline1_apply(spine_constraint_timeline1 self, spine_skeleton skeleton, float lastTime, float time, spine_array_event pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction, bool appliedPose);
SPINE_C_API void spine_constraint_timeline1_apply(spine_constraint_timeline1 self, spine_skeleton skeleton, float lastTime, float time,
spine_array_event pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction,
bool appliedPose);
SPINE_C_API size_t spine_constraint_timeline1_get_frame_entries(spine_constraint_timeline1 self);
SPINE_C_API size_t spine_constraint_timeline1_get_frame_count(spine_constraint_timeline1 self);
SPINE_C_API spine_array_float spine_constraint_timeline1_get_frames(spine_constraint_timeline1 self);

47
spine-c/src/generated/curve_timeline.cpp
View File

@ -4,57 +4,72 @@
using namespace spine;
void spine_curve_timeline_dispose(spine_curve_timeline self) {
delete (CurveTimeline*)self;
delete (CurveTimeline *) self;
}
spine_rtti spine_curve_timeline_get_rtti(spine_curve_timeline self) {
return (spine_rtti)&((CurveTimeline*)self)->getRTTI();
CurveTimeline *_self = (CurveTimeline *) self;
return (spine_rtti) &_self->getRTTI();
}
void spine_curve_timeline_set_linear(spine_curve_timeline self, size_t frame) {
((CurveTimeline*)self)->setLinear(frame);
CurveTimeline *_self = (CurveTimeline *) self;
_self->setLinear(frame);
}
void spine_curve_timeline_set_stepped(spine_curve_timeline self, size_t frame) {
((CurveTimeline*)self)->setStepped(frame);
CurveTimeline *_self = (CurveTimeline *) self;
_self->setStepped(frame);
}
void spine_curve_timeline_set_bezier(spine_curve_timeline self, size_t bezier, size_t frame, float value, float time1, float value1, float cx1, float cy1, float cx2, float cy2, float time2, float value2) {
((CurveTimeline*)self)->setBezier(bezier, frame, value, time1, value1, cx1, cy1, cx2, cy2, time2, value2);
void spine_curve_timeline_set_bezier(spine_curve_timeline self, size_t bezier, size_t frame, float value, float time1, float value1, float cx1,
float cy1, float cx2, float cy2, float time2, float value2) {
CurveTimeline *_self = (CurveTimeline *) self;
_self->setBezier(bezier, frame, value, time1, value1, cx1, cy1, cx2, cy2, time2, value2);
}
float spine_curve_timeline_get_bezier_value(spine_curve_timeline self, float time, size_t frame, size_t valueOffset, size_t i) {
return ((CurveTimeline*)self)->getBezierValue(time, frame, valueOffset, i);
CurveTimeline *_self = (CurveTimeline *) self;
return _self->getBezierValue(time, frame, valueOffset, i);
}
spine_array_float spine_curve_timeline_get_curves(spine_curve_timeline self) {
return (spine_array_float)&((CurveTimeline*)self)->getCurves();
CurveTimeline *_self = (CurveTimeline *) self;
return (spine_array_float) &_self->getCurves();
}
void spine_curve_timeline_apply(spine_curve_timeline self, spine_skeleton skeleton, float lastTime, float time, spine_array_event pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction, bool appliedPose) {
((Timeline*)(CurveTimeline*)self)->apply(*((Skeleton*)skeleton), lastTime, time, (Array<Event *> *)pEvents, alpha, (MixBlend)blend, (MixDirection)direction, appliedPose);
void spine_curve_timeline_apply(spine_curve_timeline self, spine_skeleton skeleton, float lastTime, float time, spine_array_event pEvents,
float alpha, spine_mix_blend blend, spine_mix_direction direction, bool appliedPose) {
Timeline *_self = (Timeline *) (CurveTimeline *) self;
_self->apply(*((Skeleton *) skeleton), lastTime, time, (Array<Event *> *) pEvents, alpha, (MixBlend) blend, (MixDirection) direction,
appliedPose);
}
size_t spine_curve_timeline_get_frame_entries(spine_curve_timeline self) {
return ((Timeline*)(CurveTimeline*)self)->getFrameEntries();
Timeline *_self = (Timeline *) (CurveTimeline *) self;
return _self->getFrameEntries();
}
size_t spine_curve_timeline_get_frame_count(spine_curve_timeline self) {
return ((Timeline*)(CurveTimeline*)self)->getFrameCount();
Timeline *_self = (Timeline *) (CurveTimeline *) self;
return _self->getFrameCount();
}
spine_array_float spine_curve_timeline_get_frames(spine_curve_timeline self) {
return (spine_array_float)&((Timeline*)(CurveTimeline*)self)->getFrames();
Timeline *_self = (Timeline *) (CurveTimeline *) self;
return (spine_array_float) &_self->getFrames();
}
float spine_curve_timeline_get_duration(spine_curve_timeline self) {
return ((Timeline*)(CurveTimeline*)self)->getDuration();
Timeline *_self = (Timeline *) (CurveTimeline *) self;
return _self->getDuration();
}
spine_array_property_id spine_curve_timeline_get_property_ids(spine_curve_timeline self) {
return (spine_array_property_id)&((Timeline*)(CurveTimeline*)self)->getPropertyIds();
Timeline *_self = (Timeline *) (CurveTimeline *) self;
return (spine_array_property_id) &_self->getPropertyIds();
}
spine_rtti spine_curve_timeline_rtti(void) {
return (spine_rtti)&CurveTimeline::rtti;
return (spine_rtti) &CurveTimeline::rtti;
}

6
spine-c/src/generated/curve_timeline.h
View File

@ -13,10 +13,12 @@ SPINE_C_API void spine_curve_timeline_dispose(spine_curve_timeline self);
SPINE_C_API spine_rtti spine_curve_timeline_get_rtti(spine_curve_timeline self);
SPINE_C_API void spine_curve_timeline_set_linear(spine_curve_timeline self, size_t frame);
SPINE_C_API void spine_curve_timeline_set_stepped(spine_curve_timeline self, size_t frame);
SPINE_C_API void spine_curve_timeline_set_bezier(spine_curve_timeline self, size_t bezier, size_t frame, float value, float time1, float value1, float cx1, float cy1, float cx2, float cy2, float time2, float value2);
SPINE_C_API void spine_curve_timeline_set_bezier(spine_curve_timeline self, size_t bezier, size_t frame, float value, float time1, float value1,
float cx1, float cy1, float cx2, float cy2, float time2, float value2);
SPINE_C_API float spine_curve_timeline_get_bezier_value(spine_curve_timeline self, float time, size_t frame, size_t valueOffset, size_t i);
SPINE_C_API spine_array_float spine_curve_timeline_get_curves(spine_curve_timeline self);
SPINE_C_API void spine_curve_timeline_apply(spine_curve_timeline self, spine_skeleton skeleton, float lastTime, float time, spine_array_event pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction, bool appliedPose);
SPINE_C_API void spine_curve_timeline_apply(spine_curve_timeline self, spine_skeleton skeleton, float lastTime, float time, spine_array_event pEvents,
float alpha, spine_mix_blend blend, spine_mix_direction direction, bool appliedPose);
SPINE_C_API size_t spine_curve_timeline_get_frame_entries(spine_curve_timeline self);
SPINE_C_API size_t spine_curve_timeline_get_frame_count(spine_curve_timeline self);
SPINE_C_API spine_array_float spine_curve_timeline_get_frames(spine_curve_timeline self);

77
spine-c/src/generated/curve_timeline1.cpp
View File

@ -4,81 +4,106 @@
using namespace spine;
void spine_curve_timeline1_dispose(spine_curve_timeline1 self) {
delete (CurveTimeline1*)self;
delete (CurveTimeline1 *) self;
}
spine_rtti spine_curve_timeline1_get_rtti(spine_curve_timeline1 self) {
return (spine_rtti)&((CurveTimeline1*)self)->getRTTI();
CurveTimeline1 *_self = (CurveTimeline1 *) self;
return (spine_rtti) &_self->getRTTI();
}
void spine_curve_timeline1_set_frame(spine_curve_timeline1 self, size_t frame, float time, float value) {
((CurveTimeline1*)self)->setFrame(frame, time, value);
CurveTimeline1 *_self = (CurveTimeline1 *) self;
_self->setFrame(frame, time, value);
}
float spine_curve_timeline1_get_curve_value(spine_curve_timeline1 self, float time) {
return ((CurveTimeline1*)self)->getCurveValue(time);
CurveTimeline1 *_self = (CurveTimeline1 *) self;
return _self->getCurveValue(time);
}
float spine_curve_timeline1_get_relative_value(spine_curve_timeline1 self, float time, float alpha, spine_mix_blend blend, float current, float setup) {
return ((CurveTimeline1*)self)->getRelativeValue(time, alpha, (MixBlend)blend, current, setup);
float spine_curve_timeline1_get_relative_value(spine_curve_timeline1 self, float time, float alpha, spine_mix_blend blend, float current,
float setup) {
CurveTimeline1 *_self = (CurveTimeline1 *) self;
return _self->getRelativeValue(time, alpha, (MixBlend) blend, current, setup);
}
float spine_curve_timeline1_get_absolute_value_1(spine_curve_timeline1 self, float time, float alpha, spine_mix_blend blend, float current, float setup) {
return ((CurveTimeline1*)self)->getAbsoluteValue(time, alpha, (MixBlend)blend, current, setup);
float spine_curve_timeline1_get_absolute_value_1(spine_curve_timeline1 self, float time, float alpha, spine_mix_blend blend, float current,
float setup) {
CurveTimeline1 *_self = (CurveTimeline1 *) self;
return _self->getAbsoluteValue(time, alpha, (MixBlend) blend, current, setup);
}
float spine_curve_timeline1_get_absolute_value_2(spine_curve_timeline1 self, float time, float alpha, spine_mix_blend blend, float current, float setup, float value) {
return ((CurveTimeline1*)self)->getAbsoluteValue(time, alpha, (MixBlend)blend, current, setup, value);
float spine_curve_timeline1_get_absolute_value_2(spine_curve_timeline1 self, float time, float alpha, spine_mix_blend blend, float current,
float setup, float value) {
CurveTimeline1 *_self = (CurveTimeline1 *) self;
return _self->getAbsoluteValue(time, alpha, (MixBlend) blend, current, setup, value);
}
float spine_curve_timeline1_get_scale_value(spine_curve_timeline1 self, float time, float alpha, spine_mix_blend blend, spine_mix_direction direction, float current, float setup) {
return ((CurveTimeline1*)self)->getScaleValue(time, alpha, (MixBlend)blend, (MixDirection)direction, current, setup);
float spine_curve_timeline1_get_scale_value(spine_curve_timeline1 self, float time, float alpha, spine_mix_blend blend, spine_mix_direction direction,
float current, float setup) {
CurveTimeline1 *_self = (CurveTimeline1 *) self;
return _self->getScaleValue(time, alpha, (MixBlend) blend, (MixDirection) direction, current, setup);
}
void spine_curve_timeline1_set_linear(spine_curve_timeline1 self, size_t frame) {
((CurveTimeline*)(CurveTimeline1*)self)->setLinear(frame);
CurveTimeline *_self = (CurveTimeline *) (CurveTimeline1 *) self;
_self->setLinear(frame);
}
void spine_curve_timeline1_set_stepped(spine_curve_timeline1 self, size_t frame) {
((CurveTimeline*)(CurveTimeline1*)self)->setStepped(frame);
CurveTimeline *_self = (CurveTimeline *) (CurveTimeline1 *) self;
_self->setStepped(frame);
}
void spine_curve_timeline1_set_bezier(spine_curve_timeline1 self, size_t bezier, size_t frame, float value, float time1, float value1, float cx1, float cy1, float cx2, float cy2, float time2, float value2) {
((CurveTimeline*)(CurveTimeline1*)self)->setBezier(bezier, frame, value, time1, value1, cx1, cy1, cx2, cy2, time2, value2);
void spine_curve_timeline1_set_bezier(spine_curve_timeline1 self, size_t bezier, size_t frame, float value, float time1, float value1, float cx1,
float cy1, float cx2, float cy2, float time2, float value2) {
CurveTimeline *_self = (CurveTimeline *) (CurveTimeline1 *) self;
_self->setBezier(bezier, frame, value, time1, value1, cx1, cy1, cx2, cy2, time2, value2);
}
float spine_curve_timeline1_get_bezier_value(spine_curve_timeline1 self, float time, size_t frame, size_t valueOffset, size_t i) {
return ((CurveTimeline*)(CurveTimeline1*)self)->getBezierValue(time, frame, valueOffset, i);
CurveTimeline *_self = (CurveTimeline *) (CurveTimeline1 *) self;
return _self->getBezierValue(time, frame, valueOffset, i);
}
spine_array_float spine_curve_timeline1_get_curves(spine_curve_timeline1 self) {
return (spine_array_float)&((CurveTimeline*)(CurveTimeline1*)self)->getCurves();
CurveTimeline *_self = (CurveTimeline *) (CurveTimeline1 *) self;
return (spine_array_float) &_self->getCurves();
}
void spine_curve_timeline1_apply(spine_curve_timeline1 self, spine_skeleton skeleton, float lastTime, float time, spine_array_event pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction, bool appliedPose) {
((CurveTimeline*)(CurveTimeline1*)self)->apply(*((Skeleton*)skeleton), lastTime, time, (Array<Event *> *)pEvents, alpha, (MixBlend)blend, (MixDirection)direction, appliedPose);
void spine_curve_timeline1_apply(spine_curve_timeline1 self, spine_skeleton skeleton, float lastTime, float time, spine_array_event pEvents,
float alpha, spine_mix_blend blend, spine_mix_direction direction, bool appliedPose) {
CurveTimeline *_self = (CurveTimeline *) (CurveTimeline1 *) self;
_self->apply(*((Skeleton *) skeleton), lastTime, time, (Array<Event *> *) pEvents, alpha, (MixBlend) blend, (MixDirection) direction,
appliedPose);
}
size_t spine_curve_timeline1_get_frame_entries(spine_curve_timeline1 self) {
return ((CurveTimeline*)(CurveTimeline1*)self)->getFrameEntries();
CurveTimeline *_self = (CurveTimeline *) (CurveTimeline1 *) self;
return _self->getFrameEntries();
}
size_t spine_curve_timeline1_get_frame_count(spine_curve_timeline1 self) {
return ((CurveTimeline*)(CurveTimeline1*)self)->getFrameCount();
CurveTimeline *_self = (CurveTimeline *) (CurveTimeline1 *) self;
return _self->getFrameCount();
}
spine_array_float spine_curve_timeline1_get_frames(spine_curve_timeline1 self) {
return (spine_array_float)&((CurveTimeline*)(CurveTimeline1*)self)->getFrames();
CurveTimeline *_self = (CurveTimeline *) (CurveTimeline1 *) self;
return (spine_array_float) &_self->getFrames();
}
float spine_curve_timeline1_get_duration(spine_curve_timeline1 self) {
return ((CurveTimeline*)(CurveTimeline1*)self)->getDuration();
CurveTimeline *_self = (CurveTimeline *) (CurveTimeline1 *) self;
return _self->getDuration();
}
spine_array_property_id spine_curve_timeline1_get_property_ids(spine_curve_timeline1 self) {
return (spine_array_property_id)&((CurveTimeline*)(CurveTimeline1*)self)->getPropertyIds();
CurveTimeline *_self = (CurveTimeline *) (CurveTimeline1 *) self;
return (spine_array_property_id) &_self->getPropertyIds();
}
spine_rtti spine_curve_timeline1_rtti(void) {
return (spine_rtti)&CurveTimeline1::rtti;
return (spine_rtti) &CurveTimeline1::rtti;
}

19
spine-c/src/generated/curve_timeline1.h
View File

@ -13,16 +13,23 @@ SPINE_C_API void spine_curve_timeline1_dispose(spine_curve_timeline1 self);
SPINE_C_API spine_rtti spine_curve_timeline1_get_rtti(spine_curve_timeline1 self);
SPINE_C_API void spine_curve_timeline1_set_frame(spine_curve_timeline1 self, size_t frame, float time, float value);
SPINE_C_API float spine_curve_timeline1_get_curve_value(spine_curve_timeline1 self, float time);
SPINE_C_API float spine_curve_timeline1_get_relative_value(spine_curve_timeline1 self, float time, float alpha, spine_mix_blend blend, float current, float setup);
SPINE_C_API float spine_curve_timeline1_get_absolute_value_1(spine_curve_timeline1 self, float time, float alpha, spine_mix_blend blend, float current, float setup);
SPINE_C_API float spine_curve_timeline1_get_absolute_value_2(spine_curve_timeline1 self, float time, float alpha, spine_mix_blend blend, float current, float setup, float value);
SPINE_C_API float spine_curve_timeline1_get_scale_value(spine_curve_timeline1 self, float time, float alpha, spine_mix_blend blend, spine_mix_direction direction, float current, float setup);
SPINE_C_API float spine_curve_timeline1_get_relative_value(spine_curve_timeline1 self, float time, float alpha, spine_mix_blend blend, float current,
float setup);
SPINE_C_API float spine_curve_timeline1_get_absolute_value_1(spine_curve_timeline1 self, float time, float alpha, spine_mix_blend blend,
float current, float setup);
SPINE_C_API float spine_curve_timeline1_get_absolute_value_2(spine_curve_timeline1 self, float time, float alpha, spine_mix_blend blend,
float current, float setup, float value);
SPINE_C_API float spine_curve_timeline1_get_scale_value(spine_curve_timeline1 self, float time, float alpha, spine_mix_blend blend,
spine_mix_direction direction, float current, float setup);
SPINE_C_API void spine_curve_timeline1_set_linear(spine_curve_timeline1 self, size_t frame);
SPINE_C_API void spine_curve_timeline1_set_stepped(spine_curve_timeline1 self, size_t frame);
SPINE_C_API void spine_curve_timeline1_set_bezier(spine_curve_timeline1 self, size_t bezier, size_t frame, float value, float time1, float value1, float cx1, float cy1, float cx2, float cy2, float time2, float value2);
SPINE_C_API void spine_curve_timeline1_set_bezier(spine_curve_timeline1 self, size_t bezier, size_t frame, float value, float time1, float value1,
float cx1, float cy1, float cx2, float cy2, float time2, float value2);
SPINE_C_API float spine_curve_timeline1_get_bezier_value(spine_curve_timeline1 self, float time, size_t frame, size_t valueOffset, size_t i);
SPINE_C_API spine_array_float spine_curve_timeline1_get_curves(spine_curve_timeline1 self);
SPINE_C_API void spine_curve_timeline1_apply(spine_curve_timeline1 self, spine_skeleton skeleton, float lastTime, float time, spine_array_event pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction, bool appliedPose);
SPINE_C_API void spine_curve_timeline1_apply(spine_curve_timeline1 self, spine_skeleton skeleton, float lastTime, float time,
spine_array_event pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction,
bool appliedPose);
SPINE_C_API size_t spine_curve_timeline1_get_frame_entries(spine_curve_timeline1 self);
SPINE_C_API size_t spine_curve_timeline1_get_frame_count(spine_curve_timeline1 self);
SPINE_C_API spine_array_float spine_curve_timeline1_get_frames(spine_curve_timeline1 self);

53
spine-c/src/generated/curve_timeline2.cpp
View File

@ -4,65 +4,82 @@
using namespace spine;
void spine_curve_timeline2_dispose(spine_curve_timeline2 self) {
delete (CurveTimeline2*)self;
delete (CurveTimeline2 *) self;
}
spine_rtti spine_curve_timeline2_get_rtti(spine_curve_timeline2 self) {
return (spine_rtti)&((CurveTimeline2*)self)->getRTTI();
CurveTimeline2 *_self = (CurveTimeline2 *) self;
return (spine_rtti) &_self->getRTTI();
}
void spine_curve_timeline2_set_frame(spine_curve_timeline2 self, size_t frame, float time, float value1, float value2) {
((CurveTimeline2*)self)->setFrame(frame, time, value1, value2);
CurveTimeline2 *_self = (CurveTimeline2 *) self;
_self->setFrame(frame, time, value1, value2);
}
float spine_curve_timeline2_get_curve_value(spine_curve_timeline2 self, float time) {
return ((CurveTimeline2*)self)->getCurveValue(time);
CurveTimeline2 *_self = (CurveTimeline2 *) self;
return _self->getCurveValue(time);
}
void spine_curve_timeline2_set_linear(spine_curve_timeline2 self, size_t frame) {
((CurveTimeline*)(CurveTimeline2*)self)->setLinear(frame);
CurveTimeline *_self = (CurveTimeline *) (CurveTimeline2 *) self;
_self->setLinear(frame);
}
void spine_curve_timeline2_set_stepped(spine_curve_timeline2 self, size_t frame) {
((CurveTimeline*)(CurveTimeline2*)self)->setStepped(frame);
CurveTimeline *_self = (CurveTimeline *) (CurveTimeline2 *) self;
_self->setStepped(frame);
}
void spine_curve_timeline2_set_bezier(spine_curve_timeline2 self, size_t bezier, size_t frame, float value, float time1, float value1, float cx1, float cy1, float cx2, float cy2, float time2, float value2) {
((CurveTimeline*)(CurveTimeline2*)self)->setBezier(bezier, frame, value, time1, value1, cx1, cy1, cx2, cy2, time2, value2);
void spine_curve_timeline2_set_bezier(spine_curve_timeline2 self, size_t bezier, size_t frame, float value, float time1, float value1, float cx1,
float cy1, float cx2, float cy2, float time2, float value2) {
CurveTimeline *_self = (CurveTimeline *) (CurveTimeline2 *) self;
_self->setBezier(bezier, frame, value, time1, value1, cx1, cy1, cx2, cy2, time2, value2);
}
float spine_curve_timeline2_get_bezier_value(spine_curve_timeline2 self, float time, size_t frame, size_t valueOffset, size_t i) {
return ((CurveTimeline*)(CurveTimeline2*)self)->getBezierValue(time, frame, valueOffset, i);
CurveTimeline *_self = (CurveTimeline *) (CurveTimeline2 *) self;
return _self->getBezierValue(time, frame, valueOffset, i);
}
spine_array_float spine_curve_timeline2_get_curves(spine_curve_timeline2 self) {
return (spine_array_float)&((CurveTimeline*)(CurveTimeline2*)self)->getCurves();
CurveTimeline *_self = (CurveTimeline *) (CurveTimeline2 *) self;
return (spine_array_float) &_self->getCurves();
}
void spine_curve_timeline2_apply(spine_curve_timeline2 self, spine_skeleton skeleton, float lastTime, float time, spine_array_event pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction, bool appliedPose) {
((CurveTimeline*)(CurveTimeline2*)self)->apply(*((Skeleton*)skeleton), lastTime, time, (Array<Event *> *)pEvents, alpha, (MixBlend)blend, (MixDirection)direction, appliedPose);
void spine_curve_timeline2_apply(spine_curve_timeline2 self, spine_skeleton skeleton, float lastTime, float time, spine_array_event pEvents,
float alpha, spine_mix_blend blend, spine_mix_direction direction, bool appliedPose) {
CurveTimeline *_self = (CurveTimeline *) (CurveTimeline2 *) self;
_self->apply(*((Skeleton *) skeleton), lastTime, time, (Array<Event *> *) pEvents, alpha, (MixBlend) blend, (MixDirection) direction,
appliedPose);
}
size_t spine_curve_timeline2_get_frame_entries(spine_curve_timeline2 self) {
return ((CurveTimeline*)(CurveTimeline2*)self)->getFrameEntries();
CurveTimeline *_self = (CurveTimeline *) (CurveTimeline2 *) self;
return _self->getFrameEntries();
}
size_t spine_curve_timeline2_get_frame_count(spine_curve_timeline2 self) {
return ((CurveTimeline*)(CurveTimeline2*)self)->getFrameCount();
CurveTimeline *_self = (CurveTimeline *) (CurveTimeline2 *) self;
return _self->getFrameCount();
}
spine_array_float spine_curve_timeline2_get_frames(spine_curve_timeline2 self) {
return (spine_array_float)&((CurveTimeline*)(CurveTimeline2*)self)->getFrames();
CurveTimeline *_self = (CurveTimeline *) (CurveTimeline2 *) self;
return (spine_array_float) &_self->getFrames();
}
float spine_curve_timeline2_get_duration(spine_curve_timeline2 self) {
return ((CurveTimeline*)(CurveTimeline2*)self)->getDuration();
CurveTimeline *_self = (CurveTimeline *) (CurveTimeline2 *) self;
return _self->getDuration();
}
spine_array_property_id spine_curve_timeline2_get_property_ids(spine_curve_timeline2 self) {
return (spine_array_property_id)&((CurveTimeline*)(CurveTimeline2*)self)->getPropertyIds();
CurveTimeline *_self = (CurveTimeline *) (CurveTimeline2 *) self;
return (spine_array_property_id) &_self->getPropertyIds();
}
spine_rtti spine_curve_timeline2_rtti(void) {
return (spine_rtti)&CurveTimeline2::rtti;
return (spine_rtti) &CurveTimeline2::rtti;
}

7
spine-c/src/generated/curve_timeline2.h
View File

@ -15,10 +15,13 @@ SPINE_C_API void spine_curve_timeline2_set_frame(spine_curve_timeline2 self, siz
SPINE_C_API float spine_curve_timeline2_get_curve_value(spine_curve_timeline2 self, float time);
SPINE_C_API void spine_curve_timeline2_set_linear(spine_curve_timeline2 self, size_t frame);
SPINE_C_API void spine_curve_timeline2_set_stepped(spine_curve_timeline2 self, size_t frame);
SPINE_C_API void spine_curve_timeline2_set_bezier(spine_curve_timeline2 self, size_t bezier, size_t frame, float value, float time1, float value1, float cx1, float cy1, float cx2, float cy2, float time2, float value2);
SPINE_C_API void spine_curve_timeline2_set_bezier(spine_curve_timeline2 self, size_t bezier, size_t frame, float value, float time1, float value1,
float cx1, float cy1, float cx2, float cy2, float time2, float value2);
SPINE_C_API float spine_curve_timeline2_get_bezier_value(spine_curve_timeline2 self, float time, size_t frame, size_t valueOffset, size_t i);
SPINE_C_API spine_array_float spine_curve_timeline2_get_curves(spine_curve_timeline2 self);
SPINE_C_API void spine_curve_timeline2_apply(spine_curve_timeline2 self, spine_skeleton skeleton, float lastTime, float time, spine_array_event pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction, bool appliedPose);
SPINE_C_API void spine_curve_timeline2_apply(spine_curve_timeline2 self, spine_skeleton skeleton, float lastTime, float time,
spine_array_event pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction,
bool appliedPose);
SPINE_C_API size_t spine_curve_timeline2_get_frame_entries(spine_curve_timeline2 self);
SPINE_C_API size_t spine_curve_timeline2_get_frame_count(spine_curve_timeline2 self);
SPINE_C_API spine_array_float spine_curve_timeline2_get_frames(spine_curve_timeline2 self);

67
spine-c/src/generated/deform_timeline.cpp
View File

@ -4,85 +4,106 @@
using namespace spine;
spine_deform_timeline spine_deform_timeline_create(size_t frameCount, size_t bezierCount, int slotIndex, spine_vertex_attachment attachment) {
return (spine_deform_timeline) new (__FILE__, __LINE__) DeformTimeline(frameCount, bezierCount, slotIndex, (VertexAttachment *)attachment);
return (spine_deform_timeline) new (__FILE__, __LINE__) DeformTimeline(frameCount, bezierCount, slotIndex, (VertexAttachment *) attachment);
}
void spine_deform_timeline_dispose(spine_deform_timeline self) {
delete (DeformTimeline*)self;
delete (DeformTimeline *) self;
}
spine_rtti spine_deform_timeline_get_rtti(spine_deform_timeline self) {
return (spine_rtti)&((DeformTimeline*)self)->getRTTI();
DeformTimeline *_self = (DeformTimeline *) self;
return (spine_rtti) &_self->getRTTI();
}
void spine_deform_timeline_set_frame(spine_deform_timeline self, int frameIndex, float time, spine_array_float vertices) {
((DeformTimeline*)self)->setFrame(frameIndex, time, *((Array<float>*)vertices));
DeformTimeline *_self = (DeformTimeline *) self;
_self->setFrame(frameIndex, time, *((Array<float> *) vertices));
}
spine_vertex_attachment spine_deform_timeline_get_attachment(spine_deform_timeline self) {
return (spine_vertex_attachment)((DeformTimeline*)self)->getAttachment();
DeformTimeline *_self = (DeformTimeline *) self;
return (spine_vertex_attachment) _self->getAttachment();
}
void spine_deform_timeline_set_attachment(spine_deform_timeline self, spine_vertex_attachment inValue) {
((DeformTimeline*)self)->setAttachment((VertexAttachment *)inValue);
DeformTimeline *_self = (DeformTimeline *) self;
_self->setAttachment((VertexAttachment *) inValue);
}
void spine_deform_timeline_set_bezier(spine_deform_timeline self, size_t bezier, size_t frame, float value, float time1, float value1, float cx1, float cy1, float cx2, float cy2, float time2, float value2) {
((DeformTimeline*)self)->setBezier(bezier, frame, value, time1, value1, cx1, cy1, cx2, cy2, time2, value2);
void spine_deform_timeline_set_bezier(spine_deform_timeline self, size_t bezier, size_t frame, float value, float time1, float value1, float cx1,
float cy1, float cx2, float cy2, float time2, float value2) {
DeformTimeline *_self = (DeformTimeline *) self;
_self->setBezier(bezier, frame, value, time1, value1, cx1, cy1, cx2, cy2, time2, value2);
}
float spine_deform_timeline_get_curve_percent(spine_deform_timeline self, float time, int frame) {
return ((DeformTimeline*)self)->getCurvePercent(time, frame);
DeformTimeline *_self = (DeformTimeline *) self;
return _self->getCurvePercent(time, frame);
}
size_t spine_deform_timeline_get_frame_count(spine_deform_timeline self) {
return ((DeformTimeline*)self)->getFrameCount();
DeformTimeline *_self = (DeformTimeline *) self;
return _self->getFrameCount();
}
void spine_deform_timeline_apply(spine_deform_timeline self, spine_skeleton skeleton, float lastTime, float time, spine_array_event pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction, bool appliedPose) {
((SlotCurveTimeline*)(DeformTimeline*)self)->apply(*((Skeleton*)skeleton), lastTime, time, (Array<Event *> *)pEvents, alpha, (MixBlend)blend, (MixDirection)direction, appliedPose);
void spine_deform_timeline_apply(spine_deform_timeline self, spine_skeleton skeleton, float lastTime, float time, spine_array_event pEvents,
float alpha, spine_mix_blend blend, spine_mix_direction direction, bool appliedPose) {
SlotCurveTimeline *_self = (SlotCurveTimeline *) (DeformTimeline *) self;
_self->apply(*((Skeleton *) skeleton), lastTime, time, (Array<Event *> *) pEvents, alpha, (MixBlend) blend, (MixDirection) direction,
appliedPose);
}
void spine_deform_timeline_set_linear(spine_deform_timeline self, size_t frame) {
((SlotCurveTimeline*)(DeformTimeline*)self)->setLinear(frame);
SlotCurveTimeline *_self = (SlotCurveTimeline *) (DeformTimeline *) self;
_self->setLinear(frame);
}
void spine_deform_timeline_set_stepped(spine_deform_timeline self, size_t frame) {
((SlotCurveTimeline*)(DeformTimeline*)self)->setStepped(frame);
SlotCurveTimeline *_self = (SlotCurveTimeline *) (DeformTimeline *) self;
_self->setStepped(frame);
}
float spine_deform_timeline_get_bezier_value(spine_deform_timeline self, float time, size_t frame, size_t valueOffset, size_t i) {
return ((SlotCurveTimeline*)(DeformTimeline*)self)->getBezierValue(time, frame, valueOffset, i);
SlotCurveTimeline *_self = (SlotCurveTimeline *) (DeformTimeline *) self;
return _self->getBezierValue(time, frame, valueOffset, i);
}
spine_array_float spine_deform_timeline_get_curves(spine_deform_timeline self) {
return (spine_array_float)&((SlotCurveTimeline*)(DeformTimeline*)self)->getCurves();
SlotCurveTimeline *_self = (SlotCurveTimeline *) (DeformTimeline *) self;
return (spine_array_float) &_self->getCurves();
}
size_t spine_deform_timeline_get_frame_entries(spine_deform_timeline self) {
return ((SlotCurveTimeline*)(DeformTimeline*)self)->getFrameEntries();
SlotCurveTimeline *_self = (SlotCurveTimeline *) (DeformTimeline *) self;
return _self->getFrameEntries();
}
spine_array_float spine_deform_timeline_get_frames(spine_deform_timeline self) {
return (spine_array_float)&((SlotCurveTimeline*)(DeformTimeline*)self)->getFrames();
SlotCurveTimeline *_self = (SlotCurveTimeline *) (DeformTimeline *) self;
return (spine_array_float) &_self->getFrames();
}
float spine_deform_timeline_get_duration(spine_deform_timeline self) {
return ((SlotCurveTimeline*)(DeformTimeline*)self)->getDuration();
SlotCurveTimeline *_self = (SlotCurveTimeline *) (DeformTimeline *) self;
return _self->getDuration();
}
spine_array_property_id spine_deform_timeline_get_property_ids(spine_deform_timeline self) {
return (spine_array_property_id)&((SlotCurveTimeline*)(DeformTimeline*)self)->getPropertyIds();
SlotCurveTimeline *_self = (SlotCurveTimeline *) (DeformTimeline *) self;
return (spine_array_property_id) &_self->getPropertyIds();
}
int spine_deform_timeline_get_slot_index(spine_deform_timeline self) {
return ((SlotCurveTimeline*)(DeformTimeline*)self)->getSlotIndex();
SlotCurveTimeline *_self = (SlotCurveTimeline *) (DeformTimeline *) self;
return _self->getSlotIndex();
}
void spine_deform_timeline_set_slot_index(spine_deform_timeline self, int inValue) {
((SlotCurveTimeline*)(DeformTimeline*)self)->setSlotIndex(inValue);
SlotCurveTimeline *_self = (SlotCurveTimeline *) (DeformTimeline *) self;
_self->setSlotIndex(inValue);
}
spine_rtti spine_deform_timeline_rtti(void) {
return (spine_rtti)&DeformTimeline::rtti;
return (spine_rtti) &DeformTimeline::rtti;
}

10
spine-c/src/generated/deform_timeline.h
View File

@ -8,7 +8,8 @@
extern "C" {
#endif
SPINE_C_API spine_deform_timeline spine_deform_timeline_create(size_t frameCount, size_t bezierCount, int slotIndex, spine_vertex_attachment attachment);
SPINE_C_API spine_deform_timeline spine_deform_timeline_create(size_t frameCount, size_t bezierCount, int slotIndex,
spine_vertex_attachment attachment);
SPINE_C_API void spine_deform_timeline_dispose(spine_deform_timeline self);
@ -16,10 +17,13 @@ SPINE_C_API spine_rtti spine_deform_timeline_get_rtti(spine_deform_timeline self
SPINE_C_API void spine_deform_timeline_set_frame(spine_deform_timeline self, int frameIndex, float time, spine_array_float vertices);
SPINE_C_API spine_vertex_attachment spine_deform_timeline_get_attachment(spine_deform_timeline self);
SPINE_C_API void spine_deform_timeline_set_attachment(spine_deform_timeline self, spine_vertex_attachment inValue);
SPINE_C_API void spine_deform_timeline_set_bezier(spine_deform_timeline self, size_t bezier, size_t frame, float value, float time1, float value1, float cx1, float cy1, float cx2, float cy2, float time2, float value2);
SPINE_C_API void spine_deform_timeline_set_bezier(spine_deform_timeline self, size_t bezier, size_t frame, float value, float time1, float value1,
float cx1, float cy1, float cx2, float cy2, float time2, float value2);
SPINE_C_API float spine_deform_timeline_get_curve_percent(spine_deform_timeline self, float time, int frame);
SPINE_C_API size_t spine_deform_timeline_get_frame_count(spine_deform_timeline self);
SPINE_C_API void spine_deform_timeline_apply(spine_deform_timeline self, spine_skeleton skeleton, float lastTime, float time, spine_array_event pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction, bool appliedPose);
SPINE_C_API void spine_deform_timeline_apply(spine_deform_timeline self, spine_skeleton skeleton, float lastTime, float time,
spine_array_event pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction,
bool appliedPose);
SPINE_C_API void spine_deform_timeline_set_linear(spine_deform_timeline self, size_t frame);
SPINE_C_API void spine_deform_timeline_set_stepped(spine_deform_timeline self, size_t frame);
SPINE_C_API float spine_deform_timeline_get_bezier_value(spine_deform_timeline self, float time, size_t frame, size_t valueOffset, size_t i);

34
spine-c/src/generated/draw_order_timeline.cpp
View File

@ -4,45 +4,55 @@
using namespace spine;
spine_draw_order_timeline spine_draw_order_timeline_create(size_t frameCount) {
return (spine_draw_order_timeline) new (__FILE__, __LINE__) DrawOrderTimeline(frameCount);
return (spine_draw_order_timeline) new (__FILE__, __LINE__) DrawOrderTimeline(frameCount);
}
void spine_draw_order_timeline_dispose(spine_draw_order_timeline self) {
delete (DrawOrderTimeline*)self;
delete (DrawOrderTimeline *) self;
}
spine_rtti spine_draw_order_timeline_get_rtti(spine_draw_order_timeline self) {
return (spine_rtti)&((DrawOrderTimeline*)self)->getRTTI();
DrawOrderTimeline *_self = (DrawOrderTimeline *) self;
return (spine_rtti) &_self->getRTTI();
}
void spine_draw_order_timeline_apply(spine_draw_order_timeline self, spine_skeleton skeleton, float lastTime, float time, spine_array_event pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction, bool appliedPose) {
((DrawOrderTimeline*)self)->apply(*((Skeleton*)skeleton), lastTime, time, (Array<Event *> *)pEvents, alpha, (MixBlend)blend, (MixDirection)direction, appliedPose);
void spine_draw_order_timeline_apply(spine_draw_order_timeline self, spine_skeleton skeleton, float lastTime, float time, spine_array_event pEvents,
float alpha, spine_mix_blend blend, spine_mix_direction direction, bool appliedPose) {
DrawOrderTimeline *_self = (DrawOrderTimeline *) self;
_self->apply(*((Skeleton *) skeleton), lastTime, time, (Array<Event *> *) pEvents, alpha, (MixBlend) blend, (MixDirection) direction,
appliedPose);
}
size_t spine_draw_order_timeline_get_frame_count(spine_draw_order_timeline self) {
return ((DrawOrderTimeline*)self)->getFrameCount();
DrawOrderTimeline *_self = (DrawOrderTimeline *) self;
return _self->getFrameCount();
}
void spine_draw_order_timeline_set_frame(spine_draw_order_timeline self, size_t frame, float time, spine_array_int drawOrder) {
((DrawOrderTimeline*)self)->setFrame(frame, time, (Array<int> *)drawOrder);
DrawOrderTimeline *_self = (DrawOrderTimeline *) self;
_self->setFrame(frame, time, (Array<int> *) drawOrder);
}
size_t spine_draw_order_timeline_get_frame_entries(spine_draw_order_timeline self) {
return ((Timeline*)(DrawOrderTimeline*)self)->getFrameEntries();
Timeline *_self = (Timeline *) (DrawOrderTimeline *) self;
return _self->getFrameEntries();
}
spine_array_float spine_draw_order_timeline_get_frames(spine_draw_order_timeline self) {
return (spine_array_float)&((Timeline*)(DrawOrderTimeline*)self)->getFrames();
Timeline *_self = (Timeline *) (DrawOrderTimeline *) self;
return (spine_array_float) &_self->getFrames();
}
float spine_draw_order_timeline_get_duration(spine_draw_order_timeline self) {
return ((Timeline*)(DrawOrderTimeline*)self)->getDuration();
Timeline *_self = (Timeline *) (DrawOrderTimeline *) self;
return _self->getDuration();
}
spine_array_property_id spine_draw_order_timeline_get_property_ids(spine_draw_order_timeline self) {
return (spine_array_property_id)&((Timeline*)(DrawOrderTimeline*)self)->getPropertyIds();
Timeline *_self = (Timeline *) (DrawOrderTimeline *) self;
return (spine_array_property_id) &_self->getPropertyIds();
}
spine_rtti spine_draw_order_timeline_rtti(void) {
return (spine_rtti)&DrawOrderTimeline::rtti;
return (spine_rtti) &DrawOrderTimeline::rtti;
}

4
spine-c/src/generated/draw_order_timeline.h
View File

@ -13,7 +13,9 @@ SPINE_C_API spine_draw_order_timeline spine_draw_order_timeline_create(size_t fr
SPINE_C_API void spine_draw_order_timeline_dispose(spine_draw_order_timeline self);
SPINE_C_API spine_rtti spine_draw_order_timeline_get_rtti(spine_draw_order_timeline self);
SPINE_C_API void spine_draw_order_timeline_apply(spine_draw_order_timeline self, spine_skeleton skeleton, float lastTime, float time, spine_array_event pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction, bool appliedPose);
SPINE_C_API void spine_draw_order_timeline_apply(spine_draw_order_timeline self, spine_skeleton skeleton, float lastTime, float time,
spine_array_event pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction,
bool appliedPose);
SPINE_C_API size_t spine_draw_order_timeline_get_frame_count(spine_draw_order_timeline self);
SPINE_C_API void spine_draw_order_timeline_set_frame(spine_draw_order_timeline self, size_t frame, float time, spine_array_int drawOrder);
SPINE_C_API size_t spine_draw_order_timeline_get_frame_entries(spine_draw_order_timeline self);

44
spine-c/src/generated/event.cpp
View File

@ -4,57 +4,69 @@
using namespace spine;
spine_event spine_event_create(float time, spine_event_data data) {
return (spine_event) new (__FILE__, __LINE__) Event(time, *((const EventData*)data));
return (spine_event) new (__FILE__, __LINE__) Event(time, *((const EventData *) data));
}
void spine_event_dispose(spine_event self) {
delete (Event*)self;
delete (Event *) self;
}
spine_event_data spine_event_get_data(spine_event self) {
return (spine_event_data)&((Event*)self)->getData();
Event *_self = (Event *) self;
return (spine_event_data) &_self->getData();
}
float spine_event_get_time(spine_event self) {
return ((Event*)self)->getTime();
Event *_self = (Event *) self;
return _self->getTime();
}
int spine_event_get_int(spine_event self) {
return ((Event*)self)->getInt();
Event *_self = (Event *) self;
return _self->getInt();
}
void spine_event_set_int(spine_event self, int inValue) {
((Event*)self)->setInt(inValue);
Event *_self = (Event *) self;
_self->setInt(inValue);
}
float spine_event_get_float(spine_event self) {
return ((Event*)self)->getFloat();
Event *_self = (Event *) self;
return _self->getFloat();
}
void spine_event_set_float(spine_event self, float inValue) {
((Event*)self)->setFloat(inValue);
Event *_self = (Event *) self;
_self->setFloat(inValue);
}
const char * spine_event_get_string(spine_event self) {
return ((Event*)self)->getString().buffer();
const char *spine_event_get_string(spine_event self) {
Event *_self = (Event *) self;
return _self->getString().buffer();
}
void spine_event_set_string(spine_event self, const char * inValue) {
((Event*)self)->setString(String(inValue));
void spine_event_set_string(spine_event self, const char *inValue) {
Event *_self = (Event *) self;
_self->setString(String(inValue));
}
float spine_event_get_volume(spine_event self) {
return ((Event*)self)->getVolume();
Event *_self = (Event *) self;
return _self->getVolume();
}
void spine_event_set_volume(spine_event self, float inValue) {
((Event*)self)->setVolume(inValue);
Event *_self = (Event *) self;
_self->setVolume(inValue);
}
float spine_event_get_balance(spine_event self) {
return ((Event*)self)->getBalance();
Event *_self = (Event *) self;
return _self->getBalance();
}
void spine_event_set_balance(spine_event self, float inValue) {
((Event*)self)->setBalance(inValue);
Event *_self = (Event *) self;
_self->setBalance(inValue);
}

4
spine-c/src/generated/event.h
View File

@ -18,8 +18,8 @@ SPINE_C_API int spine_event_get_int(spine_event self);
SPINE_C_API void spine_event_set_int(spine_event self, int inValue);
SPINE_C_API float spine_event_get_float(spine_event self);
SPINE_C_API void spine_event_set_float(spine_event self, float inValue);
SPINE_C_API const char * spine_event_get_string(spine_event self);
SPINE_C_API void spine_event_set_string(spine_event self, const char * inValue);
SPINE_C_API const char *spine_event_get_string(spine_event self);
SPINE_C_API void spine_event_set_string(spine_event self, const char *inValue);
SPINE_C_API float spine_event_get_volume(spine_event self);
SPINE_C_API void spine_event_set_volume(spine_event self, float inValue);
SPINE_C_API float spine_event_get_balance(spine_event self);

55
spine-c/src/generated/event_data.cpp
View File

@ -3,62 +3,75 @@
using namespace spine;
spine_event_data spine_event_data_create(const char * name) {
return (spine_event_data) new (__FILE__, __LINE__) EventData(String(name));
spine_event_data spine_event_data_create(const char *name) {
return (spine_event_data) new (__FILE__, __LINE__) EventData(String(name));
}
void spine_event_data_dispose(spine_event_data self) {
delete (EventData*)self;
delete (EventData *) self;
}
const char * spine_event_data_get_name(spine_event_data self) {
return ((EventData*)self)->getName().buffer();
const char *spine_event_data_get_name(spine_event_data self) {
EventData *_self = (EventData *) self;
return _self->getName().buffer();
}
int spine_event_data_get_int(spine_event_data self) {
return ((EventData*)self)->getInt();
EventData *_self = (EventData *) self;
return _self->getInt();
}
void spine_event_data_set_int(spine_event_data self, int inValue) {
((EventData*)self)->setInt(inValue);
EventData *_self = (EventData *) self;
_self->setInt(inValue);
}
float spine_event_data_get_float(spine_event_data self) {
return ((EventData*)self)->getFloat();
EventData *_self = (EventData *) self;
return _self->getFloat();
}
void spine_event_data_set_float(spine_event_data self, float inValue) {
((EventData*)self)->setFloat(inValue);
EventData *_self = (EventData *) self;
_self->setFloat(inValue);
}
const char * spine_event_data_get_string(spine_event_data self) {
return ((EventData*)self)->getString().buffer();
const char *spine_event_data_get_string(spine_event_data self) {
EventData *_self = (EventData *) self;
return _self->getString().buffer();
}
void spine_event_data_set_string(spine_event_data self, const char * inValue) {
((EventData*)self)->setString(String(inValue));
void spine_event_data_set_string(spine_event_data self, const char *inValue) {
EventData *_self = (EventData *) self;
_self->setString(String(inValue));
}
const char * spine_event_data_get_audio_path(spine_event_data self) {
return ((EventData*)self)->getAudioPath().buffer();
const char *spine_event_data_get_audio_path(spine_event_data self) {
EventData *_self = (EventData *) self;
return _self->getAudioPath().buffer();
}
void spine_event_data_set_audio_path(spine_event_data self, const char * inValue) {
((EventData*)self)->setAudioPath(String(inValue));
void spine_event_data_set_audio_path(spine_event_data self, const char *inValue) {
EventData *_self = (EventData *) self;
_self->setAudioPath(String(inValue));
}
float spine_event_data_get_volume(spine_event_data self) {
return ((EventData*)self)->getVolume();
EventData *_self = (EventData *) self;
return _self->getVolume();
}
void spine_event_data_set_volume(spine_event_data self, float inValue) {
((EventData*)self)->setVolume(inValue);
EventData *_self = (EventData *) self;
_self->setVolume(inValue);
}
float spine_event_data_get_balance(spine_event_data self) {
return ((EventData*)self)->getBalance();
EventData *_self = (EventData *) self;
return _self->getBalance();
}
void spine_event_data_set_balance(spine_event_data self, float inValue) {
((EventData*)self)->setBalance(inValue);
EventData *_self = (EventData *) self;
_self->setBalance(inValue);
}

12
spine-c/src/generated/event_data.h
View File

@ -8,19 +8,19 @@
extern "C" {
#endif
SPINE_C_API spine_event_data spine_event_data_create(const char * name);
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 const char *spine_event_data_get_name(spine_event_data self);
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 const char *spine_event_data_get_string(spine_event_data self);
SPINE_C_API void spine_event_data_set_string(spine_event_data self, const char *inValue);
SPINE_C_API const char *spine_event_data_get_audio_path(spine_event_data self);
SPINE_C_API void spine_event_data_set_audio_path(spine_event_data self, const char *inValue);
SPINE_C_API float spine_event_data_get_volume(spine_event_data self);
SPINE_C_API void spine_event_data_set_volume(spine_event_data self, float inValue);
SPINE_C_API float spine_event_data_get_balance(spine_event_data self);

22
spine-c/src/generated/event_queue_entry.cpp
View File

@ -4,33 +4,39 @@
using namespace spine;
spine_event_queue_entry spine_event_queue_entry_create(spine_event_type eventType, spine_track_entry trackEntry, spine_event event) {
return (spine_event_queue_entry) new (__FILE__, __LINE__) EventQueueEntry((EventType)eventType, (TrackEntry *)trackEntry, (Event *)event);
return (spine_event_queue_entry) new (__FILE__, __LINE__) EventQueueEntry((EventType) eventType, (TrackEntry *) trackEntry, (Event *) event);
}
void spine_event_queue_entry_dispose(spine_event_queue_entry self) {
delete (EventQueueEntry*)self;
delete (EventQueueEntry *) self;
}
spine_event_type spine_event_queue_entry_get__type(spine_event_queue_entry self) {
return (spine_event_type)((EventQueueEntry*)self)->_type;
EventQueueEntry *_self = (EventQueueEntry *) self;
return (spine_event_type) _self->_type;
}
void spine_event_queue_entry_set__type(spine_event_queue_entry self, spine_event_type value) {
((EventQueueEntry*)self)->_type = (EventType)value;
EventQueueEntry *_self = (EventQueueEntry *) self;
_self->_type = (EventType) value;
}
spine_track_entry spine_event_queue_entry_get__entry(spine_event_queue_entry self) {
return (spine_track_entry)((EventQueueEntry*)self)->_entry;
EventQueueEntry *_self = (EventQueueEntry *) self;
return (spine_track_entry) _self->_entry;
}
void spine_event_queue_entry_set__entry(spine_event_queue_entry self, spine_track_entry value) {
((EventQueueEntry*)self)->_entry = (TrackEntry*)value;
EventQueueEntry *_self = (EventQueueEntry *) self;
_self->_entry = (TrackEntry *) value;
}
spine_event spine_event_queue_entry_get__event(spine_event_queue_entry self) {
return (spine_event)((EventQueueEntry*)self)->_event;
EventQueueEntry *_self = (EventQueueEntry *) self;
return (spine_event) _self->_event;
}
void spine_event_queue_entry_set__event(spine_event_queue_entry self, spine_event value) {
((EventQueueEntry*)self)->_event = (Event*)value;
EventQueueEntry *_self = (EventQueueEntry *) self;
_self->_event = (Event *) value;
}

37
spine-c/src/generated/event_timeline.cpp
View File

@ -4,49 +4,60 @@
using namespace spine;
spine_event_timeline spine_event_timeline_create(size_t frameCount) {
return (spine_event_timeline) new (__FILE__, __LINE__) EventTimeline(frameCount);
return (spine_event_timeline) new (__FILE__, __LINE__) EventTimeline(frameCount);
}
void spine_event_timeline_dispose(spine_event_timeline self) {
delete (EventTimeline*)self;
delete (EventTimeline *) self;
}
spine_rtti spine_event_timeline_get_rtti(spine_event_timeline self) {
return (spine_rtti)&((EventTimeline*)self)->getRTTI();
EventTimeline *_self = (EventTimeline *) self;
return (spine_rtti) &_self->getRTTI();
}
void spine_event_timeline_apply(spine_event_timeline self, spine_skeleton skeleton, float lastTime, float time, spine_array_event pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction, bool appliedPose) {
((EventTimeline*)self)->apply(*((Skeleton*)skeleton), lastTime, time, (Array<Event *> *)pEvents, alpha, (MixBlend)blend, (MixDirection)direction, appliedPose);
void spine_event_timeline_apply(spine_event_timeline self, spine_skeleton skeleton, float lastTime, float time, spine_array_event pEvents,
float alpha, spine_mix_blend blend, spine_mix_direction direction, bool appliedPose) {
EventTimeline *_self = (EventTimeline *) self;
_self->apply(*((Skeleton *) skeleton), lastTime, time, (Array<Event *> *) pEvents, alpha, (MixBlend) blend, (MixDirection) direction,
appliedPose);
}
size_t spine_event_timeline_get_frame_count(spine_event_timeline self) {
return ((EventTimeline*)self)->getFrameCount();
EventTimeline *_self = (EventTimeline *) self;
return _self->getFrameCount();
}
spine_array_event spine_event_timeline_get_events(spine_event_timeline self) {
return (spine_array_event)&((EventTimeline*)self)->getEvents();
EventTimeline *_self = (EventTimeline *) self;
return (spine_array_event) &_self->getEvents();
}
void spine_event_timeline_set_frame(spine_event_timeline self, size_t frame, spine_event event) {
((EventTimeline*)self)->setFrame(frame, (Event *)event);
EventTimeline *_self = (EventTimeline *) self;
_self->setFrame(frame, (Event *) event);
}
size_t spine_event_timeline_get_frame_entries(spine_event_timeline self) {
return ((Timeline*)(EventTimeline*)self)->getFrameEntries();
Timeline *_self = (Timeline *) (EventTimeline *) self;
return _self->getFrameEntries();
}
spine_array_float spine_event_timeline_get_frames(spine_event_timeline self) {
return (spine_array_float)&((Timeline*)(EventTimeline*)self)->getFrames();
Timeline *_self = (Timeline *) (EventTimeline *) self;
return (spine_array_float) &_self->getFrames();
}
float spine_event_timeline_get_duration(spine_event_timeline self) {
return ((Timeline*)(EventTimeline*)self)->getDuration();
Timeline *_self = (Timeline *) (EventTimeline *) self;
return _self->getDuration();
}
spine_array_property_id spine_event_timeline_get_property_ids(spine_event_timeline self) {
return (spine_array_property_id)&((Timeline*)(EventTimeline*)self)->getPropertyIds();
Timeline *_self = (Timeline *) (EventTimeline *) self;
return (spine_array_property_id) &_self->getPropertyIds();
}
spine_rtti spine_event_timeline_rtti(void) {
return (spine_rtti)&EventTimeline::rtti;
return (spine_rtti) &EventTimeline::rtti;
}

3
spine-c/src/generated/event_timeline.h
View File

@ -13,7 +13,8 @@ SPINE_C_API spine_event_timeline spine_event_timeline_create(size_t frameCount);
SPINE_C_API void spine_event_timeline_dispose(spine_event_timeline self);
SPINE_C_API spine_rtti spine_event_timeline_get_rtti(spine_event_timeline self);
SPINE_C_API void spine_event_timeline_apply(spine_event_timeline self, spine_skeleton skeleton, float lastTime, float time, spine_array_event pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction, bool appliedPose);
SPINE_C_API void spine_event_timeline_apply(spine_event_timeline self, spine_skeleton skeleton, float lastTime, float time, spine_array_event pEvents,
float alpha, spine_mix_blend blend, spine_mix_direction direction, bool appliedPose);
SPINE_C_API size_t spine_event_timeline_get_frame_count(spine_event_timeline self);
SPINE_C_API spine_array_event spine_event_timeline_get_events(spine_event_timeline self);
SPINE_C_API void spine_event_timeline_set_frame(spine_event_timeline self, size_t frame, spine_event event);

12
spine-c/src/generated/event_type.h
View File

@ -6,12 +6,12 @@ extern "C" {
#endif
typedef enum spine_event_type {
SPINE_EVENT_TYPE_START = 0,
SPINE_EVENT_TYPE_INTERRUPT,
SPINE_EVENT_TYPE_END,
SPINE_EVENT_TYPE_DISPOSE,
SPINE_EVENT_TYPE_COMPLETE,
SPINE_EVENT_TYPE_EVENT
SPINE_EVENT_TYPE_START = 0,
SPINE_EVENT_TYPE_INTERRUPT,
SPINE_EVENT_TYPE_END,
SPINE_EVENT_TYPE_DISPOSE,
SPINE_EVENT_TYPE_COMPLETE,
SPINE_EVENT_TYPE_EVENT
} spine_event_type;
#ifdef __cplusplus

14
spine-c/src/generated/format.h
View File

@ -6,13 +6,13 @@ extern "C" {
#endif
typedef enum spine_format {
SPINE_FORMAT_ALPHA,
SPINE_FORMAT_INTENSITY,
SPINE_FORMAT_LUMINANCE_ALPHA,
SPINE_FORMAT_RGB565,
SPINE_FORMAT_RGBA4444,
SPINE_FORMAT_RGB888,
SPINE_FORMAT_RGBA8888
SPINE_FORMAT_ALPHA,
SPINE_FORMAT_INTENSITY,
SPINE_FORMAT_LUMINANCE_ALPHA,
SPINE_FORMAT_RGB565,
SPINE_FORMAT_RGBA4444,
SPINE_FORMAT_RGB888,
SPINE_FORMAT_RGBA8888
} spine_format;
#ifdef __cplusplus

24
spine-c/src/generated/from_property.cpp
View File

@ -4,33 +4,39 @@
using namespace spine;
void spine_from_property_dispose(spine_from_property self) {
delete (FromProperty*)self;
delete (FromProperty *) self;
}
spine_rtti spine_from_property_get_rtti(spine_from_property self) {
return (spine_rtti)&((FromProperty*)self)->getRTTI();
FromProperty *_self = (FromProperty *) self;
return (spine_rtti) &_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);
float spine_from_property_value(spine_from_property self, spine_skeleton skeleton, spine_bone_pose source, bool local, float *offsets) {
FromProperty *_self = (FromProperty *) self;
return _self->value(*((Skeleton *) skeleton), *((BonePose *) source), local, offsets);
}
spine_rtti spine_from_property_rtti(void) {
return (spine_rtti)&FromProperty::rtti;
return (spine_rtti) &FromProperty::rtti;
}
float spine_from_property_get__offset(spine_from_property self) {
return ((FromProperty*)self)->_offset;
FromProperty *_self = (FromProperty *) self;
return _self->_offset;
}
void spine_from_property_set__offset(spine_from_property self, float value) {
((FromProperty*)self)->_offset = value;
FromProperty *_self = (FromProperty *) self;
_self->_offset = value;
}
spine_array_to_property spine_from_property_get__to(spine_from_property self) {
return (spine_array_to_property)&((FromProperty*)self)->_to;
FromProperty *_self = (FromProperty *) self;
return (spine_array_to_property) &_self->_to;
}
void spine_from_property_set__to(spine_from_property self, spine_array_to_property value) {
((FromProperty*)self)->_to = *((Array<ToProperty *>*)value);
FromProperty *_self = (FromProperty *) self;
_self->_to = *((Array<ToProperty *> *) value);
}

2
spine-c/src/generated/from_property.h
View File

@ -11,7 +11,7 @@ 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 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);

14
spine-c/src/generated/from_rotate.cpp
View File

@ -4,21 +4,23 @@
using namespace spine;
spine_from_rotate spine_from_rotate_create(void) {
return (spine_from_rotate) new (__FILE__, __LINE__) FromRotate();
return (spine_from_rotate) new (__FILE__, __LINE__) FromRotate();
}
void spine_from_rotate_dispose(spine_from_rotate self) {
delete (FromRotate*)self;
delete (FromRotate *) self;
}
spine_rtti spine_from_rotate_get_rtti(spine_from_rotate self) {
return (spine_rtti)&((FromRotate*)self)->getRTTI();
FromRotate *_self = (FromRotate *) self;
return (spine_rtti) &_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);
float spine_from_rotate_value(spine_from_rotate self, spine_skeleton skeleton, spine_bone_pose source, bool local, float *offsets) {
FromRotate *_self = (FromRotate *) self;
return _self->value(*((Skeleton *) skeleton), *((BonePose *) source), local, offsets);
}
spine_rtti spine_from_rotate_rtti(void) {
return (spine_rtti)&FromRotate::rtti;
return (spine_rtti) &FromRotate::rtti;
}

2
spine-c/src/generated/from_rotate.h
View File

@ -13,7 +13,7 @@ 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 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

14
spine-c/src/generated/from_scale_x.cpp
View File

@ -4,21 +4,23 @@
using namespace spine;
spine_from_scale_x spine_from_scale_x_create(void) {
return (spine_from_scale_x) new (__FILE__, __LINE__) FromScaleX();
return (spine_from_scale_x) new (__FILE__, __LINE__) FromScaleX();
}
void spine_from_scale_x_dispose(spine_from_scale_x self) {
delete (FromScaleX*)self;
delete (FromScaleX *) self;
}
spine_rtti spine_from_scale_x_get_rtti(spine_from_scale_x self) {
return (spine_rtti)&((FromScaleX*)self)->getRTTI();
FromScaleX *_self = (FromScaleX *) self;
return (spine_rtti) &_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);
float spine_from_scale_x_value(spine_from_scale_x self, spine_skeleton skeleton, spine_bone_pose source, bool local, float *offsets) {
FromScaleX *_self = (FromScaleX *) self;
return _self->value(*((Skeleton *) skeleton), *((BonePose *) source), local, offsets);
}
spine_rtti spine_from_scale_x_rtti(void) {
return (spine_rtti)&FromScaleX::rtti;
return (spine_rtti) &FromScaleX::rtti;
}

2
spine-c/src/generated/from_scale_x.h
View File

@ -13,7 +13,7 @@ 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 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

14
spine-c/src/generated/from_scale_y.cpp
View File

@ -4,21 +4,23 @@
using namespace spine;
spine_from_scale_y spine_from_scale_y_create(void) {
return (spine_from_scale_y) new (__FILE__, __LINE__) FromScaleY();
return (spine_from_scale_y) new (__FILE__, __LINE__) FromScaleY();
}
void spine_from_scale_y_dispose(spine_from_scale_y self) {
delete (FromScaleY*)self;
delete (FromScaleY *) self;
}
spine_rtti spine_from_scale_y_get_rtti(spine_from_scale_y self) {
return (spine_rtti)&((FromScaleY*)self)->getRTTI();
FromScaleY *_self = (FromScaleY *) self;
return (spine_rtti) &_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);
float spine_from_scale_y_value(spine_from_scale_y self, spine_skeleton skeleton, spine_bone_pose source, bool local, float *offsets) {
FromScaleY *_self = (FromScaleY *) self;
return _self->value(*((Skeleton *) skeleton), *((BonePose *) source), local, offsets);
}
spine_rtti spine_from_scale_y_rtti(void) {
return (spine_rtti)&FromScaleY::rtti;
return (spine_rtti) &FromScaleY::rtti;
}

2
spine-c/src/generated/from_scale_y.h
View File

@ -13,7 +13,7 @@ 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 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

14
spine-c/src/generated/from_shear_y.cpp
View File

@ -4,21 +4,23 @@
using namespace spine;
spine_from_shear_y spine_from_shear_y_create(void) {
return (spine_from_shear_y) new (__FILE__, __LINE__) FromShearY();
return (spine_from_shear_y) new (__FILE__, __LINE__) FromShearY();
}
void spine_from_shear_y_dispose(spine_from_shear_y self) {
delete (FromShearY*)self;
delete (FromShearY *) self;
}
spine_rtti spine_from_shear_y_get_rtti(spine_from_shear_y self) {
return (spine_rtti)&((FromShearY*)self)->getRTTI();
FromShearY *_self = (FromShearY *) self;
return (spine_rtti) &_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);
float spine_from_shear_y_value(spine_from_shear_y self, spine_skeleton skeleton, spine_bone_pose source, bool local, float *offsets) {
FromShearY *_self = (FromShearY *) self;
return _self->value(*((Skeleton *) skeleton), *((BonePose *) source), local, offsets);
}
spine_rtti spine_from_shear_y_rtti(void) {
return (spine_rtti)&FromShearY::rtti;
return (spine_rtti) &FromShearY::rtti;
}

2
spine-c/src/generated/from_shear_y.h
View File

@ -13,7 +13,7 @@ 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 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

14
spine-c/src/generated/from_x.cpp
View File

@ -4,21 +4,23 @@
using namespace spine;
spine_from_x spine_from_x_create(void) {
return (spine_from_x) new (__FILE__, __LINE__) FromX();
return (spine_from_x) new (__FILE__, __LINE__) FromX();
}
void spine_from_x_dispose(spine_from_x self) {
delete (FromX*)self;
delete (FromX *) self;
}
spine_rtti spine_from_x_get_rtti(spine_from_x self) {
return (spine_rtti)&((FromX*)self)->getRTTI();
FromX *_self = (FromX *) self;
return (spine_rtti) &_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);
float spine_from_x_value(spine_from_x self, spine_skeleton skeleton, spine_bone_pose source, bool local, float *offsets) {
FromX *_self = (FromX *) self;
return _self->value(*((Skeleton *) skeleton), *((BonePose *) source), local, offsets);
}
spine_rtti spine_from_x_rtti(void) {
return (spine_rtti)&FromX::rtti;
return (spine_rtti) &FromX::rtti;
}

2
spine-c/src/generated/from_x.h
View File

@ -13,7 +13,7 @@ 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 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

14
spine-c/src/generated/from_y.cpp
View File

@ -4,21 +4,23 @@
using namespace spine;
spine_from_y spine_from_y_create(void) {
return (spine_from_y) new (__FILE__, __LINE__) FromY();
return (spine_from_y) new (__FILE__, __LINE__) FromY();
}
void spine_from_y_dispose(spine_from_y self) {
delete (FromY*)self;
delete (FromY *) self;
}
spine_rtti spine_from_y_get_rtti(spine_from_y self) {
return (spine_rtti)&((FromY*)self)->getRTTI();
FromY *_self = (FromY *) self;
return (spine_rtti) &_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);
float spine_from_y_value(spine_from_y self, spine_skeleton skeleton, spine_bone_pose source, bool local, float *offsets) {
FromY *_self = (FromY *) self;
return _self->value(*((Skeleton *) skeleton), *((BonePose *) source), local, offsets);
}
spine_rtti spine_from_y_rtti(void) {
return (spine_rtti)&FromY::rtti;
return (spine_rtti) &FromY::rtti;
}

2
spine-c/src/generated/from_y.h
View File

@ -13,7 +13,7 @@ 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 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

72
spine-c/src/generated/ik_constraint.cpp
View File

@ -4,85 +4,111 @@
using namespace spine;
spine_ik_constraint spine_ik_constraint_create(spine_ik_constraint_data data, spine_skeleton skeleton) {
return (spine_ik_constraint) new (__FILE__, __LINE__) IkConstraint(*((IkConstraintData*)data), *((Skeleton*)skeleton));
return (spine_ik_constraint) new (__FILE__, __LINE__) IkConstraint(*((IkConstraintData *) data), *((Skeleton *) skeleton));
}
void spine_ik_constraint_dispose(spine_ik_constraint self) {
delete (IkConstraint*)self;
delete (IkConstraint *) self;
}
spine_rtti spine_ik_constraint_get_rtti(spine_ik_constraint self) {
return (spine_rtti)&((IkConstraint*)self)->getRTTI();
IkConstraint *_self = (IkConstraint *) self;
return (spine_rtti) &_self->getRTTI();
}
spine_ik_constraint spine_ik_constraint_copy(spine_ik_constraint self, spine_skeleton skeleton) {
return (spine_ik_constraint)((IkConstraint*)self)->copy(*((Skeleton*)skeleton));
IkConstraint *_self = (IkConstraint *) self;
return (spine_ik_constraint) _self->copy(*((Skeleton *) skeleton));
}
void spine_ik_constraint_update(spine_ik_constraint self, spine_skeleton skeleton, spine_physics physics) {
((IkConstraint*)self)->update(*((Skeleton*)skeleton), (Physics)physics);
IkConstraint *_self = (IkConstraint *) self;
_self->update(*((Skeleton *) skeleton), (Physics) physics);
}
void spine_ik_constraint_sort(spine_ik_constraint self, spine_skeleton skeleton) {
((IkConstraint*)self)->sort(*((Skeleton*)skeleton));
IkConstraint *_self = (IkConstraint *) self;
_self->sort(*((Skeleton *) skeleton));
}
bool spine_ik_constraint_is_source_active(spine_ik_constraint self) {
return ((IkConstraint*)self)->isSourceActive();
IkConstraint *_self = (IkConstraint *) self;
return _self->isSourceActive();
}
spine_ik_constraint_data spine_ik_constraint_get_data(spine_ik_constraint self) {
return (spine_ik_constraint_data)&((IkConstraint*)self)->getData();
IkConstraint *_self = (IkConstraint *) self;
return (spine_ik_constraint_data) &_self->getData();
}
spine_array_bone_pose spine_ik_constraint_get_bones(spine_ik_constraint self) {
return (spine_array_bone_pose)&((IkConstraint*)self)->getBones();
IkConstraint *_self = (IkConstraint *) self;
return (spine_array_bone_pose) &_self->getBones();
}
spine_bone spine_ik_constraint_get_target(spine_ik_constraint self) {
return (spine_bone)((IkConstraint*)self)->getTarget();
IkConstraint *_self = (IkConstraint *) self;
return (spine_bone) _self->getTarget();
}
void spine_ik_constraint_set_target(spine_ik_constraint self, spine_bone inValue) {
((IkConstraint*)self)->setTarget((Bone *)inValue);
IkConstraint *_self = (IkConstraint *) self;
_self->setTarget((Bone *) inValue);
}
void spine_ik_constraint_apply_1(spine_skeleton skeleton, spine_bone_pose bone, float targetX, float targetY, bool compress, bool stretch, bool uniform, float mix) {
IkConstraint::apply(*((Skeleton*)skeleton), *((BonePose*)bone), targetX, targetY, compress, stretch, uniform, mix);
void spine_ik_constraint_apply_1(spine_skeleton skeleton, spine_bone_pose bone, float targetX, float targetY, bool compress, bool stretch,
bool uniform, float mix) {
IkConstraint::apply(*((Skeleton *) skeleton), *((BonePose *) bone), targetX, targetY, compress, stretch, uniform, mix);
}
void spine_ik_constraint_apply_2(spine_skeleton skeleton, spine_bone_pose parent, spine_bone_pose child, float targetX, float targetY, int bendDirection, bool stretch, bool uniform, float softness, float mix) {
IkConstraint::apply(*((Skeleton*)skeleton), *((BonePose*)parent), *((BonePose*)child), targetX, targetY, bendDirection, stretch, uniform, softness, mix);
void spine_ik_constraint_apply_2(spine_skeleton skeleton, spine_bone_pose parent, spine_bone_pose child, float targetX, float targetY,
int bendDirection, bool stretch, bool uniform, float softness, float mix) {
IkConstraint::apply(*((Skeleton *) skeleton), *((BonePose *) parent), *((BonePose *) child), targetX, targetY, bendDirection, stretch, uniform,
softness, mix);
}
spine_ik_constraint_pose spine_ik_constraint_get_pose(spine_ik_constraint self) {
return (spine_ik_constraint_pose)&((ConstraintGeneric<IkConstraint, IkConstraintData, IkConstraintPose>*)(IkConstraint*)self)->getPose();
ConstraintGeneric<IkConstraint, IkConstraintData, IkConstraintPose>
*_self = (ConstraintGeneric<IkConstraint, IkConstraintData, IkConstraintPose> *) (IkConstraint *) self;
return (spine_ik_constraint_pose) &_self->getPose();
}
spine_ik_constraint_pose spine_ik_constraint_get_applied_pose(spine_ik_constraint self) {
return (spine_ik_constraint_pose)&((ConstraintGeneric<IkConstraint, IkConstraintData, IkConstraintPose>*)(IkConstraint*)self)->getAppliedPose();
ConstraintGeneric<IkConstraint, IkConstraintData, IkConstraintPose>
*_self = (ConstraintGeneric<IkConstraint, IkConstraintData, IkConstraintPose> *) (IkConstraint *) self;
return (spine_ik_constraint_pose) &_self->getAppliedPose();
}
void spine_ik_constraint_reset_constrained(spine_ik_constraint self) {
((ConstraintGeneric<IkConstraint, IkConstraintData, IkConstraintPose>*)(IkConstraint*)self)->resetConstrained();
ConstraintGeneric<IkConstraint, IkConstraintData, IkConstraintPose>
*_self = (ConstraintGeneric<IkConstraint, IkConstraintData, IkConstraintPose> *) (IkConstraint *) self;
_self->resetConstrained();
}
void spine_ik_constraint_constrained(spine_ik_constraint self) {
((ConstraintGeneric<IkConstraint, IkConstraintData, IkConstraintPose>*)(IkConstraint*)self)->constrained();
ConstraintGeneric<IkConstraint, IkConstraintData, IkConstraintPose>
*_self = (ConstraintGeneric<IkConstraint, IkConstraintData, IkConstraintPose> *) (IkConstraint *) self;
_self->constrained();
}
bool spine_ik_constraint_is_pose_equal_to_applied(spine_ik_constraint self) {
return ((ConstraintGeneric<IkConstraint, IkConstraintData, IkConstraintPose>*)(IkConstraint*)self)->isPoseEqualToApplied();
ConstraintGeneric<IkConstraint, IkConstraintData, IkConstraintPose>
*_self = (ConstraintGeneric<IkConstraint, IkConstraintData, IkConstraintPose> *) (IkConstraint *) self;
return _self->isPoseEqualToApplied();
}
bool spine_ik_constraint_is_active(spine_ik_constraint self) {
return ((ConstraintGeneric<IkConstraint, IkConstraintData, IkConstraintPose>*)(IkConstraint*)self)->isActive();
ConstraintGeneric<IkConstraint, IkConstraintData, IkConstraintPose>
*_self = (ConstraintGeneric<IkConstraint, IkConstraintData, IkConstraintPose> *) (IkConstraint *) self;
return _self->isActive();
}
void spine_ik_constraint_set_active(spine_ik_constraint self, bool active) {
((ConstraintGeneric<IkConstraint, IkConstraintData, IkConstraintPose>*)(IkConstraint*)self)->setActive(active);
ConstraintGeneric<IkConstraint, IkConstraintData, IkConstraintPose>
*_self = (ConstraintGeneric<IkConstraint, IkConstraintData, IkConstraintPose> *) (IkConstraint *) self;
_self->setActive(active);
}
spine_rtti spine_ik_constraint_rtti(void) {
return (spine_rtti)&IkConstraint::rtti;
return (spine_rtti) &IkConstraint::rtti;
}

6
spine-c/src/generated/ik_constraint.h
View File

@ -21,8 +21,10 @@ SPINE_C_API spine_ik_constraint_data spine_ik_constraint_get_data(spine_ik_const
SPINE_C_API spine_array_bone_pose spine_ik_constraint_get_bones(spine_ik_constraint self);
SPINE_C_API spine_bone spine_ik_constraint_get_target(spine_ik_constraint self);
SPINE_C_API void spine_ik_constraint_set_target(spine_ik_constraint self, spine_bone inValue);
SPINE_C_API void spine_ik_constraint_apply_1(spine_skeleton skeleton, spine_bone_pose bone, float targetX, float targetY, bool compress, bool stretch, bool uniform, float mix);
SPINE_C_API void spine_ik_constraint_apply_2(spine_skeleton skeleton, spine_bone_pose parent, spine_bone_pose child, float targetX, float targetY, int bendDirection, bool stretch, bool uniform, float softness, float mix);
SPINE_C_API void spine_ik_constraint_apply_1(spine_skeleton skeleton, spine_bone_pose bone, float targetX, float targetY, bool compress, bool stretch,
bool uniform, float mix);
SPINE_C_API void spine_ik_constraint_apply_2(spine_skeleton skeleton, spine_bone_pose parent, spine_bone_pose child, float targetX, float targetY,
int bendDirection, bool stretch, bool uniform, float softness, float mix);
SPINE_C_API spine_ik_constraint_pose spine_ik_constraint_get_pose(spine_ik_constraint self);
SPINE_C_API spine_ik_constraint_pose spine_ik_constraint_get_applied_pose(spine_ik_constraint self);
SPINE_C_API void spine_ik_constraint_reset_constrained(spine_ik_constraint self);

47
spine-c/src/generated/ik_constraint_data.cpp
View File

@ -3,58 +3,73 @@
using namespace spine;
spine_ik_constraint_data spine_ik_constraint_data_create(const char * name) {
return (spine_ik_constraint_data) new (__FILE__, __LINE__) IkConstraintData(String(name));
spine_ik_constraint_data spine_ik_constraint_data_create(const char *name) {
return (spine_ik_constraint_data) new (__FILE__, __LINE__) IkConstraintData(String(name));
}
void spine_ik_constraint_data_dispose(spine_ik_constraint_data self) {
delete (IkConstraintData*)self;
delete (IkConstraintData *) self;
}
spine_rtti spine_ik_constraint_data_get_rtti(spine_ik_constraint_data self) {
return (spine_rtti)&((IkConstraintData*)self)->getRTTI();
IkConstraintData *_self = (IkConstraintData *) self;
return (spine_rtti) &_self->getRTTI();
}
spine_constraint spine_ik_constraint_data_create_method(spine_ik_constraint_data self, spine_skeleton skeleton) {
return (spine_constraint)((IkConstraintData*)self)->create(*((Skeleton*)skeleton));
IkConstraintData *_self = (IkConstraintData *) self;
return (spine_constraint) _self->create(*((Skeleton *) skeleton));
}
spine_array_bone_data spine_ik_constraint_data_get_bones(spine_ik_constraint_data self) {
return (spine_array_bone_data)&((IkConstraintData*)self)->getBones();
IkConstraintData *_self = (IkConstraintData *) self;
return (spine_array_bone_data) &_self->getBones();
}
spine_bone_data spine_ik_constraint_data_get_target(spine_ik_constraint_data self) {
return (spine_bone_data)((IkConstraintData*)self)->getTarget();
IkConstraintData *_self = (IkConstraintData *) self;
return (spine_bone_data) _self->getTarget();
}
void spine_ik_constraint_data_set_target(spine_ik_constraint_data self, spine_bone_data inValue) {
((IkConstraintData*)self)->setTarget((BoneData *)inValue);
IkConstraintData *_self = (IkConstraintData *) self;
_self->setTarget((BoneData *) inValue);
}
bool spine_ik_constraint_data_get_uniform(spine_ik_constraint_data self) {
return ((IkConstraintData*)self)->getUniform();
IkConstraintData *_self = (IkConstraintData *) self;
return _self->getUniform();
}
void spine_ik_constraint_data_set_uniform(spine_ik_constraint_data self, bool uniform) {
((IkConstraintData*)self)->setUniform(uniform);
IkConstraintData *_self = (IkConstraintData *) self;
_self->setUniform(uniform);
}
const char * spine_ik_constraint_data_get_name(spine_ik_constraint_data self) {
return ((ConstraintDataGeneric<IkConstraint, IkConstraintPose>*)(IkConstraintData*)self)->getName().buffer();
const char *spine_ik_constraint_data_get_name(spine_ik_constraint_data self) {
ConstraintDataGeneric<IkConstraint, IkConstraintPose> *_self = (ConstraintDataGeneric<IkConstraint, IkConstraintPose> *) (IkConstraintData *)
self;
return _self->getName().buffer();
}
bool spine_ik_constraint_data_get_skin_required(spine_ik_constraint_data self) {
return ((ConstraintDataGeneric<IkConstraint, IkConstraintPose>*)(IkConstraintData*)self)->getSkinRequired();
ConstraintDataGeneric<IkConstraint, IkConstraintPose> *_self = (ConstraintDataGeneric<IkConstraint, IkConstraintPose> *) (IkConstraintData *)
self;
return _self->getSkinRequired();
}
spine_ik_constraint_pose spine_ik_constraint_data_get_setup_pose(spine_ik_constraint_data self) {
return (spine_ik_constraint_pose)&((ConstraintDataGeneric<IkConstraint, IkConstraintPose>*)(IkConstraintData*)self)->getSetupPose();
ConstraintDataGeneric<IkConstraint, IkConstraintPose> *_self = (ConstraintDataGeneric<IkConstraint, IkConstraintPose> *) (IkConstraintData *)
self;
return (spine_ik_constraint_pose) &_self->getSetupPose();
}
void spine_ik_constraint_data_set_skin_required(spine_ik_constraint_data self, bool skinRequired) {
((ConstraintDataGeneric<IkConstraint, IkConstraintPose>*)(IkConstraintData*)self)->setSkinRequired(skinRequired);
ConstraintDataGeneric<IkConstraint, IkConstraintPose> *_self = (ConstraintDataGeneric<IkConstraint, IkConstraintPose> *) (IkConstraintData *)
self;
_self->setSkinRequired(skinRequired);
}
spine_rtti spine_ik_constraint_data_rtti(void) {
return (spine_rtti)&IkConstraintData::rtti;
return (spine_rtti) &IkConstraintData::rtti;
}

4
spine-c/src/generated/ik_constraint_data.h
View File

@ -8,7 +8,7 @@
extern "C" {
#endif
SPINE_C_API spine_ik_constraint_data spine_ik_constraint_data_create(const char * name);
SPINE_C_API spine_ik_constraint_data spine_ik_constraint_data_create(const char *name);
SPINE_C_API void spine_ik_constraint_data_dispose(spine_ik_constraint_data self);
@ -19,7 +19,7 @@ SPINE_C_API spine_bone_data spine_ik_constraint_data_get_target(spine_ik_constra
SPINE_C_API void spine_ik_constraint_data_set_target(spine_ik_constraint_data self, spine_bone_data inValue);
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 const char *spine_ik_constraint_data_get_name(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);

37
spine-c/src/generated/ik_constraint_pose.cpp
View File

@ -4,53 +4,64 @@
using namespace spine;
spine_ik_constraint_pose spine_ik_constraint_pose_create(void) {
return (spine_ik_constraint_pose) new (__FILE__, __LINE__) IkConstraintPose();
return (spine_ik_constraint_pose) new (__FILE__, __LINE__) IkConstraintPose();
}
void spine_ik_constraint_pose_dispose(spine_ik_constraint_pose self) {
delete (IkConstraintPose*)self;
delete (IkConstraintPose *) self;
}
void spine_ik_constraint_pose_set(spine_ik_constraint_pose self, spine_ik_constraint_pose pose) {
((IkConstraintPose*)self)->set(*((IkConstraintPose*)pose));
IkConstraintPose *_self = (IkConstraintPose *) self;
_self->set(*((IkConstraintPose *) pose));
}
float spine_ik_constraint_pose_get_mix(spine_ik_constraint_pose self) {
return ((IkConstraintPose*)self)->getMix();
IkConstraintPose *_self = (IkConstraintPose *) self;
return _self->getMix();
}
void spine_ik_constraint_pose_set_mix(spine_ik_constraint_pose self, float mix) {
((IkConstraintPose*)self)->setMix(mix);
IkConstraintPose *_self = (IkConstraintPose *) self;
_self->setMix(mix);
}
float spine_ik_constraint_pose_get_softness(spine_ik_constraint_pose self) {
return ((IkConstraintPose*)self)->getSoftness();
IkConstraintPose *_self = (IkConstraintPose *) self;
return _self->getSoftness();
}
void spine_ik_constraint_pose_set_softness(spine_ik_constraint_pose self, float softness) {
((IkConstraintPose*)self)->setSoftness(softness);
IkConstraintPose *_self = (IkConstraintPose *) self;
_self->setSoftness(softness);
}
int spine_ik_constraint_pose_get_bend_direction(spine_ik_constraint_pose self) {
return ((IkConstraintPose*)self)->getBendDirection();
IkConstraintPose *_self = (IkConstraintPose *) self;
return _self->getBendDirection();
}
void spine_ik_constraint_pose_set_bend_direction(spine_ik_constraint_pose self, int bendDirection) {
((IkConstraintPose*)self)->setBendDirection(bendDirection);
IkConstraintPose *_self = (IkConstraintPose *) self;
_self->setBendDirection(bendDirection);
}
bool spine_ik_constraint_pose_get_compress(spine_ik_constraint_pose self) {
return ((IkConstraintPose*)self)->getCompress();
IkConstraintPose *_self = (IkConstraintPose *) self;
return _self->getCompress();
}
void spine_ik_constraint_pose_set_compress(spine_ik_constraint_pose self, bool compress) {
((IkConstraintPose*)self)->setCompress(compress);
IkConstraintPose *_self = (IkConstraintPose *) self;
_self->setCompress(compress);
}
bool spine_ik_constraint_pose_get_stretch(spine_ik_constraint_pose self) {
return ((IkConstraintPose*)self)->getStretch();
IkConstraintPose *_self = (IkConstraintPose *) self;
return _self->getStretch();
}
void spine_ik_constraint_pose_set_stretch(spine_ik_constraint_pose self, bool stretch) {
((IkConstraintPose*)self)->setStretch(stretch);
IkConstraintPose *_self = (IkConstraintPose *) self;
_self->setStretch(stretch);
}

62
spine-c/src/generated/ik_constraint_timeline.cpp
View File

@ -4,73 +4,93 @@
using namespace spine;
spine_ik_constraint_timeline spine_ik_constraint_timeline_create(size_t frameCount, size_t bezierCount, int constraintIndex) {
return (spine_ik_constraint_timeline) new (__FILE__, __LINE__) IkConstraintTimeline(frameCount, bezierCount, constraintIndex);
return (spine_ik_constraint_timeline) new (__FILE__, __LINE__) IkConstraintTimeline(frameCount, bezierCount, constraintIndex);
}
void spine_ik_constraint_timeline_dispose(spine_ik_constraint_timeline self) {
delete (IkConstraintTimeline*)self;
delete (IkConstraintTimeline *) self;
}
spine_rtti spine_ik_constraint_timeline_get_rtti(spine_ik_constraint_timeline self) {
return (spine_rtti)&((IkConstraintTimeline*)self)->getRTTI();
IkConstraintTimeline *_self = (IkConstraintTimeline *) self;
return (spine_rtti) &_self->getRTTI();
}
void spine_ik_constraint_timeline_apply(spine_ik_constraint_timeline self, spine_skeleton skeleton, float lastTime, float time, spine_array_event pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction, bool appliedPose) {
((IkConstraintTimeline*)self)->apply(*((Skeleton*)skeleton), lastTime, time, (Array<Event *> *)pEvents, alpha, (MixBlend)blend, (MixDirection)direction, appliedPose);
void spine_ik_constraint_timeline_apply(spine_ik_constraint_timeline self, spine_skeleton skeleton, float lastTime, float time,
spine_array_event pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction,
bool appliedPose) {
IkConstraintTimeline *_self = (IkConstraintTimeline *) self;
_self->apply(*((Skeleton *) skeleton), lastTime, time, (Array<Event *> *) pEvents, alpha, (MixBlend) blend, (MixDirection) direction,
appliedPose);
}
void spine_ik_constraint_timeline_set_frame(spine_ik_constraint_timeline self, int frame, float time, float mix, float softness, int bendDirection, bool compress, bool stretch) {
((IkConstraintTimeline*)self)->setFrame(frame, time, mix, softness, bendDirection, compress, stretch);
void spine_ik_constraint_timeline_set_frame(spine_ik_constraint_timeline self, int frame, float time, float mix, float softness, int bendDirection,
bool compress, bool stretch) {
IkConstraintTimeline *_self = (IkConstraintTimeline *) self;
_self->setFrame(frame, time, mix, softness, bendDirection, compress, stretch);
}
void spine_ik_constraint_timeline_set_linear(spine_ik_constraint_timeline self, size_t frame) {
((CurveTimeline*)(IkConstraintTimeline*)self)->setLinear(frame);
CurveTimeline *_self = (CurveTimeline *) (IkConstraintTimeline *) self;
_self->setLinear(frame);
}
void spine_ik_constraint_timeline_set_stepped(spine_ik_constraint_timeline self, size_t frame) {
((CurveTimeline*)(IkConstraintTimeline*)self)->setStepped(frame);
CurveTimeline *_self = (CurveTimeline *) (IkConstraintTimeline *) self;
_self->setStepped(frame);
}
void spine_ik_constraint_timeline_set_bezier(spine_ik_constraint_timeline self, size_t bezier, size_t frame, float value, float time1, float value1, float cx1, float cy1, float cx2, float cy2, float time2, float value2) {
((CurveTimeline*)(IkConstraintTimeline*)self)->setBezier(bezier, frame, value, time1, value1, cx1, cy1, cx2, cy2, time2, value2);
void spine_ik_constraint_timeline_set_bezier(spine_ik_constraint_timeline self, size_t bezier, size_t frame, float value, float time1, float value1,
float cx1, float cy1, float cx2, float cy2, float time2, float value2) {
CurveTimeline *_self = (CurveTimeline *) (IkConstraintTimeline *) self;
_self->setBezier(bezier, frame, value, time1, value1, cx1, cy1, cx2, cy2, time2, value2);
}
float spine_ik_constraint_timeline_get_bezier_value(spine_ik_constraint_timeline self, float time, size_t frame, size_t valueOffset, size_t i) {
return ((CurveTimeline*)(IkConstraintTimeline*)self)->getBezierValue(time, frame, valueOffset, i);
CurveTimeline *_self = (CurveTimeline *) (IkConstraintTimeline *) self;
return _self->getBezierValue(time, frame, valueOffset, i);
}
spine_array_float spine_ik_constraint_timeline_get_curves(spine_ik_constraint_timeline self) {
return (spine_array_float)&((CurveTimeline*)(IkConstraintTimeline*)self)->getCurves();
CurveTimeline *_self = (CurveTimeline *) (IkConstraintTimeline *) self;
return (spine_array_float) &_self->getCurves();
}
size_t spine_ik_constraint_timeline_get_frame_entries(spine_ik_constraint_timeline self) {
return ((CurveTimeline*)(IkConstraintTimeline*)self)->getFrameEntries();
CurveTimeline *_self = (CurveTimeline *) (IkConstraintTimeline *) self;
return _self->getFrameEntries();
}
size_t spine_ik_constraint_timeline_get_frame_count(spine_ik_constraint_timeline self) {
return ((CurveTimeline*)(IkConstraintTimeline*)self)->getFrameCount();
CurveTimeline *_self = (CurveTimeline *) (IkConstraintTimeline *) self;
return _self->getFrameCount();
}
spine_array_float spine_ik_constraint_timeline_get_frames(spine_ik_constraint_timeline self) {
return (spine_array_float)&((CurveTimeline*)(IkConstraintTimeline*)self)->getFrames();
CurveTimeline *_self = (CurveTimeline *) (IkConstraintTimeline *) self;
return (spine_array_float) &_self->getFrames();
}
float spine_ik_constraint_timeline_get_duration(spine_ik_constraint_timeline self) {
return ((CurveTimeline*)(IkConstraintTimeline*)self)->getDuration();
CurveTimeline *_self = (CurveTimeline *) (IkConstraintTimeline *) self;
return _self->getDuration();
}
spine_array_property_id spine_ik_constraint_timeline_get_property_ids(spine_ik_constraint_timeline self) {
return (spine_array_property_id)&((CurveTimeline*)(IkConstraintTimeline*)self)->getPropertyIds();
CurveTimeline *_self = (CurveTimeline *) (IkConstraintTimeline *) self;
return (spine_array_property_id) &_self->getPropertyIds();
}
int spine_ik_constraint_timeline_get_constraint_index(spine_ik_constraint_timeline self) {
return ((ConstraintTimeline*)(IkConstraintTimeline*)self)->getConstraintIndex();
ConstraintTimeline *_self = (ConstraintTimeline *) (IkConstraintTimeline *) self;
return _self->getConstraintIndex();
}
void spine_ik_constraint_timeline_set_constraint_index(spine_ik_constraint_timeline self, int inValue) {
((ConstraintTimeline*)(IkConstraintTimeline*)self)->setConstraintIndex(inValue);
ConstraintTimeline *_self = (ConstraintTimeline *) (IkConstraintTimeline *) self;
_self->setConstraintIndex(inValue);
}
spine_rtti spine_ik_constraint_timeline_rtti(void) {
return (spine_rtti)&IkConstraintTimeline::rtti;
return (spine_rtti) &IkConstraintTimeline::rtti;
}

13
spine-c/src/generated/ik_constraint_timeline.h
View File

@ -13,12 +13,17 @@ SPINE_C_API spine_ik_constraint_timeline spine_ik_constraint_timeline_create(siz
SPINE_C_API void spine_ik_constraint_timeline_dispose(spine_ik_constraint_timeline self);
SPINE_C_API spine_rtti spine_ik_constraint_timeline_get_rtti(spine_ik_constraint_timeline self);
SPINE_C_API void spine_ik_constraint_timeline_apply(spine_ik_constraint_timeline self, spine_skeleton skeleton, float lastTime, float time, spine_array_event pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction, bool appliedPose);
SPINE_C_API void spine_ik_constraint_timeline_set_frame(spine_ik_constraint_timeline self, int frame, float time, float mix, float softness, int bendDirection, bool compress, bool stretch);
SPINE_C_API void spine_ik_constraint_timeline_apply(spine_ik_constraint_timeline self, spine_skeleton skeleton, float lastTime, float time,
spine_array_event pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction,
bool appliedPose);
SPINE_C_API void spine_ik_constraint_timeline_set_frame(spine_ik_constraint_timeline self, int frame, float time, float mix, float softness,
int bendDirection, bool compress, bool stretch);
SPINE_C_API void spine_ik_constraint_timeline_set_linear(spine_ik_constraint_timeline self, size_t frame);
SPINE_C_API void spine_ik_constraint_timeline_set_stepped(spine_ik_constraint_timeline self, size_t frame);
SPINE_C_API void spine_ik_constraint_timeline_set_bezier(spine_ik_constraint_timeline self, size_t bezier, size_t frame, float value, float time1, float value1, float cx1, float cy1, float cx2, float cy2, float time2, float value2);
SPINE_C_API float spine_ik_constraint_timeline_get_bezier_value(spine_ik_constraint_timeline self, float time, size_t frame, size_t valueOffset, size_t i);
SPINE_C_API void spine_ik_constraint_timeline_set_bezier(spine_ik_constraint_timeline self, size_t bezier, size_t frame, float value, float time1,
float value1, float cx1, float cy1, float cx2, float cy2, float time2, float value2);
SPINE_C_API float spine_ik_constraint_timeline_get_bezier_value(spine_ik_constraint_timeline self, float time, size_t frame, size_t valueOffset,
size_t i);
SPINE_C_API spine_array_float spine_ik_constraint_timeline_get_curves(spine_ik_constraint_timeline self);
SPINE_C_API size_t spine_ik_constraint_timeline_get_frame_entries(spine_ik_constraint_timeline self);
SPINE_C_API size_t spine_ik_constraint_timeline_get_frame_count(spine_ik_constraint_timeline self);

10
spine-c/src/generated/inherit.h
View File

@ -6,11 +6,11 @@ extern "C" {
#endif
typedef enum spine_inherit {
SPINE_INHERIT_NORMAL = 0,
SPINE_INHERIT_ONLY_TRANSLATION,
SPINE_INHERIT_NO_ROTATION_OR_REFLECTION,
SPINE_INHERIT_NO_SCALE,
SPINE_INHERIT_NO_SCALE_OR_REFLECTION
SPINE_INHERIT_NORMAL = 0,
SPINE_INHERIT_ONLY_TRANSLATION,
SPINE_INHERIT_NO_ROTATION_OR_REFLECTION,
SPINE_INHERIT_NO_SCALE,
SPINE_INHERIT_NO_SCALE_OR_REFLECTION
} spine_inherit;
#ifdef __cplusplus

40
spine-c/src/generated/inherit_timeline.cpp
View File

@ -4,53 +4,65 @@
using namespace spine;
spine_inherit_timeline spine_inherit_timeline_create(size_t frameCount, int boneIndex) {
return (spine_inherit_timeline) new (__FILE__, __LINE__) InheritTimeline(frameCount, boneIndex);
return (spine_inherit_timeline) new (__FILE__, __LINE__) InheritTimeline(frameCount, boneIndex);
}
void spine_inherit_timeline_dispose(spine_inherit_timeline self) {
delete (InheritTimeline*)self;
delete (InheritTimeline *) self;
}
spine_rtti spine_inherit_timeline_get_rtti(spine_inherit_timeline self) {
return (spine_rtti)&((InheritTimeline*)self)->getRTTI();
InheritTimeline *_self = (InheritTimeline *) self;
return (spine_rtti) &_self->getRTTI();
}
void spine_inherit_timeline_set_frame(spine_inherit_timeline self, int frame, float time, spine_inherit inherit) {
((InheritTimeline*)self)->setFrame(frame, time, (Inherit)inherit);
InheritTimeline *_self = (InheritTimeline *) self;
_self->setFrame(frame, time, (Inherit) inherit);
}
void spine_inherit_timeline_apply(spine_inherit_timeline self, spine_skeleton skeleton, float lastTime, float time, spine_array_event pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction, bool appliedPose) {
((InheritTimeline*)self)->apply(*((Skeleton*)skeleton), lastTime, time, (Array<Event *> *)pEvents, alpha, (MixBlend)blend, (MixDirection)direction, appliedPose);
void spine_inherit_timeline_apply(spine_inherit_timeline self, spine_skeleton skeleton, float lastTime, float time, spine_array_event pEvents,
float alpha, spine_mix_blend blend, spine_mix_direction direction, bool appliedPose) {
InheritTimeline *_self = (InheritTimeline *) self;
_self->apply(*((Skeleton *) skeleton), lastTime, time, (Array<Event *> *) pEvents, alpha, (MixBlend) blend, (MixDirection) direction,
appliedPose);
}
size_t spine_inherit_timeline_get_frame_entries(spine_inherit_timeline self) {
return ((Timeline*)(InheritTimeline*)self)->getFrameEntries();
Timeline *_self = (Timeline *) (InheritTimeline *) self;
return _self->getFrameEntries();
}
size_t spine_inherit_timeline_get_frame_count(spine_inherit_timeline self) {
return ((Timeline*)(InheritTimeline*)self)->getFrameCount();
Timeline *_self = (Timeline *) (InheritTimeline *) self;
return _self->getFrameCount();
}
spine_array_float spine_inherit_timeline_get_frames(spine_inherit_timeline self) {
return (spine_array_float)&((Timeline*)(InheritTimeline*)self)->getFrames();
Timeline *_self = (Timeline *) (InheritTimeline *) self;
return (spine_array_float) &_self->getFrames();
}
float spine_inherit_timeline_get_duration(spine_inherit_timeline self) {
return ((Timeline*)(InheritTimeline*)self)->getDuration();
Timeline *_self = (Timeline *) (InheritTimeline *) self;
return _self->getDuration();
}
spine_array_property_id spine_inherit_timeline_get_property_ids(spine_inherit_timeline self) {
return (spine_array_property_id)&((Timeline*)(InheritTimeline*)self)->getPropertyIds();
Timeline *_self = (Timeline *) (InheritTimeline *) self;
return (spine_array_property_id) &_self->getPropertyIds();
}
int spine_inherit_timeline_get_bone_index(spine_inherit_timeline self) {
return ((BoneTimeline*)(InheritTimeline*)self)->getBoneIndex();
BoneTimeline *_self = (BoneTimeline *) (InheritTimeline *) self;
return _self->getBoneIndex();
}
void spine_inherit_timeline_set_bone_index(spine_inherit_timeline self, int inValue) {
((BoneTimeline*)(InheritTimeline*)self)->setBoneIndex(inValue);
BoneTimeline *_self = (BoneTimeline *) (InheritTimeline *) self;
_self->setBoneIndex(inValue);
}
spine_rtti spine_inherit_timeline_rtti(void) {
return (spine_rtti)&InheritTimeline::rtti;
return (spine_rtti) &InheritTimeline::rtti;
}

4
spine-c/src/generated/inherit_timeline.h
View File

@ -14,7 +14,9 @@ SPINE_C_API void spine_inherit_timeline_dispose(spine_inherit_timeline self);
SPINE_C_API spine_rtti spine_inherit_timeline_get_rtti(spine_inherit_timeline self);
SPINE_C_API void spine_inherit_timeline_set_frame(spine_inherit_timeline self, int frame, float time, spine_inherit inherit);
SPINE_C_API void spine_inherit_timeline_apply(spine_inherit_timeline self, spine_skeleton skeleton, float lastTime, float time, spine_array_event pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction, bool appliedPose);
SPINE_C_API void spine_inherit_timeline_apply(spine_inherit_timeline self, spine_skeleton skeleton, float lastTime, float time,
spine_array_event pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction,
bool appliedPose);
SPINE_C_API size_t spine_inherit_timeline_get_frame_entries(spine_inherit_timeline self);
SPINE_C_API size_t spine_inherit_timeline_get_frame_count(spine_inherit_timeline self);
SPINE_C_API spine_array_float spine_inherit_timeline_get_frames(spine_inherit_timeline self);

13
spine-c/src/generated/linked_mesh.cpp
View File

@ -3,14 +3,17 @@
using namespace spine;
spine_linked_mesh spine_linked_mesh_create(spine_mesh_attachment mesh, const int skinIndex, size_t slotIndex, const char * parent, bool inheritTimelines) {
return (spine_linked_mesh) new (__FILE__, __LINE__) LinkedMesh((MeshAttachment *)mesh, skinIndex, slotIndex, String(parent), inheritTimelines);
spine_linked_mesh spine_linked_mesh_create(spine_mesh_attachment mesh, const int skinIndex, size_t slotIndex, const char *parent,
bool inheritTimelines) {
return (spine_linked_mesh) new (__FILE__, __LINE__) LinkedMesh((MeshAttachment *) mesh, skinIndex, slotIndex, String(parent), inheritTimelines);
}
spine_linked_mesh spine_linked_mesh_create2(spine_mesh_attachment mesh, const char * skin, size_t slotIndex, const char * parent, bool inheritTimelines) {
return (spine_linked_mesh) new (__FILE__, __LINE__) LinkedMesh((MeshAttachment *)mesh, String(skin), slotIndex, String(parent), inheritTimelines);
spine_linked_mesh spine_linked_mesh_create2(spine_mesh_attachment mesh, const char *skin, size_t slotIndex, const char *parent,
bool inheritTimelines) {
return (spine_linked_mesh) new (__FILE__, __LINE__)
LinkedMesh((MeshAttachment *) mesh, String(skin), slotIndex, String(parent), inheritTimelines);
}
void spine_linked_mesh_dispose(spine_linked_mesh self) {
delete (LinkedMesh*)self;
delete (LinkedMesh *) self;
}

6
spine-c/src/generated/linked_mesh.h
View File

@ -8,8 +8,10 @@
extern "C" {
#endif
SPINE_C_API spine_linked_mesh spine_linked_mesh_create(spine_mesh_attachment mesh, const int skinIndex, size_t slotIndex, const char * parent, bool inheritTimelines);
SPINE_C_API spine_linked_mesh spine_linked_mesh_create2(spine_mesh_attachment mesh, const char * skin, size_t slotIndex, const char * parent, bool inheritTimelines);
SPINE_C_API spine_linked_mesh spine_linked_mesh_create(spine_mesh_attachment mesh, const int skinIndex, size_t slotIndex, const char *parent,
bool inheritTimelines);
SPINE_C_API spine_linked_mesh spine_linked_mesh_create2(spine_mesh_attachment mesh, const char *skin, size_t slotIndex, const char *parent,
bool inheritTimelines);
SPINE_C_API void spine_linked_mesh_dispose(spine_linked_mesh self);

146
spine-c/src/generated/mesh_attachment.cpp
View File

@ -3,182 +3,226 @@
using namespace spine;
spine_mesh_attachment spine_mesh_attachment_create(const char * name) {
return (spine_mesh_attachment) new (__FILE__, __LINE__) MeshAttachment(String(name));
spine_mesh_attachment spine_mesh_attachment_create(const char *name) {
return (spine_mesh_attachment) new (__FILE__, __LINE__) MeshAttachment(String(name));
}
void spine_mesh_attachment_dispose(spine_mesh_attachment self) {
delete (MeshAttachment*)self;
delete (MeshAttachment *) self;
}
spine_rtti spine_mesh_attachment_get_rtti(spine_mesh_attachment self) {
return (spine_rtti)&((MeshAttachment*)self)->getRTTI();
MeshAttachment *_self = (MeshAttachment *) self;
return (spine_rtti) &_self->getRTTI();
}
void spine_mesh_attachment_compute_world_vertices_1(spine_mesh_attachment self, spine_skeleton skeleton, spine_slot slot, size_t start, size_t count, float * worldVertices, size_t offset, size_t stride) {
((MeshAttachment*)self)->computeWorldVertices(*((Skeleton*)skeleton), *((Slot*)slot), start, count, worldVertices, offset, stride);
void spine_mesh_attachment_compute_world_vertices_1(spine_mesh_attachment self, spine_skeleton skeleton, spine_slot slot, size_t start, size_t count,
float *worldVertices, size_t offset, size_t stride) {
MeshAttachment *_self = (MeshAttachment *) self;
_self->computeWorldVertices(*((Skeleton *) skeleton), *((Slot *) slot), start, count, worldVertices, offset, stride);
}
void spine_mesh_attachment_compute_world_vertices_2(spine_mesh_attachment self, spine_skeleton skeleton, spine_slot slot, size_t start, size_t count, spine_array_float worldVertices, size_t offset, size_t stride) {
((VertexAttachment*)(MeshAttachment*)self)->computeWorldVertices(*((Skeleton*)skeleton), *((Slot*)slot), start, count, *((Array<float>*)worldVertices), offset, stride);
void spine_mesh_attachment_compute_world_vertices_2(spine_mesh_attachment self, spine_skeleton skeleton, spine_slot slot, size_t start, size_t count,
spine_array_float worldVertices, size_t offset, size_t stride) {
VertexAttachment *_self = (VertexAttachment *) (MeshAttachment *) self;
_self->computeWorldVertices(*((Skeleton *) skeleton), *((Slot *) slot), start, count, *((Array<float> *) worldVertices), offset, stride);
}
void spine_mesh_attachment_update_region(spine_mesh_attachment self) {
((MeshAttachment*)self)->updateRegion();
MeshAttachment *_self = (MeshAttachment *) self;
_self->updateRegion();
}
int spine_mesh_attachment_get_hull_length(spine_mesh_attachment self) {
return ((MeshAttachment*)self)->getHullLength();
MeshAttachment *_self = (MeshAttachment *) self;
return _self->getHullLength();
}
void spine_mesh_attachment_set_hull_length(spine_mesh_attachment self, int inValue) {
((MeshAttachment*)self)->setHullLength(inValue);
MeshAttachment *_self = (MeshAttachment *) self;
_self->setHullLength(inValue);
}
spine_array_float spine_mesh_attachment_get_region_u_vs(spine_mesh_attachment self) {
return (spine_array_float)&((MeshAttachment*)self)->getRegionUVs();
MeshAttachment *_self = (MeshAttachment *) self;
return (spine_array_float) &_self->getRegionUVs();
}
void spine_mesh_attachment_set_region_u_vs(spine_mesh_attachment self, spine_array_float inValue) {
((MeshAttachment*)self)->setRegionUVs(*((Array<float>*)inValue));
MeshAttachment *_self = (MeshAttachment *) self;
_self->setRegionUVs(*((Array<float> *) inValue));
}
spine_array_float spine_mesh_attachment_get_u_vs(spine_mesh_attachment self) {
return (spine_array_float)&((MeshAttachment*)self)->getUVs();
MeshAttachment *_self = (MeshAttachment *) self;
return (spine_array_float) &_self->getUVs();
}
spine_array_unsigned_short spine_mesh_attachment_get_triangles(spine_mesh_attachment self) {
return (spine_array_unsigned_short)&((MeshAttachment*)self)->getTriangles();
MeshAttachment *_self = (MeshAttachment *) self;
return (spine_array_unsigned_short) &_self->getTriangles();
}
void spine_mesh_attachment_set_triangles(spine_mesh_attachment self, spine_array_unsigned_short inValue) {
((MeshAttachment*)self)->setTriangles(*((Array<unsigned short>*)inValue));
MeshAttachment *_self = (MeshAttachment *) self;
_self->setTriangles(*((Array<unsigned short> *) inValue));
}
spine_color spine_mesh_attachment_get_color(spine_mesh_attachment self) {
return (spine_color)&((MeshAttachment*)self)->getColor();
MeshAttachment *_self = (MeshAttachment *) self;
return (spine_color) &_self->getColor();
}
const char * spine_mesh_attachment_get_path(spine_mesh_attachment self) {
return ((MeshAttachment*)self)->getPath().buffer();
const char *spine_mesh_attachment_get_path(spine_mesh_attachment self) {
MeshAttachment *_self = (MeshAttachment *) self;
return _self->getPath().buffer();
}
void spine_mesh_attachment_set_path(spine_mesh_attachment self, const char * inValue) {
((MeshAttachment*)self)->setPath(String(inValue));
void spine_mesh_attachment_set_path(spine_mesh_attachment self, const char *inValue) {
MeshAttachment *_self = (MeshAttachment *) self;
_self->setPath(String(inValue));
}
spine_texture_region spine_mesh_attachment_get_region(spine_mesh_attachment self) {
return (spine_texture_region)((MeshAttachment*)self)->getRegion();
MeshAttachment *_self = (MeshAttachment *) self;
return (spine_texture_region) _self->getRegion();
}
void spine_mesh_attachment_set_region(spine_mesh_attachment self, spine_texture_region region) {
((MeshAttachment*)self)->setRegion((TextureRegion *)region);
MeshAttachment *_self = (MeshAttachment *) self;
_self->setRegion((TextureRegion *) region);
}
spine_sequence spine_mesh_attachment_get_sequence(spine_mesh_attachment self) {
return (spine_sequence)((MeshAttachment*)self)->getSequence();
MeshAttachment *_self = (MeshAttachment *) self;
return (spine_sequence) _self->getSequence();
}
void spine_mesh_attachment_set_sequence(spine_mesh_attachment self, spine_sequence sequence) {
((MeshAttachment*)self)->setSequence((Sequence *)sequence);
MeshAttachment *_self = (MeshAttachment *) self;
_self->setSequence((Sequence *) sequence);
}
spine_mesh_attachment spine_mesh_attachment_get_parent_mesh(spine_mesh_attachment self) {
return (spine_mesh_attachment)((MeshAttachment*)self)->getParentMesh();
MeshAttachment *_self = (MeshAttachment *) self;
return (spine_mesh_attachment) _self->getParentMesh();
}
void spine_mesh_attachment_set_parent_mesh(spine_mesh_attachment self, spine_mesh_attachment inValue) {
((MeshAttachment*)self)->setParentMesh((MeshAttachment *)inValue);
MeshAttachment *_self = (MeshAttachment *) self;
_self->setParentMesh((MeshAttachment *) inValue);
}
spine_array_unsigned_short spine_mesh_attachment_get_edges(spine_mesh_attachment self) {
return (spine_array_unsigned_short)&((MeshAttachment*)self)->getEdges();
MeshAttachment *_self = (MeshAttachment *) self;
return (spine_array_unsigned_short) &_self->getEdges();
}
void spine_mesh_attachment_set_edges(spine_mesh_attachment self, spine_array_unsigned_short inValue) {
((MeshAttachment*)self)->setEdges(*((Array<unsigned short>*)inValue));
MeshAttachment *_self = (MeshAttachment *) self;
_self->setEdges(*((Array<unsigned short> *) inValue));
}
float spine_mesh_attachment_get_width(spine_mesh_attachment self) {
return ((MeshAttachment*)self)->getWidth();
MeshAttachment *_self = (MeshAttachment *) self;
return _self->getWidth();
}
void spine_mesh_attachment_set_width(spine_mesh_attachment self, float inValue) {
((MeshAttachment*)self)->setWidth(inValue);
MeshAttachment *_self = (MeshAttachment *) self;
_self->setWidth(inValue);
}
float spine_mesh_attachment_get_height(spine_mesh_attachment self) {
return ((MeshAttachment*)self)->getHeight();
MeshAttachment *_self = (MeshAttachment *) self;
return _self->getHeight();
}
void spine_mesh_attachment_set_height(spine_mesh_attachment self, float inValue) {
((MeshAttachment*)self)->setHeight(inValue);
MeshAttachment *_self = (MeshAttachment *) self;
_self->setHeight(inValue);
}
spine_attachment spine_mesh_attachment_copy(spine_mesh_attachment self) {
return (spine_attachment)((MeshAttachment*)self)->copy();
MeshAttachment *_self = (MeshAttachment *) self;
return (spine_attachment) _self->copy();
}
spine_mesh_attachment spine_mesh_attachment_new_linked_mesh(spine_mesh_attachment self) {
return (spine_mesh_attachment)((MeshAttachment*)self)->newLinkedMesh();
MeshAttachment *_self = (MeshAttachment *) self;
return (spine_mesh_attachment) _self->newLinkedMesh();
}
int spine_mesh_attachment_get_id(spine_mesh_attachment self) {
return ((VertexAttachment*)(MeshAttachment*)self)->getId();
VertexAttachment *_self = (VertexAttachment *) (MeshAttachment *) self;
return _self->getId();
}
spine_array_int spine_mesh_attachment_get_bones(spine_mesh_attachment self) {
return (spine_array_int)&((VertexAttachment*)(MeshAttachment*)self)->getBones();
VertexAttachment *_self = (VertexAttachment *) (MeshAttachment *) self;
return (spine_array_int) &_self->getBones();
}
void spine_mesh_attachment_set_bones(spine_mesh_attachment self, spine_array_int bones) {
((VertexAttachment*)(MeshAttachment*)self)->setBones(*((Array<int>*)bones));
VertexAttachment *_self = (VertexAttachment *) (MeshAttachment *) self;
_self->setBones(*((Array<int> *) bones));
}
spine_array_float spine_mesh_attachment_get_vertices(spine_mesh_attachment self) {
return (spine_array_float)&((VertexAttachment*)(MeshAttachment*)self)->getVertices();
VertexAttachment *_self = (VertexAttachment *) (MeshAttachment *) self;
return (spine_array_float) &_self->getVertices();
}
void spine_mesh_attachment_set_vertices(spine_mesh_attachment self, spine_array_float vertices) {
((VertexAttachment*)(MeshAttachment*)self)->setVertices(*((Array<float>*)vertices));
VertexAttachment *_self = (VertexAttachment *) (MeshAttachment *) self;
_self->setVertices(*((Array<float> *) vertices));
}
size_t spine_mesh_attachment_get_world_vertices_length(spine_mesh_attachment self) {
return ((VertexAttachment*)(MeshAttachment*)self)->getWorldVerticesLength();
VertexAttachment *_self = (VertexAttachment *) (MeshAttachment *) self;
return _self->getWorldVerticesLength();
}
void spine_mesh_attachment_set_world_vertices_length(spine_mesh_attachment self, size_t inValue) {
((VertexAttachment*)(MeshAttachment*)self)->setWorldVerticesLength(inValue);
VertexAttachment *_self = (VertexAttachment *) (MeshAttachment *) self;
_self->setWorldVerticesLength(inValue);
}
spine_attachment spine_mesh_attachment_get_timeline_attachment(spine_mesh_attachment self) {
return (spine_attachment)((VertexAttachment*)(MeshAttachment*)self)->getTimelineAttachment();
VertexAttachment *_self = (VertexAttachment *) (MeshAttachment *) self;
return (spine_attachment) _self->getTimelineAttachment();
}
void spine_mesh_attachment_set_timeline_attachment(spine_mesh_attachment self, spine_attachment attachment) {
((VertexAttachment*)(MeshAttachment*)self)->setTimelineAttachment((Attachment *)attachment);
VertexAttachment *_self = (VertexAttachment *) (MeshAttachment *) self;
_self->setTimelineAttachment((Attachment *) attachment);
}
void spine_mesh_attachment_copy_to(spine_mesh_attachment self, spine_vertex_attachment other) {
((VertexAttachment*)(MeshAttachment*)self)->copyTo((VertexAttachment *)other);
VertexAttachment *_self = (VertexAttachment *) (MeshAttachment *) self;
_self->copyTo((VertexAttachment *) other);
}
const char * spine_mesh_attachment_get_name(spine_mesh_attachment self) {
return ((VertexAttachment*)(MeshAttachment*)self)->getName().buffer();
const char *spine_mesh_attachment_get_name(spine_mesh_attachment self) {
VertexAttachment *_self = (VertexAttachment *) (MeshAttachment *) self;
return _self->getName().buffer();
}
int spine_mesh_attachment_get_ref_count(spine_mesh_attachment self) {
return ((VertexAttachment*)(MeshAttachment*)self)->getRefCount();
VertexAttachment *_self = (VertexAttachment *) (MeshAttachment *) self;
return _self->getRefCount();
}
void spine_mesh_attachment_reference(spine_mesh_attachment self) {
((VertexAttachment*)(MeshAttachment*)self)->reference();
VertexAttachment *_self = (VertexAttachment *) (MeshAttachment *) self;
_self->reference();
}
void spine_mesh_attachment_dereference(spine_mesh_attachment self) {
((VertexAttachment*)(MeshAttachment*)self)->dereference();
VertexAttachment *_self = (VertexAttachment *) (MeshAttachment *) self;
_self->dereference();
}
spine_rtti spine_mesh_attachment_rtti(void) {
return (spine_rtti)&MeshAttachment::rtti;
return (spine_rtti) &MeshAttachment::rtti;
}

Some files were not shown because too many files have changed in this diff Show More