diff --git a/spine-c-new/CMakeLists.txt b/spine-c-new/CMakeLists.txt new file mode 100644 index 000000000..d5fde14d1 --- /dev/null +++ b/spine-c-new/CMakeLists.txt @@ -0,0 +1,43 @@ +cmake_minimum_required(VERSION 3.10) +project(spine-c-new C CXX) + +set(CMAKE_C_STANDARD 99) +set(CMAKE_CXX_STANDARD 11) + +# Include spine-cpp +add_subdirectory(../spine-cpp ${CMAKE_CURRENT_BINARY_DIR}/spine-cpp) + +# Collect all source files +file(GLOB SOURCES + "${CMAKE_CURRENT_SOURCE_DIR}/src/*.c" + "${CMAKE_CURRENT_SOURCE_DIR}/src/*.cpp" +) +file(GLOB GENERATED_SOURCES + "${CMAKE_CURRENT_SOURCE_DIR}/src/generated/*.cpp" +) +list(APPEND SOURCES ${GENERATED_SOURCES}) + +# Create the library +add_library(spine-c-new STATIC ${SOURCES}) + +# Include directories +target_include_directories(spine-c-new PUBLIC + ${CMAKE_CURRENT_SOURCE_DIR}/include + ${CMAKE_CURRENT_SOURCE_DIR}/src +) + +# Link with spine-cpp +target_link_libraries(spine-c-new PRIVATE spine-cpp) + +# Add spine-cpp include directories +target_include_directories(spine-c-new PRIVATE + ../spine-cpp/spine-cpp/include +) + +# Export compile commands for better IDE support +set(CMAKE_EXPORT_COMPILE_COMMANDS ON) + +# Create test executable +add_executable(spine-c-test test/test.c) +target_link_libraries(spine-c-test spine-c-new) +target_include_directories(spine-c-test PRIVATE include) \ No newline at end of file diff --git a/spine-c-new/codegen/exclusions.txt b/spine-c-new/codegen/exclusions.txt new file mode 100644 index 000000000..84eea9fc2 --- /dev/null +++ b/spine-c-new/codegen/exclusions.txt @@ -0,0 +1,49 @@ +# Excluded types (whole type is skipped) +type: SkeletonClipping +type: Triangulator +type: SpineObject +type: TextureLoader +type: DebugExtension +type: DefaultSpineExtension +type: SpineExtension +type: Updateable +type: Pair +type: EventListener +type: AnimationStateListener +type: AnimationStateListenerObject +type: Pool +type: ContainerUtil +type: BlockAllocator +type: MathUtil +type: Vector +type: PoolObject +type: HasRendererObject +type: String +type: StringBuffer +type: EventQueue +type: Json +type: BaseTimeline + +# Excluded methods (specific methods on otherwise included types) +method: AnimationState::setListener +method: AnimationState::addListener +method: AnimationState::removeListener +method: AnimationState::clearListeners +method: AnimationState::disableQueue +method: AnimationState::enableQueue +method: AnimationState::setManualTrackEntryDisposal +method: AnimationState::getManualTrackEntryDisposal +method: Skeleton::updateCache +method: Skeleton::printUpdateCache +method: SkeletonData::setName +method: SkeletonData::setVersion +method: SkeletonData::setHash +method: SkeletonData::setImagesPath +method: SkeletonData::setAudioPath +method: SkeletonData::setFps +method: EventData::setIntValue +method: EventData::setFloatValue +method: EventData::setStringValue +method: EventData::setAudioPath +method: EventData::setVolume +method: EventData::setBalance \ No newline at end of file diff --git a/spine-c-new/codegen/package-lock.json b/spine-c-new/codegen/package-lock.json new file mode 100644 index 000000000..d2a46e949 --- /dev/null +++ b/spine-c-new/codegen/package-lock.json @@ -0,0 +1,48 @@ +{ + "name": "codegen", + "version": "1.0.0", + "lockfileVersion": 3, + "requires": true, + "packages": { + "": { + "name": "codegen", + "version": "1.0.0", + "license": "ISC", + "devDependencies": { + "@types/node": "^24.0.10", + "typescript": "^5.8.3" + } + }, + "node_modules/@types/node": { + "version": "24.0.10", + "resolved": "https://registry.npmjs.org/@types/node/-/node-24.0.10.tgz", + "integrity": "sha512-ENHwaH+JIRTDIEEbDK6QSQntAYGtbvdDXnMXnZaZ6k13Du1dPMmprkEHIL7ok2Wl2aZevetwTAb5S+7yIF+enA==", + "dev": true, + "license": "MIT", + "dependencies": { + "undici-types": "~7.8.0" + } + }, + "node_modules/typescript": { + "version": "5.8.3", + "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.8.3.tgz", + "integrity": "sha512-p1diW6TqL9L07nNxvRMM7hMMw4c5XOo/1ibL4aAIGmSAt9slTE1Xgw5KWuof2uTOvCg9BY7ZRi+GaF+7sfgPeQ==", + "dev": true, + "license": "Apache-2.0", + "bin": { + "tsc": "bin/tsc", + "tsserver": "bin/tsserver" + }, + "engines": { + "node": ">=14.17" + } + }, + "node_modules/undici-types": { + "version": "7.8.0", + "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-7.8.0.tgz", + "integrity": "sha512-9UJ2xGDvQ43tYyVMpuHlsgApydB8ZKfVYTsLDhXkFL/6gfkp+U8xTGdh8pMJv1SpZna0zxG1DwsKZsreLbXBxw==", + "dev": true, + "license": "MIT" + } + } +} diff --git a/spine-c-new/codegen/package.json b/spine-c-new/codegen/package.json new file mode 100644 index 000000000..dd7b8b5c0 --- /dev/null +++ b/spine-c-new/codegen/package.json @@ -0,0 +1,18 @@ +{ + "name": "codegen", + "version": "1.0.0", + "main": "index.js", + "scripts": { + "build": "tsc", + "generate": "npm run build && node dist/index.js", + "test": "echo \"Error: no test specified\" && exit 1" + }, + "keywords": [], + "author": "", + "license": "ISC", + "description": "", + "devDependencies": { + "@types/node": "^24.0.10", + "typescript": "^5.8.3" + } +} diff --git a/spine-c-new/codegen/rtti-bases.txt b/spine-c-new/codegen/rtti-bases.txt new file mode 100644 index 000000000..3ff4851fb --- /dev/null +++ b/spine-c-new/codegen/rtti-bases.txt @@ -0,0 +1,8 @@ +# Base types that need RTTI emulation +Attachment +Constraint +ConstraintData +Pose +Posed +PosedData +Timeline \ No newline at end of file diff --git a/spine-c-new/codegen/src/exclusions.ts b/spine-c-new/codegen/src/exclusions.ts new file mode 100644 index 000000000..e7f953802 --- /dev/null +++ b/spine-c-new/codegen/src/exclusions.ts @@ -0,0 +1,49 @@ +import * as fs from 'fs'; +import { Exclusion } from './types'; + +export function loadExclusions(filePath: string): Exclusion[] { + const content = fs.readFileSync(filePath, 'utf8'); + const lines = content.split('\n'); + const exclusions: Exclusion[] = []; + + for (const line of lines) { + const trimmed = line.trim(); + + // Skip empty lines and comments + if (!trimmed || trimmed.startsWith('#')) continue; + + // Parse type exclusion + const typeMatch = trimmed.match(/^type:\s*(.+)$/); + if (typeMatch) { + exclusions.push({ + kind: 'type', + typeName: typeMatch[1].trim() + }); + continue; + } + + // Parse method exclusion + const methodMatch = trimmed.match(/^method:\s*(.+?)::(.+)$/); + if (methodMatch) { + exclusions.push({ + kind: 'method', + typeName: methodMatch[1].trim(), + methodName: methodMatch[2].trim() + }); + } + } + + return exclusions; +} + +export function isTypeExcluded(typeName: string, exclusions: Exclusion[]): boolean { + return exclusions.some(ex => ex.kind === 'type' && ex.typeName === typeName); +} + +export function isMethodExcluded(typeName: string, methodName: string, exclusions: Exclusion[]): boolean { + return exclusions.some(ex => + ex.kind === 'method' && + ex.typeName === typeName && + ex.methodName === methodName + ); +} \ No newline at end of file diff --git a/spine-c-new/codegen/src/file-writer.ts b/spine-c-new/codegen/src/file-writer.ts new file mode 100644 index 000000000..2e5a73310 --- /dev/null +++ b/spine-c-new/codegen/src/file-writer.ts @@ -0,0 +1,158 @@ +import * as fs from 'fs'; +import * as path from 'path'; +import { Type, toSnakeCase } from './types'; + +const LICENSE_HEADER = `/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/`; + +export class FileWriter { + constructor(private outputDir: string) { + // Clean and recreate output directory + this.cleanOutputDirectory(); + } + + private cleanOutputDirectory(): void { + // Remove existing generated directory if it exists + if (fs.existsSync(this.outputDir)) { + console.log(`Cleaning ${this.outputDir}...`); + fs.rmSync(this.outputDir, { recursive: true, force: true }); + } + + // Recreate the directory + fs.mkdirSync(this.outputDir, { recursive: true }); + } + + async writeType(typeName: string, headerContent: string[], sourceContent: string[]): Promise { + const fileName = toSnakeCase(typeName); + + // Write header file + const headerPath = path.join(this.outputDir, `${fileName}.h`); + const headerGuard = `SPINE_C_${typeName.toUpperCase()}_H`; + + const headerLines = [ + LICENSE_HEADER, + '', + `#ifndef ${headerGuard}`, + `#define ${headerGuard}`, + '', + '#ifdef __cplusplus', + 'extern "C" {', + '#endif', + '', + ...headerContent, + '', + '#ifdef __cplusplus', + '}', + '#endif', + '', + `#endif // ${headerGuard}` + ]; + + fs.writeFileSync(headerPath, headerLines.join('\n')); + + // Write source file (as .cpp since it contains C++ code) + const sourcePath = path.join(this.outputDir, `${fileName}.cpp`); + const sourceLines = [ + LICENSE_HEADER, + '', + ...sourceContent + ]; + + fs.writeFileSync(sourcePath, sourceLines.join('\n')); + } + + async writeEnum(enumName: string, content: string[]): Promise { + const fileName = toSnakeCase(enumName); + const headerPath = path.join(this.outputDir, `${fileName}.h`); + const headerGuard = `SPINE_C_${enumName.toUpperCase()}_H`; + + const headerLines = [ + LICENSE_HEADER, + '', + `#ifndef ${headerGuard}`, + `#define ${headerGuard}`, + '', + '#include "../../custom.h"', + '', + '#ifdef __cplusplus', + 'extern "C" {', + '#endif', + '', + ...content, + '', + '#ifdef __cplusplus', + '}', + '#endif', + '', + `#endif // ${headerGuard}` + ]; + + fs.writeFileSync(headerPath, headerLines.join('\n')); + } + + async writeMainHeader(classes: Type[], enums: Type[]): Promise { + const mainHeaderPath = path.join(this.outputDir, '..', '..', 'include', 'spine-c.h'); + + // Ensure include directory exists + const includeDir = path.dirname(mainHeaderPath); + if (!fs.existsSync(includeDir)) { + fs.mkdirSync(includeDir, { recursive: true }); + } + + const lines = [ + LICENSE_HEADER, + '', + '#ifndef SPINE_C_H', + '#define SPINE_C_H', + '', + '// Custom types and functions', + '#include "../src/custom.h"', + '', + '// Generated enum types' + ]; + + // Add enum includes + for (const enumType of enums) { + lines.push(`#include "../src/generated/${toSnakeCase(enumType.name)}.h"`); + } + + lines.push(''); + lines.push('// Generated class types'); + + // Add class includes + for (const classType of classes) { + lines.push(`#include "../src/generated/${toSnakeCase(classType.name)}.h"`); + } + + lines.push(''); + lines.push('#endif // SPINE_C_H'); + + fs.writeFileSync(mainHeaderPath, lines.join('\n')); + } +} \ No newline at end of file diff --git a/spine-c-new/codegen/src/generators/constructor-generator.ts b/spine-c-new/codegen/src/generators/constructor-generator.ts new file mode 100644 index 000000000..53cd08d59 --- /dev/null +++ b/spine-c-new/codegen/src/generators/constructor-generator.ts @@ -0,0 +1,111 @@ +import { Type, Member, toSnakeCase, toCFunctionName, toCTypeName } from '../types'; + +export interface GeneratorResult { + declarations: string[]; + implementations: string[]; +} + +export class ConstructorGenerator { + generate(type: Type): GeneratorResult { + const declarations: string[] = []; + const implementations: string[] = []; + + if (!type.members) return { declarations, implementations }; + + const constructors = type.members.filter(m => m.kind === 'constructor'); + const cTypeName = `spine_${toSnakeCase(type.name)}`; + + // Generate create functions for each constructor + let constructorIndex = 0; + for (const constructor of constructors) { + const funcName = this.getCreateFunctionName(type.name, constructor, constructorIndex); + const params = this.generateParameters(constructor); + + // Declaration + declarations.push(`SPINE_C_EXPORT ${cTypeName} ${funcName}(${params.declaration});`); + + // Implementation + implementations.push(`${cTypeName} ${funcName}(${params.declaration}) {`); + implementations.push(` ${type.name} *obj = new (__FILE__, __LINE__) ${type.name}(${params.call});`); + implementations.push(` return (${cTypeName}) obj;`); + implementations.push(`}`); + implementations.push(''); + + constructorIndex++; + } + + // Always generate dispose function + declarations.push(`SPINE_C_EXPORT void ${cTypeName}_dispose(${cTypeName} obj);`); + + implementations.push(`void ${cTypeName}_dispose(${cTypeName} obj) {`); + implementations.push(` if (!obj) return;`); + implementations.push(` delete (${type.name} *) obj;`); + implementations.push(`}`); + implementations.push(''); + + return { declarations, implementations }; + } + + private getCreateFunctionName(typeName: string, constructor: Member, index: number): string { + const baseName = `spine_${toSnakeCase(typeName)}_create`; + + if (!constructor.parameters || constructor.parameters.length === 0) { + return baseName; + } + + if (index === 0) { + return baseName; + } + + // Generate name based on parameter types + const paramNames = constructor.parameters + .map(p => this.getParamTypeSuffix(p.type)) + .join('_'); + + return `${baseName}_with_${paramNames}`; + } + + private getParamTypeSuffix(type: string): string { + if (type.includes('float')) return 'float'; + if (type.includes('int')) return 'int'; + if (type.includes('bool')) return 'bool'; + if (type.includes('String') || type.includes('char')) return 'string'; + + // Extract class name from pointers/references + const match = type.match(/(?:const\s+)?(\w+)(?:\s*[*&])?/); + if (match) { + return toSnakeCase(match[1]); + } + + return 'param'; + } + + private generateParameters(constructor: Member): { declaration: string; call: string } { + if (!constructor.parameters || constructor.parameters.length === 0) { + return { declaration: 'void', call: '' }; + } + + const declParts: string[] = []; + const callParts: string[] = []; + + for (const param of constructor.parameters) { + const cType = toCTypeName(param.type); + declParts.push(`${cType} ${param.name}`); + + // Convert C type back to C++ for the call + let callExpr = param.name; + if (param.type === 'const String &' || param.type === 'String') { + callExpr = `String(${param.name})`; + } else if (param.type.includes('*')) { + callExpr = `(${param.type}) ${param.name}`; + } + + callParts.push(callExpr); + } + + return { + declaration: declParts.join(', '), + call: callParts.join(', ') + }; + } +} \ No newline at end of file diff --git a/spine-c-new/codegen/src/generators/enum-generator.ts b/spine-c-new/codegen/src/generators/enum-generator.ts new file mode 100644 index 000000000..362607cdb --- /dev/null +++ b/spine-c-new/codegen/src/generators/enum-generator.ts @@ -0,0 +1,27 @@ +import { Type, toSnakeCase } from '../types'; + +export class EnumGenerator { + generate(enumType: Type): string[] { + const lines: string[] = []; + const enumName = `spine_${toSnakeCase(enumType.name)}`; + + lines.push(`typedef enum ${enumName} {`); + + if (enumType.values) { + for (let i = 0; i < enumType.values.length; i++) { + const value = enumType.values[i]; + const cName = `SPINE_${toSnakeCase(enumType.name).toUpperCase()}_${toSnakeCase(value.name).toUpperCase()}`; + + if (value.value !== undefined) { + lines.push(` ${cName} = ${value.value}${i < enumType.values.length - 1 ? ',' : ''}`); + } else { + lines.push(` ${cName}${i < enumType.values.length - 1 ? ',' : ''}`); + } + } + } + + lines.push(`} ${enumName};`); + + return lines; + } +} \ No newline at end of file diff --git a/spine-c-new/codegen/src/generators/method-generator.ts b/spine-c-new/codegen/src/generators/method-generator.ts new file mode 100644 index 000000000..4f4986d07 --- /dev/null +++ b/spine-c-new/codegen/src/generators/method-generator.ts @@ -0,0 +1,199 @@ +import { Type, Member, toSnakeCase, toCFunctionName, toCTypeName, Exclusion } from '../types'; +import { isMethodExcluded } from '../exclusions'; +import { GeneratorResult } from './constructor-generator'; + +export class MethodGenerator { + constructor(private exclusions: Exclusion[]) {} + + generate(type: Type): GeneratorResult { + const declarations: string[] = []; + const implementations: string[] = []; + + if (!type.members) return { declarations, implementations }; + + const methods = type.members.filter(m => + m.kind === 'method' && + !m.isStatic && + !isMethodExcluded(type.name, m.name, this.exclusions) + ); + + const cTypeName = `spine_${toSnakeCase(type.name)}`; + + for (const method of methods) { + // Handle getters + if (method.name.startsWith('get') && (!method.parameters || method.parameters.length === 0)) { + const propName = method.name.substring(3); + const funcName = toCFunctionName(type.name, method.name); + const returnType = toCTypeName(method.returnType || 'void'); + + declarations.push(`SPINE_C_EXPORT ${returnType} ${funcName}(${cTypeName} obj);`); + + implementations.push(`${returnType} ${funcName}(${cTypeName} obj) {`); + implementations.push(` if (!obj) return ${this.getDefaultReturn(returnType)};`); + implementations.push(` ${type.name} *_obj = (${type.name} *) obj;`); + + const callExpr = this.generateMethodCall('_obj', method); + implementations.push(` return ${callExpr};`); + implementations.push(`}`); + implementations.push(''); + + // Generate collection accessors if return type is Vector + if (method.returnType && method.returnType.includes('Vector<')) { + this.generateCollectionAccessors(type, method, propName, declarations, implementations); + } + } + // Handle setters + else if (method.name.startsWith('set') && method.parameters && method.parameters.length === 1) { + const funcName = toCFunctionName(type.name, method.name); + const paramType = toCTypeName(method.parameters[0].type); + + declarations.push(`SPINE_C_EXPORT void ${funcName}(${cTypeName} obj, ${paramType} value);`); + + implementations.push(`void ${funcName}(${cTypeName} obj, ${paramType} value) {`); + implementations.push(` if (!obj) return;`); + implementations.push(` ${type.name} *_obj = (${type.name} *) obj;`); + + const callExpr = this.generateSetterCall('_obj', method, 'value'); + implementations.push(` ${callExpr};`); + implementations.push(`}`); + implementations.push(''); + } + // Handle other methods + else { + const funcName = toCFunctionName(type.name, method.name); + const returnType = toCTypeName(method.returnType || 'void'); + const params = this.generateMethodParameters(cTypeName, method); + + declarations.push(`SPINE_C_EXPORT ${returnType} ${funcName}(${params.declaration});`); + + implementations.push(`${returnType} ${funcName}(${params.declaration}) {`); + implementations.push(` if (!obj) return ${this.getDefaultReturn(returnType)};`); + implementations.push(` ${type.name} *_obj = (${type.name} *) obj;`); + + const callExpr = this.generateMethodCall('_obj', method, params.call); + if (returnType === 'void') { + implementations.push(` ${callExpr};`); + } else { + implementations.push(` return ${callExpr};`); + } + implementations.push(`}`); + implementations.push(''); + } + } + + return { declarations, implementations }; + } + + private generateCollectionAccessors(type: Type, method: Member, propName: string, + declarations: string[], implementations: string[]) { + const cTypeName = `spine_${toSnakeCase(type.name)}`; + const propSnake = toSnakeCase(propName); + const vectorMatch = method.returnType!.match(/Vector<(.+?)>/); + if (!vectorMatch) return; + + const elementType = vectorMatch[1].trim().replace(/\s*\*$/, ''); + let cElementType: string; + if (elementType === 'int') { + cElementType = 'int32_t'; + } else { + cElementType = `spine_${toSnakeCase(elementType)}`; + } + + // Get count function + const getCountFunc = `spine_${toSnakeCase(type.name)}_get_num_${propSnake}`; + declarations.push(`SPINE_C_EXPORT int32_t ${getCountFunc}(${cTypeName} obj);`); + + implementations.push(`int32_t ${getCountFunc}(${cTypeName} obj) {`); + implementations.push(` if (!obj) return 0;`); + implementations.push(` ${type.name} *_obj = (${type.name} *) obj;`); + implementations.push(` return (int32_t) _obj->get${propName}().size();`); + implementations.push(`}`); + implementations.push(''); + + // Get array function + const getArrayFunc = `spine_${toSnakeCase(type.name)}_get_${propSnake}`; + declarations.push(`SPINE_C_EXPORT ${cElementType} *${getArrayFunc}(${cTypeName} obj);`); + + implementations.push(`${cElementType} *${getArrayFunc}(${cTypeName} obj) {`); + implementations.push(` if (!obj) return nullptr;`); + implementations.push(` ${type.name} *_obj = (${type.name} *) obj;`); + implementations.push(` return (${cElementType} *) _obj->get${propName}().buffer();`); + implementations.push(`}`); + implementations.push(''); + } + + private generateMethodCall(objName: string, method: Member, args?: string): string { + let call = `${objName}->${method.name}(${args || ''})`; + + // Handle return type conversions + if (method.returnType) { + if (method.returnType === 'const String &' || method.returnType === 'String') { + call = `(const utf8 *) ${call}.buffer()`; + } else if (method.returnType === 'const spine::RTTI &' || method.returnType === 'const RTTI &') { + // RTTI needs special handling - return as opaque pointer + call = `(spine_rtti) &${call}`; + } else if (method.returnType.includes('*')) { + const cType = toCTypeName(method.returnType); + call = `(${cType}) ${call}`; + } else if (method.returnType === 'Color &' || method.returnType === 'const Color &') { + call = `(spine_color) &${call}`; + } + } + + return call; + } + + private generateSetterCall(objName: string, method: Member, valueName: string): string { + const param = method.parameters![0]; + let value = valueName; + + // Convert from C type to C++ + if (param.type === 'const String &' || param.type === 'String') { + value = `String(${valueName})`; + } else if (param.type.includes('Vector<')) { + // Vector types are passed as void* and need to be cast back + value = `(${param.type}) ${valueName}`; + } else if (param.type.includes('*')) { + value = `(${param.type}) ${valueName}`; + } + + return `${objName}->${method.name}(${value})`; + } + + private generateMethodParameters(objTypeName: string, method: Member): { declaration: string; call: string } { + const declParts = [`${objTypeName} obj`]; + const callParts: string[] = []; + + if (method.parameters) { + for (const param of method.parameters) { + const cType = toCTypeName(param.type); + declParts.push(`${cType} ${param.name}`); + + // Convert C type back to C++ for the call + let callExpr = param.name; + if (param.type === 'const String &' || param.type === 'String') { + callExpr = `String(${param.name})`; + } else if (param.type.includes('Vector<')) { + // Vector types are passed as void* and need to be cast back + callExpr = `(${param.type}) ${param.name}`; + } else if (param.type.includes('*')) { + callExpr = `(${param.type}) ${param.name}`; + } + + callParts.push(callExpr); + } + } + + return { + declaration: declParts.join(', '), + call: callParts.join(', ') + }; + } + + private getDefaultReturn(returnType: string): string { + if (returnType === 'void') return ''; + if (returnType === 'spine_bool') return '0'; + if (returnType.includes('int') || returnType === 'float' || returnType === 'double') return '0'; + return 'nullptr'; + } +} \ No newline at end of file diff --git a/spine-c-new/codegen/src/generators/opaque-type-generator.ts b/spine-c-new/codegen/src/generators/opaque-type-generator.ts new file mode 100644 index 000000000..499eb4a39 --- /dev/null +++ b/spine-c-new/codegen/src/generators/opaque-type-generator.ts @@ -0,0 +1,8 @@ +import { Type, toSnakeCase } from '../types'; + +export class OpaqueTypeGenerator { + generate(type: Type): string { + const cName = `spine_${toSnakeCase(type.name)}`; + return `SPINE_OPAQUE_TYPE(${cName})`; + } +} \ No newline at end of file diff --git a/spine-c-new/codegen/src/generators/rtti-generator.ts b/spine-c-new/codegen/src/generators/rtti-generator.ts new file mode 100644 index 000000000..3651da5f6 --- /dev/null +++ b/spine-c-new/codegen/src/generators/rtti-generator.ts @@ -0,0 +1,85 @@ +import { Type, toSnakeCase } from '../types'; +import { getTypeHierarchy, getLeafTypes } from '../rtti'; +import { GeneratorResult } from './constructor-generator'; + +export class RttiGenerator { + constructor( + private rttiBases: Set, + private allTypes: Type[] + ) {} + + needsRtti(type: Type): boolean { + const hierarchy = getTypeHierarchy(type, this.allTypes); + return hierarchy.some(t => this.rttiBases.has(t)); + } + + generateForType(baseType: Type): GeneratorResult { + const declarations: string[] = []; + const implementations: string[] = []; + + // Only generate RTTI for base types in rttiBases + if (!this.rttiBases.has(baseType.name)) { + return { declarations, implementations }; + } + + const leafTypes = getLeafTypes(baseType.name, this.allTypes); + const baseSnake = toSnakeCase(baseType.name); + const enumName = `spine_${baseSnake}_type`; + + // Add forward declarations for all leaf types + for (const leafType of leafTypes) { + const leafTypeName = `spine_${toSnakeCase(leafType.name)}`; + declarations.push(`struct ${leafTypeName}_wrapper;`); + declarations.push(`typedef struct ${leafTypeName}_wrapper *${leafTypeName};`); + } + declarations.push(''); + + // Generate enum + declarations.push(`typedef enum ${enumName} {`); + leafTypes.forEach((type, index) => { + const enumValue = `SPINE_TYPE_${baseSnake.toUpperCase()}_${toSnakeCase(type.name).toUpperCase()}`; + declarations.push(` ${enumValue} = ${index}${index < leafTypes.length - 1 ? ',' : ''}`); + }); + declarations.push(`} ${enumName};`); + declarations.push(''); + + // Generate is_type method + const isTypeFunc = `spine_${baseSnake}_is_type`; + declarations.push(`SPINE_C_EXPORT spine_bool ${isTypeFunc}(spine_${baseSnake} obj, ${enumName} type);`); + + implementations.push(`spine_bool ${isTypeFunc}(spine_${baseSnake} obj, ${enumName} type) {`); + implementations.push(` if (!obj) return 0;`); + implementations.push(` ${baseType.name} *_obj = (${baseType.name} *) obj;`); + implementations.push(` `); + implementations.push(` switch (type) {`); + + leafTypes.forEach((type, index) => { + const enumValue = `SPINE_TYPE_${baseSnake.toUpperCase()}_${toSnakeCase(type.name).toUpperCase()}`; + implementations.push(` case ${enumValue}:`); + implementations.push(` return _obj->getRTTI().instanceOf(${type.name}::rtti);`); + }); + + implementations.push(` }`); + implementations.push(` return 0;`); + implementations.push(`}`); + implementations.push(''); + + // Generate cast methods for each leaf type + for (const leafType of leafTypes) { + const castFunc = `spine_${baseSnake}_as_${toSnakeCase(leafType.name)}`; + const returnType = `spine_${toSnakeCase(leafType.name)}`; + + declarations.push(`SPINE_C_EXPORT ${returnType} ${castFunc}(spine_${baseSnake} obj);`); + + implementations.push(`${returnType} ${castFunc}(spine_${baseSnake} obj) {`); + implementations.push(` if (!obj) return nullptr;`); + implementations.push(` ${baseType.name} *_obj = (${baseType.name} *) obj;`); + implementations.push(` if (!_obj->getRTTI().instanceOf(${leafType.name}::rtti)) return nullptr;`); + implementations.push(` return (${returnType}) obj;`); + implementations.push(`}`); + implementations.push(''); + } + + return { declarations, implementations }; + } +} \ No newline at end of file diff --git a/spine-c-new/codegen/src/index.ts b/spine-c-new/codegen/src/index.ts new file mode 100644 index 000000000..029e71eee --- /dev/null +++ b/spine-c-new/codegen/src/index.ts @@ -0,0 +1,109 @@ +#!/usr/bin/env node +import * as fs from 'fs'; +import * as path from 'path'; +import { Type, Member, SpineTypes, toSnakeCase } from './types'; +import { loadExclusions, isTypeExcluded, isMethodExcluded } from './exclusions'; +import { loadRttiBases } from './rtti'; +import { OpaqueTypeGenerator } from './generators/opaque-type-generator'; +import { ConstructorGenerator } from './generators/constructor-generator'; +import { MethodGenerator } from './generators/method-generator'; +import { EnumGenerator } from './generators/enum-generator'; +import { RttiGenerator } from './generators/rtti-generator'; +import { FileWriter } from './file-writer'; + +async function main() { + console.log('Loading type information...'); + + // Load all necessary data + const typesJson = JSON.parse(fs.readFileSync(path.join(__dirname, '../all-spine-types.json'), 'utf8')) as SpineTypes; + const exclusions = loadExclusions(path.join(__dirname, '../exclusions.txt')); + const rttiBases = loadRttiBases(path.join(__dirname, '../rtti-bases.txt')); + + // Flatten all types from all headers into a single array + const allTypes: Type[] = []; + for (const header of Object.keys(typesJson)) { + allTypes.push(...typesJson[header]); + } + + // Filter out excluded types + const includedTypes = allTypes.filter(type => !isTypeExcluded(type.name, exclusions)); + + // Separate classes and enums + const classes = includedTypes.filter(t => t.kind === 'class' || t.kind === 'struct'); + const enums = includedTypes.filter(t => t.kind === 'enum'); + + console.log(`Found ${classes.length} classes/structs and ${enums.length} enums to generate`); + + // Initialize generators + const opaqueTypeGen = new OpaqueTypeGenerator(); + const constructorGen = new ConstructorGenerator(); + const methodGen = new MethodGenerator(exclusions); + const enumGen = new EnumGenerator(); + const rttiGen = new RttiGenerator(rttiBases, allTypes); + const fileWriter = new FileWriter(path.join(__dirname, '../../src/generated')); + + // Generate code for each type + for (const type of classes) { + console.log(`Generating ${type.name}...`); + + const headerContent: string[] = []; + const sourceContent: string[] = []; + + // Add includes + headerContent.push('#include "../custom.h"'); + headerContent.push(''); + + sourceContent.push(`#include "${toSnakeCase(type.name)}.h"`); + sourceContent.push('#include '); + sourceContent.push(''); + sourceContent.push('using namespace spine;'); + sourceContent.push(''); + + // Generate opaque type + headerContent.push(opaqueTypeGen.generate(type)); + headerContent.push(''); + + // Generate constructors + const constructors = constructorGen.generate(type); + if (constructors.declarations.length > 0) { + headerContent.push(...constructors.declarations); + sourceContent.push(...constructors.implementations); + } + + // Generate methods + const methods = methodGen.generate(type); + if (methods.declarations.length > 0) { + headerContent.push(...methods.declarations); + sourceContent.push(...methods.implementations); + } + + // Check if this type needs RTTI + if (rttiGen.needsRtti(type)) { + const rtti = rttiGen.generateForType(type); + if (rtti.declarations.length > 0) { + headerContent.push(...rtti.declarations); + sourceContent.push(...rtti.implementations); + } + } + + // Write files + await fileWriter.writeType(type.name, headerContent, sourceContent); + } + + // Generate enum files + for (const enumType of enums) { + console.log(`Generating enum ${enumType.name}...`); + const enumCode = enumGen.generate(enumType); + await fileWriter.writeEnum(enumType.name, enumCode); + } + + // Generate main header file + await fileWriter.writeMainHeader(classes, enums); + + console.log('Code generation complete!'); +} + +main().catch(error => { + console.error('Error:', error); + process.exit(1); +}); \ No newline at end of file diff --git a/spine-c-new/codegen/src/rtti.ts b/spine-c-new/codegen/src/rtti.ts new file mode 100644 index 000000000..64fdbe602 --- /dev/null +++ b/spine-c-new/codegen/src/rtti.ts @@ -0,0 +1,61 @@ +import * as fs from 'fs'; +import { Type } from './types'; + +export function loadRttiBases(filePath: string): Set { + const content = fs.readFileSync(filePath, 'utf8'); + const lines = content.split('\n'); + const bases = new Set(); + + for (const line of lines) { + const trimmed = line.trim(); + if (trimmed && !trimmed.startsWith('#')) { + bases.add(trimmed); + } + } + + return bases; +} + +export function getTypeHierarchy(type: Type, allTypes: Type[]): string[] { + const hierarchy: string[] = [type.name]; + + if (type.superTypes) { + for (const superName of type.superTypes) { + const superType = allTypes.find(t => t.name === superName); + if (superType) { + hierarchy.push(...getTypeHierarchy(superType, allTypes)); + } + } + } + + return hierarchy; +} + +export function getAllDerivedTypes(baseName: string, allTypes: Type[]): Type[] { + const derived: Type[] = []; + + for (const type of allTypes) { + if (type.superTypes && type.superTypes.includes(baseName)) { + derived.push(type); + // Recursively find all derived types + derived.push(...getAllDerivedTypes(type.name, allTypes)); + } + } + + return derived; +} + +export function getLeafTypes(baseName: string, allTypes: Type[]): Type[] { + const allDerived = getAllDerivedTypes(baseName, allTypes); + const leafTypes: Type[] = []; + + for (const type of allDerived) { + // A type is a leaf if no other type derives from it + const hasChildren = allTypes.some(t => t.superTypes && t.superTypes.includes(type.name)); + if (!hasChildren && !type.isAbstract) { + leafTypes.push(type); + } + } + + return leafTypes; +} \ No newline at end of file diff --git a/spine-c-new/codegen/src/types.ts b/spine-c-new/codegen/src/types.ts new file mode 100644 index 000000000..131a7faa7 --- /dev/null +++ b/spine-c-new/codegen/src/types.ts @@ -0,0 +1,118 @@ +export interface Parameter { + name: string; + type: string; + defaultValue?: string; +} + +export interface Member { + kind: 'field' | 'method' | 'constructor' | 'destructor'; + name: string; + type?: string; // For fields + returnType?: string; // For methods + parameters?: Parameter[]; + isStatic?: boolean; + isVirtual?: boolean; + isPure?: boolean; + isConst?: boolean; + fromSupertype?: string; // Indicates this member was inherited +} + +export interface EnumValue { + name: string; + value?: string; +} + +export interface Type { + name: string; + kind: 'class' | 'struct' | 'enum'; + loc?: { + line: number; + col: number; + }; + superTypes?: string[]; + members?: Member[]; + values?: EnumValue[]; // For enums + isAbstract?: boolean; + isTemplate?: boolean; + templateParams?: string[]; +} + +export interface SpineTypes { + [header: string]: Type[]; +} + +export interface Exclusion { + kind: 'type' | 'method'; + typeName: string; + methodName?: string; +} + +export function toSnakeCase(name: string): string { + // Handle acronyms and consecutive capitals + let result = name.replace(/([A-Z]+)([A-Z][a-z])/g, '$1_$2'); + // Insert underscore before capital letters + result = result.replace(/([a-z\d])([A-Z])/g, '$1_$2'); + return result.toLowerCase(); +} + +export function toCFunctionName(typeName: string, methodName: string): string { + return `spine_${toSnakeCase(typeName)}_${toSnakeCase(methodName)}`; +} + +export function toCTypeName(cppType: string): string { + // Handle basic types + if (cppType === 'float') return 'float'; + if (cppType === 'double') return 'double'; + if (cppType === 'int' || cppType === 'int32_t') return 'int32_t'; + if (cppType === 'unsigned int' || cppType === 'uint32_t') return 'uint32_t'; + if (cppType === 'short' || cppType === 'int16_t') return 'int16_t'; + if (cppType === 'unsigned short' || cppType === 'uint16_t') return 'uint16_t'; + if (cppType === 'bool') return 'spine_bool'; + if (cppType === 'void') return 'void'; + if (cppType === 'size_t') return 'spine_size_t'; + if (cppType === 'const char *' || cppType === 'String' || cppType === 'const String &') return 'const utf8 *'; + + // Handle RTTI type specially + if (cppType === 'const spine::RTTI &' || cppType === 'RTTI &' || cppType === 'const RTTI &') return 'spine_rtti'; + + // Handle Vector types FIRST before checking for pointers - these should be converted to void* in C API + const vectorMatch = cppType.match(/Vector<(.+?)>/); + if (vectorMatch) { + const elementType = vectorMatch[1].trim(); + // Special case for Vector - use int32_t* + if (elementType === 'int') { + return 'int32_t *'; + } + // For now, use void* for other vector parameters since we can't expose templates + return 'void *'; + } + + // Handle pointers + const pointerMatch = cppType.match(/^(.+?)\s*\*$/); + if (pointerMatch) { + const baseType = pointerMatch[1].trim(); + return `spine_${toSnakeCase(baseType)}`; + } + + // Handle references + const refMatch = cppType.match(/^(?:const\s+)?(.+?)\s*&$/); + if (refMatch) { + const baseType = refMatch[1].trim(); + if (baseType === 'String') return 'const utf8 *'; + if (baseType === 'RTTI' || baseType === 'spine::RTTI') return 'spine_rtti'; + return toCTypeName(baseType); + } + + // Handle enum types from spine namespace + const enumTypes = ['MixBlend', 'MixDirection', 'BlendMode', 'AttachmentType', 'EventType', + 'Format', 'TextureFilter', 'TextureWrap', 'Inherit', 'Physics', + 'PositionMode', 'Property', 'RotateMode', 'SequenceMode', 'SpacingMode']; + for (const enumType of enumTypes) { + if (cppType === enumType || cppType === `spine::${enumType}`) { + return `spine_${toSnakeCase(enumType)}`; + } + } + + // Default: assume it's a spine type + return `spine_${toSnakeCase(cppType)}`; +} \ No newline at end of file diff --git a/spine-c-new/codegen/src/validate-coverage.ts b/spine-c-new/codegen/src/validate-coverage.ts new file mode 100644 index 000000000..2bb5fbeb8 --- /dev/null +++ b/spine-c-new/codegen/src/validate-coverage.ts @@ -0,0 +1,81 @@ +#!/usr/bin/env node +import * as fs from 'fs'; +import * as path from 'path'; +import { Type, SpineTypes } from './types'; +import { loadExclusions, isTypeExcluded } from './exclusions'; + +function main() { + console.log('Validating type coverage...\n'); + + // Load all necessary data + const typesJson = JSON.parse(fs.readFileSync(path.join(__dirname, '../all-spine-types.json'), 'utf8')) as SpineTypes; + const exclusions = loadExclusions(path.join(__dirname, '../exclusions.txt')); + + // Flatten all types + const allTypes: Type[] = []; + for (const header of Object.keys(typesJson)) { + allTypes.push(...typesJson[header]); + } + + // Categorize types + const classes = allTypes.filter(t => t.kind === 'class' || t.kind === 'struct'); + const enums = allTypes.filter(t => t.kind === 'enum'); + + // Check excluded types + const excludedTypes = classes.filter(t => isTypeExcluded(t.name, exclusions)); + const includedTypes = classes.filter(t => !isTypeExcluded(t.name, exclusions)); + + // Find abstract types + const abstractTypes = includedTypes.filter(t => t.isAbstract); + const concreteTypes = includedTypes.filter(t => !t.isAbstract); + + console.log('=== Type Coverage Report ===\n'); + console.log(`Total types found: ${allTypes.length}`); + console.log(` Classes/Structs: ${classes.length}`); + console.log(` Enums: ${enums.length}`); + console.log(''); + + console.log(`Excluded types: ${excludedTypes.length}`); + excludedTypes.forEach(t => console.log(` - ${t.name}`)); + console.log(''); + + console.log(`Included types: ${includedTypes.length}`); + console.log(` Abstract: ${abstractTypes.length}`); + abstractTypes.forEach(t => console.log(` - ${t.name}`)); + console.log(` Concrete: ${concreteTypes.length}`); + console.log(''); + + // Check for missing important types + const importantTypes = [ + 'Skeleton', 'SkeletonData', 'Animation', 'AnimationState', + 'Bone', 'Slot', 'Attachment', 'Skin', 'Event' + ]; + + console.log('Important types check:'); + for (const typeName of importantTypes) { + const found = concreteTypes.find(t => t.name === typeName); + const status = found ? '✓' : '✗'; + console.log(` ${status} ${typeName}`); + } + + console.log('\n=== Method Exclusion Report ===\n'); + + // Count excluded methods per type + const methodExclusions = exclusions.filter(e => e.kind === 'method'); + const methodsByType = new Map(); + + for (const exc of methodExclusions) { + if (!methodsByType.has(exc.typeName)) { + methodsByType.set(exc.typeName, []); + } + methodsByType.get(exc.typeName)!.push(exc.methodName!); + } + + console.log(`Total method exclusions: ${methodExclusions.length}`); + for (const [typeName, methods] of methodsByType) { + console.log(` ${typeName}: ${methods.length} methods`); + methods.forEach(m => console.log(` - ${m}`)); + } +} + +main(); \ No newline at end of file diff --git a/spine-c-new/codegen/tsconfig.json b/spine-c-new/codegen/tsconfig.json new file mode 100644 index 000000000..2a13d3a6d --- /dev/null +++ b/spine-c-new/codegen/tsconfig.json @@ -0,0 +1,19 @@ +{ + "compilerOptions": { + "target": "ES2020", + "module": "commonjs", + "lib": ["ES2020"], + "outDir": "./dist", + "rootDir": "./src", + "strict": true, + "esModuleInterop": true, + "skipLibCheck": true, + "forceConsistentCasingInFileNames": true, + "resolveJsonModule": true, + "declaration": true, + "declarationMap": true, + "sourceMap": true + }, + "include": ["src/**/*"], + "exclude": ["node_modules", "dist"] +} \ No newline at end of file diff --git a/spine-c-new/include/spine-c.h b/spine-c-new/include/spine-c.h new file mode 100644 index 000000000..50c900bf1 --- /dev/null +++ b/spine-c-new/include/spine-c.h @@ -0,0 +1,190 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#ifndef SPINE_C_H +#define SPINE_C_H + +// Custom types and functions +#include "../src/custom.h" + +// Generated enum types +#include "../src/generated/event_type.h" +#include "../src/generated/format.h" +#include "../src/generated/texture_filter.h" +#include "../src/generated/texture_wrap.h" +#include "../src/generated/attachment_type.h" +#include "../src/generated/blend_mode.h" +#include "../src/generated/inherit.h" +#include "../src/generated/mix_blend.h" +#include "../src/generated/mix_direction.h" +#include "../src/generated/physics.h" +#include "../src/generated/position_mode.h" +#include "../src/generated/property.h" +#include "../src/generated/rotate_mode.h" +#include "../src/generated/sequence_mode.h" +#include "../src/generated/spacing_mode.h" + +// Generated class types +#include "../src/generated/animation.h" +#include "../src/generated/track_entry.h" +#include "../src/generated/event_queue_entry.h" +#include "../src/generated/animation_state.h" +#include "../src/generated/animation_state_data.h" +#include "../src/generated/atlas_page.h" +#include "../src/generated/atlas_region.h" +#include "../src/generated/atlas.h" +#include "../src/generated/atlas_attachment_loader.h" +#include "../src/generated/attachment.h" +#include "../src/generated/attachment_loader.h" +#include "../src/generated/attachment_timeline.h" +#include "../src/generated/block.h" +#include "../src/generated/bone.h" +#include "../src/generated/bone_data.h" +#include "../src/generated/bone_local.h" +#include "../src/generated/bone_pose.h" +#include "../src/generated/bone_timeline.h" +#include "../src/generated/bone_timeline1.h" +#include "../src/generated/bone_timeline2.h" +#include "../src/generated/bounding_box_attachment.h" +#include "../src/generated/clipping_attachment.h" +#include "../src/generated/color.h" +#include "../src/generated/rgba_timeline.h" +#include "../src/generated/rgb_timeline.h" +#include "../src/generated/alpha_timeline.h" +#include "../src/generated/rgba2_timeline.h" +#include "../src/generated/rgb2_timeline.h" +#include "../src/generated/constraint.h" +#include "../src/generated/constraint_generic.h" +#include "../src/generated/constraint_data.h" +#include "../src/generated/constraint_data_generic.h" +#include "../src/generated/constraint_timeline.h" +#include "../src/generated/constraint_timeline1.h" +#include "../src/generated/curve_timeline.h" +#include "../src/generated/curve_timeline1.h" +#include "../src/generated/curve_timeline2.h" +#include "../src/generated/deform_timeline.h" +#include "../src/generated/draw_order_timeline.h" +#include "../src/generated/event.h" +#include "../src/generated/event_data.h" +#include "../src/generated/event_timeline.h" +#include "../src/generated/hash_map.h" +#include "../src/generated/ik_constraint.h" +#include "../src/generated/ik_constraint_data.h" +#include "../src/generated/ik_constraint_pose.h" +#include "../src/generated/ik_constraint_timeline.h" +#include "../src/generated/inherit_timeline.h" +#include "../src/generated/linked_mesh.h" +#include "../src/generated/interpolation.h" +#include "../src/generated/pow_interpolation.h" +#include "../src/generated/pow_out_interpolation.h" +#include "../src/generated/mesh_attachment.h" +#include "../src/generated/path_attachment.h" +#include "../src/generated/path_constraint.h" +#include "../src/generated/path_constraint_data.h" +#include "../src/generated/path_constraint_mix_timeline.h" +#include "../src/generated/path_constraint_pose.h" +#include "../src/generated/path_constraint_position_timeline.h" +#include "../src/generated/path_constraint_spacing_timeline.h" +#include "../src/generated/physics_constraint.h" +#include "../src/generated/physics_constraint_data.h" +#include "../src/generated/physics_constraint_pose.h" +#include "../src/generated/physics_constraint_timeline.h" +#include "../src/generated/physics_constraint_inertia_timeline.h" +#include "../src/generated/physics_constraint_strength_timeline.h" +#include "../src/generated/physics_constraint_damping_timeline.h" +#include "../src/generated/physics_constraint_mass_timeline.h" +#include "../src/generated/physics_constraint_wind_timeline.h" +#include "../src/generated/physics_constraint_gravity_timeline.h" +#include "../src/generated/physics_constraint_mix_timeline.h" +#include "../src/generated/physics_constraint_reset_timeline.h" +#include "../src/generated/point_attachment.h" +#include "../src/generated/pose.h" +#include "../src/generated/posed.h" +#include "../src/generated/posed_generic.h" +#include "../src/generated/posed_active.h" +#include "../src/generated/posed_data.h" +#include "../src/generated/posed_data_generic.h" +#include "../src/generated/rtti.h" +#include "../src/generated/region_attachment.h" +#include "../src/generated/rotate_timeline.h" +#include "../src/generated/scale_timeline.h" +#include "../src/generated/scale_x_timeline.h" +#include "../src/generated/scale_y_timeline.h" +#include "../src/generated/sequence.h" +#include "../src/generated/sequence_timeline.h" +#include "../src/generated/shear_timeline.h" +#include "../src/generated/shear_x_timeline.h" +#include "../src/generated/shear_y_timeline.h" +#include "../src/generated/skeleton.h" +#include "../src/generated/skeleton_binary.h" +#include "../src/generated/skeleton_bounds.h" +#include "../src/generated/polygon.h" +#include "../src/generated/skeleton_data.h" +#include "../src/generated/skeleton_json.h" +#include "../src/generated/render_command.h" +#include "../src/generated/skeleton_renderer.h" +#include "../src/generated/skin.h" +#include "../src/generated/slider.h" +#include "../src/generated/slider_data.h" +#include "../src/generated/slider_mix_timeline.h" +#include "../src/generated/slider_pose.h" +#include "../src/generated/slider_timeline.h" +#include "../src/generated/slot.h" +#include "../src/generated/slot_curve_timeline.h" +#include "../src/generated/slot_data.h" +#include "../src/generated/slot_pose.h" +#include "../src/generated/slot_timeline.h" +#include "../src/generated/texture_region.h" +#include "../src/generated/timeline.h" +#include "../src/generated/transform_constraint.h" +#include "../src/generated/from_property.h" +#include "../src/generated/to_property.h" +#include "../src/generated/from_rotate.h" +#include "../src/generated/to_rotate.h" +#include "../src/generated/from_x.h" +#include "../src/generated/to_x.h" +#include "../src/generated/from_y.h" +#include "../src/generated/to_y.h" +#include "../src/generated/from_scale_x.h" +#include "../src/generated/to_scale_x.h" +#include "../src/generated/from_scale_y.h" +#include "../src/generated/to_scale_y.h" +#include "../src/generated/from_shear_y.h" +#include "../src/generated/to_shear_y.h" +#include "../src/generated/transform_constraint_data.h" +#include "../src/generated/transform_constraint_pose.h" +#include "../src/generated/transform_constraint_timeline.h" +#include "../src/generated/translate_timeline.h" +#include "../src/generated/translate_x_timeline.h" +#include "../src/generated/translate_y_timeline.h" +#include "../src/generated/update.h" +#include "../src/generated/vertex_attachment.h" +#include "../src/generated/vertices.h" + +#endif // SPINE_C_H \ No newline at end of file diff --git a/spine-c-new/src/custom.cpp b/spine-c-new/src/custom.cpp new file mode 100644 index 000000000..9cf4b1ce8 --- /dev/null +++ b/spine-c-new/src/custom.cpp @@ -0,0 +1,529 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#include "custom.h" +#include +#include +#include +#include +#include +#include + +using namespace spine; + +// Internal structures +struct _spine_atlas { + void *atlas; + utf8 **imagePaths; + int32_t numImagePaths; + utf8 *error; +}; + +struct _spine_skeleton_data_result { + spine_skeleton_data skeletonData; + utf8 *error; +}; + +struct _spine_bounds { + float x, y, width, height; +}; + +struct _spine_vector { + 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; +}; + +struct _spine_skin_entry { + int32_t slotIndex; + utf8 *name; + spine_attachment attachment; +}; + +struct _spine_skin_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){}; +}; + +class EventListener : public AnimationStateListenerObject, public SpineObject { +public: + Vector events; + + void callback(AnimationState *state, EventType type, TrackEntry *entry, Event *event) override { + events.add(AnimationStateEvent(type, entry, event)); + SP_UNUSED(state); + } +}; + +// Static variables +static Color NULL_COLOR(0, 0, 0, 0); +static SpineExtension *defaultExtension = nullptr; +static DebugExtension *debugExtension = nullptr; + +static void initExtensions() { + if (defaultExtension == nullptr) { + defaultExtension = new DefaultSpineExtension(); + debugExtension = new DebugExtension(defaultExtension); + } +} + +namespace spine { + SpineExtension *getDefaultExtension() { + initExtensions(); + return defaultExtension; + } +} + +// Version functions +int32_t spine_major_version() { + return SPINE_MAJOR_VERSION; +} + +int32_t spine_minor_version() { + return SPINE_MINOR_VERSION; +} + +void spine_enable_debug_extension(spine_bool enable) { + initExtensions(); + SpineExtension::setInstance(enable ? debugExtension : defaultExtension); +} + +void spine_report_leaks() { + initExtensions(); + debugExtension->reportLeaks(); + fflush(stdout); +} + +// Color functions +float spine_color_get_r(spine_color color) { + if (!color) return 0; + return ((Color *) color)->r; +} + +float spine_color_get_g(spine_color color) { + if (!color) return 0; + return ((Color *) color)->g; +} + +float spine_color_get_b(spine_color color) { + if (!color) return 0; + return ((Color *) color)->b; +} + +float spine_color_get_a(spine_color color) { + if (!color) return 0; + return ((Color *) color)->a; +} + +// Bounds functions +float spine_bounds_get_x(spine_bounds bounds) { + 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; +} + +float spine_bounds_get_width(spine_bounds bounds) { + 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; +} + +// Vector functions +float spine_vector_get_x(spine_vector vector) { + 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; +} + +// Atlas functions +class LiteTextureLoad : public TextureLoader { + void load(AtlasPage &page, const String &path) { + page.texture = (void *) (intptr_t) page.index; + } + + void unload(void *texture) { + } +}; +static LiteTextureLoad liteLoader; + +spine_atlas spine_atlas_load(const utf8 *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(result->numImagePaths, __FILE__, __LINE__); + for (int i = 0; i < result->numImagePaths; i++) { + result->imagePaths[i] = (utf8 *) strdup(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; + +public: + CallbackTextureLoad() : loadCb(nullptr), unloadCb(nullptr) {} + + 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 unload(void *texture) { + this->unloadCb(texture); + } +}; +static CallbackTextureLoad callbackLoader; + +spine_atlas spine_atlas_load_callback(const utf8 *atlasData, const utf8 *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(result->numImagePaths, __FILE__, __LINE__); + for (int i = 0; i < result->numImagePaths; i++) { + result->imagePaths[i] = (utf8 *) strdup(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; +} + +utf8 *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]; +} + +spine_bool spine_atlas_is_pma(spine_atlas atlas) { + if (!atlas) return 0; + 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 -1; + } + return 0; +} + +utf8 *spine_atlas_get_error(spine_atlas atlas) { + 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) { + for (int i = 0; i < _atlas->numImagePaths; i++) { + if (_atlas->imagePaths[i]) { + SpineExtension::free(_atlas->imagePaths[i], __FILE__, __LINE__); + } + } + 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 utf8 *skeletonData) { + 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 = (utf8 *) strdup("Failed to load skeleton 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) { + 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 = (utf8 *) strdup("Failed to load skeleton data"); + return (spine_skeleton_data_result) result; + } + + result->skeletonData = (spine_skeleton_data) data; + return (spine_skeleton_data_result) result; +} + +utf8 *spine_skeleton_data_result_get_error(spine_skeleton_data_result result) { + 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; +} + +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__); +} + +// 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(); + + 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(); + + 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; + + 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->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; +} + +spine_skeleton spine_skeleton_drawable_get_skeleton(spine_skeleton_drawable drawable) { + 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; +} + +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; +} + +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; +} + +// Render command functions +float *spine_render_command_get_positions(spine_render_command command) { + if (!command) return nullptr; + return ((RenderCommand *) command)->positions; +} + +float *spine_render_command_get_uvs(spine_render_command command) { + if (!command) return nullptr; + return ((RenderCommand *) command)->uvs; +} + +int32_t *spine_render_command_get_colors(spine_render_command command) { + if (!command) return nullptr; + return (int32_t *) ((RenderCommand *) command)->colors; +} + +int32_t *spine_render_command_get_dark_colors(spine_render_command command) { + if (!command) return nullptr; + return (int32_t *) ((RenderCommand *) command)->darkColors; +} + +int32_t spine_render_command_get_num_vertices(spine_render_command command) { + if (!command) return 0; + return ((RenderCommand *) command)->numVertices; +} + +uint16_t *spine_render_command_get_indices(spine_render_command command) { + if (!command) return nullptr; + return ((RenderCommand *) command)->indices; +} + +int32_t spine_render_command_get_num_indices(spine_render_command command) { + if (!command) return 0; + return ((RenderCommand *) command)->numIndices; +} + +int32_t spine_render_command_get_atlas_page(spine_render_command command) { + if (!command) return 0; + return (int32_t) (intptr_t) ((RenderCommand *) command)->texture; +} + +spine_blend_mode spine_render_command_get_blend_mode(spine_render_command command) { + if (!command) return SPINE_BLEND_MODE_NORMAL; + BlendMode mode = ((RenderCommand *) command)->blendMode; + switch (mode) { + case BlendMode_Normal: return SPINE_BLEND_MODE_NORMAL; + case BlendMode_Additive: return SPINE_BLEND_MODE_ADDITIVE; + case BlendMode_Multiply: return SPINE_BLEND_MODE_MULTIPLY; + case BlendMode_Screen: return SPINE_BLEND_MODE_SCREEN; + default: return SPINE_BLEND_MODE_NORMAL; + } +} + +spine_render_command spine_render_command_get_next(spine_render_command command) { + if (!command) return nullptr; + return (spine_render_command) ((RenderCommand *) command)->next; +} + +// 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; +} + +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__); +} + +int32_t spine_skin_entries_get_num_entries(spine_skin_entries entries) { + 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]; +} + +int32_t spine_skin_entry_get_slot_index(spine_skin_entry entry) { + if (!entry) return 0; + return ((_spine_skin_entry *) entry)->slotIndex; +} + +const utf8 *spine_skin_entry_get_name(spine_skin_entry entry) { + 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; +} \ No newline at end of file diff --git a/spine-c-new/src/custom.h b/spine-c-new/src/custom.h new file mode 100644 index 000000000..bebb9ff0d --- /dev/null +++ b/spine-c-new/src/custom.h @@ -0,0 +1,194 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#ifndef SPINE_C_NEW_CUSTOM_H +#define SPINE_C_NEW_CUSTOM_H + +#include +#include + +#ifdef __cplusplus +#if _WIN32 +#define SPINE_C_EXPORT extern "C" __declspec(dllexport) +#else +#ifdef __EMSCRIPTEN__ +#define SPINE_C_EXPORT extern "C" __attribute__((used)) +#else +#define SPINE_C_EXPORT extern "C" +#endif +#endif +#else +#if _WIN32 +#define SPINE_C_EXPORT __declspec(dllexport) +#else +#ifdef __EMSCRIPTEN__ +#define SPINE_C_EXPORT __attribute__((used)) +#else +#define SPINE_C_EXPORT +#endif +#endif +#endif + +#define SPINE_OPAQUE_TYPE(name) \ + typedef struct name##_wrapper { \ + } name##_wrapper; \ + typedef name##_wrapper *name; + +typedef char utf8; +typedef int32_t spine_bool; +typedef size_t spine_size_t; + +// Custom types for spine-c-new +SPINE_OPAQUE_TYPE(spine_atlas) +SPINE_OPAQUE_TYPE(spine_skeleton_data_result) +SPINE_OPAQUE_TYPE(spine_bounds) +SPINE_OPAQUE_TYPE(spine_vector) +SPINE_OPAQUE_TYPE(spine_color) +SPINE_OPAQUE_TYPE(spine_skeleton_drawable) +SPINE_OPAQUE_TYPE(spine_render_command) +SPINE_OPAQUE_TYPE(spine_skin_entry) +SPINE_OPAQUE_TYPE(spine_skin_entries) +SPINE_OPAQUE_TYPE(spine_rtti) + +// Texture loader callbacks +typedef void* (*spine_texture_loader_load_func)(const char *path); +typedef void (*spine_texture_loader_unload_func)(void *texture); + +// Version functions +SPINE_C_EXPORT int32_t spine_major_version(); +SPINE_C_EXPORT int32_t spine_minor_version(); +SPINE_C_EXPORT void spine_enable_debug_extension(spine_bool enable); +SPINE_C_EXPORT void spine_report_leaks(); + +// Color functions +SPINE_C_EXPORT float spine_color_get_r(spine_color color); +SPINE_C_EXPORT float spine_color_get_g(spine_color color); +SPINE_C_EXPORT float spine_color_get_b(spine_color color); +SPINE_C_EXPORT float spine_color_get_a(spine_color color); + +// Bounds functions +SPINE_C_EXPORT float spine_bounds_get_x(spine_bounds bounds); +SPINE_C_EXPORT float spine_bounds_get_y(spine_bounds bounds); +SPINE_C_EXPORT float spine_bounds_get_width(spine_bounds bounds); +SPINE_C_EXPORT float spine_bounds_get_height(spine_bounds bounds); + +// Vector functions +SPINE_C_EXPORT float spine_vector_get_x(spine_vector vector); +SPINE_C_EXPORT float spine_vector_get_y(spine_vector vector); + +// Atlas functions +SPINE_C_EXPORT spine_atlas spine_atlas_load(const utf8 *atlasData); +SPINE_C_EXPORT spine_atlas spine_atlas_load_callback(const utf8 *atlasData, const utf8 *atlasDir, + spine_texture_loader_load_func load, + spine_texture_loader_unload_func unload); +SPINE_C_EXPORT int32_t spine_atlas_get_num_image_paths(spine_atlas atlas); +SPINE_C_EXPORT utf8 *spine_atlas_get_image_path(spine_atlas atlas, int32_t index); +SPINE_C_EXPORT spine_bool spine_atlas_is_pma(spine_atlas atlas); +SPINE_C_EXPORT utf8 *spine_atlas_get_error(spine_atlas atlas); +SPINE_C_EXPORT void spine_atlas_dispose(spine_atlas atlas); + +// Forward declarations for types used in generated headers +struct spine_skeleton_data_wrapper; +typedef struct spine_skeleton_data_wrapper *spine_skeleton_data; +struct spine_timeline_wrapper; +typedef struct spine_timeline_wrapper *spine_timeline; +struct spine_skeleton_wrapper; +typedef struct spine_skeleton_wrapper *spine_skeleton; +struct spine_event_wrapper; +typedef struct spine_event_wrapper *spine_event; +struct spine_skin_wrapper; +typedef struct spine_skin_wrapper *spine_skin; +struct spine_sequence_wrapper; +typedef struct spine_sequence_wrapper *spine_sequence; +struct spine_attachment_wrapper; +typedef struct spine_attachment_wrapper *spine_attachment; + +SPINE_C_EXPORT spine_skeleton_data_result spine_skeleton_data_load_json(spine_atlas atlas, const utf8 *skeletonData); +SPINE_C_EXPORT spine_skeleton_data_result spine_skeleton_data_load_binary(spine_atlas atlas, const uint8_t *skeletonData, int32_t length); +SPINE_C_EXPORT utf8 *spine_skeleton_data_result_get_error(spine_skeleton_data_result result); +SPINE_C_EXPORT spine_skeleton_data spine_skeleton_data_result_get_data(spine_skeleton_data_result result); +SPINE_C_EXPORT void spine_skeleton_data_result_dispose(spine_skeleton_data_result result); + +// Skeleton drawable - these need forward declarations +struct spine_skeleton_wrapper; +typedef struct spine_skeleton_wrapper *spine_skeleton; +struct spine_animation_state_wrapper; +typedef struct spine_animation_state_wrapper *spine_animation_state; +struct spine_animation_state_data_wrapper; +typedef struct spine_animation_state_data_wrapper *spine_animation_state_data; +struct spine_animation_state_events_wrapper; +typedef struct spine_animation_state_events_wrapper *spine_animation_state_events; + +SPINE_C_EXPORT spine_skeleton_drawable spine_skeleton_drawable_create(spine_skeleton_data skeletonData); +SPINE_C_EXPORT spine_render_command spine_skeleton_drawable_render(spine_skeleton_drawable drawable); +SPINE_C_EXPORT void spine_skeleton_drawable_dispose(spine_skeleton_drawable drawable); +SPINE_C_EXPORT spine_skeleton spine_skeleton_drawable_get_skeleton(spine_skeleton_drawable drawable); +SPINE_C_EXPORT spine_animation_state spine_skeleton_drawable_get_animation_state(spine_skeleton_drawable drawable); +SPINE_C_EXPORT spine_animation_state_data spine_skeleton_drawable_get_animation_state_data(spine_skeleton_drawable drawable); +SPINE_C_EXPORT spine_animation_state_events spine_skeleton_drawable_get_animation_state_events(spine_skeleton_drawable drawable); + +// Render command functions +SPINE_C_EXPORT float *spine_render_command_get_positions(spine_render_command command); +SPINE_C_EXPORT float *spine_render_command_get_uvs(spine_render_command command); +SPINE_C_EXPORT int32_t *spine_render_command_get_colors(spine_render_command command); +SPINE_C_EXPORT int32_t *spine_render_command_get_dark_colors(spine_render_command command); +SPINE_C_EXPORT int32_t spine_render_command_get_num_vertices(spine_render_command command); +SPINE_C_EXPORT uint16_t *spine_render_command_get_indices(spine_render_command command); +SPINE_C_EXPORT int32_t spine_render_command_get_num_indices(spine_render_command command); +SPINE_C_EXPORT int32_t spine_render_command_get_atlas_page(spine_render_command command); + +// Forward declaration for spine_blend_mode enum +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; + +// Forward declarations for other enum types used in generated headers +typedef enum spine_mix_blend spine_mix_blend; +typedef enum spine_mix_direction spine_mix_direction; + +SPINE_C_EXPORT spine_blend_mode spine_render_command_get_blend_mode(spine_render_command command); +SPINE_C_EXPORT spine_render_command spine_render_command_get_next(spine_render_command command); + +// Skin entries - these need forward declarations +struct spine_attachment_wrapper; +typedef struct spine_attachment_wrapper *spine_attachment; + +SPINE_C_EXPORT spine_skin_entries spine_skin_entries_create(); +SPINE_C_EXPORT void spine_skin_entries_dispose(spine_skin_entries entries); +SPINE_C_EXPORT int32_t spine_skin_entries_get_num_entries(spine_skin_entries entries); +SPINE_C_EXPORT spine_skin_entry spine_skin_entries_get_entry(spine_skin_entries entries, int32_t index); + +SPINE_C_EXPORT int32_t spine_skin_entry_get_slot_index(spine_skin_entry entry); +SPINE_C_EXPORT const utf8 *spine_skin_entry_get_name(spine_skin_entry entry); +SPINE_C_EXPORT spine_attachment spine_skin_entry_get_attachment(spine_skin_entry entry); + +#endif // SPINE_C_NEW_CUSTOM_H \ No newline at end of file diff --git a/spine-c-new/src/generated/alpha_timeline.cpp b/spine-c-new/src/generated/alpha_timeline.cpp new file mode 100644 index 000000000..a8b50040c --- /dev/null +++ b/spine-c-new/src/generated/alpha_timeline.cpp @@ -0,0 +1,103 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#include "alpha_timeline.h" +#include + +using namespace spine; + +spine_alpha_timeline spine_alpha_timeline_create(spine_size_t frameCount, spine_size_t bezierCount, int32_t slotIndex) { + AlphaTimeline *obj = new (__FILE__, __LINE__) AlphaTimeline(frameCount, bezierCount, slotIndex); + return (spine_alpha_timeline) obj; +} + +void spine_alpha_timeline_dispose(spine_alpha_timeline obj) { + if (!obj) return; + delete (AlphaTimeline *) obj; +} + +spine_rtti spine_alpha_timeline_get_rtti(spine_alpha_timeline obj) { + if (!obj) return nullptr; + AlphaTimeline *_obj = (AlphaTimeline *) obj; + return (spine_rtti) &_obj->getRTTI(); +} + +void spine_alpha_timeline_apply(spine_alpha_timeline obj, spine_skeleton skeleton, float lastTime, float time, void * pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction, spine_bool appliedPose) { + if (!obj) return ; + AlphaTimeline *_obj = (AlphaTimeline *) obj; + _obj->apply(skeleton, lastTime, time, (Vector *) pEvents, alpha, blend, direction, appliedPose); +} + +void spine_alpha_timeline_set_frame(spine_alpha_timeline obj, spine_size_t frame, float time, float value) { + if (!obj) return ; + AlphaTimeline *_obj = (AlphaTimeline *) obj; + _obj->setFrame(frame, time, value); +} + +float spine_alpha_timeline_get_curve_value(spine_alpha_timeline obj, float time) { + if (!obj) return 0; + AlphaTimeline *_obj = (AlphaTimeline *) obj; + return _obj->getCurveValue(time); +} + +float spine_alpha_timeline_get_relative_value(spine_alpha_timeline obj, float time, float alpha, spine_mix_blend blend, float current, float setup) { + if (!obj) return 0; + AlphaTimeline *_obj = (AlphaTimeline *) obj; + return _obj->getRelativeValue(time, alpha, blend, current, setup); +} + +float spine_alpha_timeline_get_absolute_value(spine_alpha_timeline obj, float time, float alpha, spine_mix_blend blend, float current, float setup) { + if (!obj) return 0; + AlphaTimeline *_obj = (AlphaTimeline *) obj; + return _obj->getAbsoluteValue(time, alpha, blend, current, setup); +} + +float spine_alpha_timeline_get_absolute_value(spine_alpha_timeline obj, float time, float alpha, spine_mix_blend blend, float current, float setup, float value) { + if (!obj) return 0; + AlphaTimeline *_obj = (AlphaTimeline *) obj; + return _obj->getAbsoluteValue(time, alpha, blend, current, setup, value); +} + +float spine_alpha_timeline_get_scale_value(spine_alpha_timeline obj, float time, float alpha, spine_mix_blend blend, spine_mix_direction direction, float current, float setup) { + if (!obj) return 0; + AlphaTimeline *_obj = (AlphaTimeline *) obj; + return _obj->getScaleValue(time, alpha, blend, direction, current, setup); +} + +int32_t spine_alpha_timeline_get_slot_index(spine_alpha_timeline obj) { + if (!obj) return 0; + AlphaTimeline *_obj = (AlphaTimeline *) obj; + return _obj->getSlotIndex(); +} + +void spine_alpha_timeline_set_slot_index(spine_alpha_timeline obj, int32_t value) { + if (!obj) return; + AlphaTimeline *_obj = (AlphaTimeline *) obj; + _obj->setSlotIndex(value); +} diff --git a/spine-c-new/src/generated/alpha_timeline.h b/spine-c-new/src/generated/alpha_timeline.h new file mode 100644 index 000000000..eef9b0c32 --- /dev/null +++ b/spine-c-new/src/generated/alpha_timeline.h @@ -0,0 +1,58 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#ifndef SPINE_C_ALPHATIMELINE_H +#define SPINE_C_ALPHATIMELINE_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include "../custom.h" + +SPINE_OPAQUE_TYPE(spine_alpha_timeline) + +SPINE_C_EXPORT spine_alpha_timeline spine_alpha_timeline_create(spine_size_t frameCount, spine_size_t bezierCount, int32_t slotIndex); +SPINE_C_EXPORT void spine_alpha_timeline_dispose(spine_alpha_timeline obj); +SPINE_C_EXPORT spine_rtti spine_alpha_timeline_get_rtti(spine_alpha_timeline obj); +SPINE_C_EXPORT void spine_alpha_timeline_apply(spine_alpha_timeline obj, spine_skeleton skeleton, float lastTime, float time, void * pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction, spine_bool appliedPose); +SPINE_C_EXPORT void spine_alpha_timeline_set_frame(spine_alpha_timeline obj, spine_size_t frame, float time, float value); +SPINE_C_EXPORT float spine_alpha_timeline_get_curve_value(spine_alpha_timeline obj, float time); +SPINE_C_EXPORT float spine_alpha_timeline_get_relative_value(spine_alpha_timeline obj, float time, float alpha, spine_mix_blend blend, float current, float setup); +SPINE_C_EXPORT float spine_alpha_timeline_get_absolute_value(spine_alpha_timeline obj, float time, float alpha, spine_mix_blend blend, float current, float setup); +SPINE_C_EXPORT float spine_alpha_timeline_get_absolute_value(spine_alpha_timeline obj, float time, float alpha, spine_mix_blend blend, float current, float setup, float value); +SPINE_C_EXPORT float spine_alpha_timeline_get_scale_value(spine_alpha_timeline obj, float time, float alpha, spine_mix_blend blend, spine_mix_direction direction, float current, float setup); +SPINE_C_EXPORT int32_t spine_alpha_timeline_get_slot_index(spine_alpha_timeline obj); +SPINE_C_EXPORT void spine_alpha_timeline_set_slot_index(spine_alpha_timeline obj, int32_t value); + +#ifdef __cplusplus +} +#endif + +#endif // SPINE_C_ALPHATIMELINE_H \ No newline at end of file diff --git a/spine-c-new/src/generated/animation.cpp b/spine-c-new/src/generated/animation.cpp new file mode 100644 index 000000000..01319a4e2 --- /dev/null +++ b/spine-c-new/src/generated/animation.cpp @@ -0,0 +1,115 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#include "animation.h" +#include + +using namespace spine; + +spine_animation spine_animation_create(const utf8 * name, void * timelines, float duration) { + Animation *obj = new (__FILE__, __LINE__) Animation(String(name), (Vector &) timelines, duration); + return (spine_animation) obj; +} + +void spine_animation_dispose(spine_animation obj) { + if (!obj) return; + delete (Animation *) obj; +} + +void * spine_animation_get_timelines(spine_animation obj) { + if (!obj) return nullptr; + Animation *_obj = (Animation *) obj; + return (void *) _obj->getTimelines(); +} + +int32_t spine_animation_get_num_timelines(spine_animation obj) { + if (!obj) return 0; + Animation *_obj = (Animation *) obj; + return (int32_t) _obj->getTimelines().size(); +} + +spine_timeline *spine_animation_get_timelines(spine_animation obj) { + if (!obj) return nullptr; + Animation *_obj = (Animation *) obj; + return (spine_timeline *) _obj->getTimelines().buffer(); +} + +void spine_animation_set_timelines(spine_animation obj, void * value) { + if (!obj) return; + Animation *_obj = (Animation *) obj; + _obj->setTimelines((Vector &) value); +} + +spine_bool spine_animation_has_timeline(spine_animation obj, void * ids) { + if (!obj) return 0; + Animation *_obj = (Animation *) obj; + return _obj->hasTimeline((Vector &) ids); +} + +float spine_animation_get_duration(spine_animation obj) { + if (!obj) return 0; + Animation *_obj = (Animation *) obj; + return _obj->getDuration(); +} + +void spine_animation_set_duration(spine_animation obj, float value) { + if (!obj) return; + Animation *_obj = (Animation *) obj; + _obj->setDuration(value); +} + +void spine_animation_apply(spine_animation obj, spine_skeleton skeleton, float lastTime, float time, spine_bool loop, void * pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction, spine_bool appliedPose) { + if (!obj) return ; + Animation *_obj = (Animation *) obj; + _obj->apply(skeleton, lastTime, time, loop, (Vector *) pEvents, alpha, blend, direction, appliedPose); +} + +const utf8 * spine_animation_get_name(spine_animation obj) { + if (!obj) return nullptr; + Animation *_obj = (Animation *) obj; + return (const utf8 *) _obj->getName().buffer(); +} + +int32_t * spine_animation_get_bones(spine_animation obj) { + if (!obj) return 0; + Animation *_obj = (Animation *) obj; + return _obj->getBones(); +} + +int32_t spine_animation_get_num_bones(spine_animation obj) { + if (!obj) return 0; + Animation *_obj = (Animation *) obj; + return (int32_t) _obj->getBones().size(); +} + +int32_t *spine_animation_get_bones(spine_animation obj) { + if (!obj) return nullptr; + Animation *_obj = (Animation *) obj; + return (int32_t *) _obj->getBones().buffer(); +} diff --git a/spine-c-new/src/generated/animation.h b/spine-c-new/src/generated/animation.h new file mode 100644 index 000000000..e5aab3f56 --- /dev/null +++ b/spine-c-new/src/generated/animation.h @@ -0,0 +1,60 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#ifndef SPINE_C_ANIMATION_H +#define SPINE_C_ANIMATION_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include "../custom.h" + +SPINE_OPAQUE_TYPE(spine_animation) + +SPINE_C_EXPORT spine_animation spine_animation_create(const utf8 * name, void * timelines, float duration); +SPINE_C_EXPORT void spine_animation_dispose(spine_animation obj); +SPINE_C_EXPORT void * spine_animation_get_timelines(spine_animation obj); +SPINE_C_EXPORT int32_t spine_animation_get_num_timelines(spine_animation obj); +SPINE_C_EXPORT spine_timeline *spine_animation_get_timelines(spine_animation obj); +SPINE_C_EXPORT void spine_animation_set_timelines(spine_animation obj, void * value); +SPINE_C_EXPORT spine_bool spine_animation_has_timeline(spine_animation obj, void * ids); +SPINE_C_EXPORT float spine_animation_get_duration(spine_animation obj); +SPINE_C_EXPORT void spine_animation_set_duration(spine_animation obj, float value); +SPINE_C_EXPORT void spine_animation_apply(spine_animation obj, spine_skeleton skeleton, float lastTime, float time, spine_bool loop, void * pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction, spine_bool appliedPose); +SPINE_C_EXPORT const utf8 * spine_animation_get_name(spine_animation obj); +SPINE_C_EXPORT int32_t * spine_animation_get_bones(spine_animation obj); +SPINE_C_EXPORT int32_t spine_animation_get_num_bones(spine_animation obj); +SPINE_C_EXPORT int32_t *spine_animation_get_bones(spine_animation obj); + +#ifdef __cplusplus +} +#endif + +#endif // SPINE_C_ANIMATION_H \ No newline at end of file diff --git a/spine-c-new/src/generated/animation_state.cpp b/spine-c-new/src/generated/animation_state.cpp new file mode 100644 index 000000000..ca263ba89 --- /dev/null +++ b/spine-c-new/src/generated/animation_state.cpp @@ -0,0 +1,169 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#include "animation_state.h" +#include + +using namespace spine; + +spine_animation_state spine_animation_state_create(spine_animation_state_data data) { + AnimationState *obj = new (__FILE__, __LINE__) AnimationState((AnimationStateData *) data); + return (spine_animation_state) obj; +} + +void spine_animation_state_dispose(spine_animation_state obj) { + if (!obj) return; + delete (AnimationState *) obj; +} + +void spine_animation_state_update(spine_animation_state obj, float delta) { + if (!obj) return ; + AnimationState *_obj = (AnimationState *) obj; + _obj->update(delta); +} + +spine_bool spine_animation_state_apply(spine_animation_state obj, spine_skeleton skeleton) { + if (!obj) return 0; + AnimationState *_obj = (AnimationState *) obj; + return _obj->apply(skeleton); +} + +void spine_animation_state_clear_tracks(spine_animation_state obj) { + if (!obj) return ; + AnimationState *_obj = (AnimationState *) obj; + _obj->clearTracks(); +} + +void spine_animation_state_clear_track(spine_animation_state obj, spine_size_t trackIndex) { + if (!obj) return ; + AnimationState *_obj = (AnimationState *) obj; + _obj->clearTrack(trackIndex); +} + +spine_track_entry spine_animation_state_set_animation(spine_animation_state obj, spine_size_t trackIndex, const utf8 * animationName, spine_bool loop) { + if (!obj) return nullptr; + AnimationState *_obj = (AnimationState *) obj; + return (spine_track_entry) _obj->setAnimation(trackIndex, String(animationName), loop); +} + +spine_track_entry spine_animation_state_set_animation(spine_animation_state obj, spine_size_t trackIndex, spine_animation animation, spine_bool loop) { + if (!obj) return nullptr; + AnimationState *_obj = (AnimationState *) obj; + return (spine_track_entry) _obj->setAnimation(trackIndex, (Animation *) animation, loop); +} + +spine_track_entry spine_animation_state_add_animation(spine_animation_state obj, spine_size_t trackIndex, const utf8 * animationName, spine_bool loop, float delay) { + if (!obj) return nullptr; + AnimationState *_obj = (AnimationState *) obj; + return (spine_track_entry) _obj->addAnimation(trackIndex, String(animationName), loop, delay); +} + +spine_track_entry spine_animation_state_add_animation(spine_animation_state obj, spine_size_t trackIndex, spine_animation animation, spine_bool loop, float delay) { + if (!obj) return nullptr; + AnimationState *_obj = (AnimationState *) obj; + return (spine_track_entry) _obj->addAnimation(trackIndex, (Animation *) animation, loop, delay); +} + +spine_track_entry spine_animation_state_set_empty_animation(spine_animation_state obj, spine_size_t trackIndex, float mixDuration) { + if (!obj) return nullptr; + AnimationState *_obj = (AnimationState *) obj; + return (spine_track_entry) _obj->setEmptyAnimation(trackIndex, mixDuration); +} + +spine_track_entry spine_animation_state_add_empty_animation(spine_animation_state obj, spine_size_t trackIndex, float mixDuration, float delay) { + if (!obj) return nullptr; + AnimationState *_obj = (AnimationState *) obj; + return (spine_track_entry) _obj->addEmptyAnimation(trackIndex, mixDuration, delay); +} + +void spine_animation_state_set_empty_animations(spine_animation_state obj, float value) { + if (!obj) return; + AnimationState *_obj = (AnimationState *) obj; + _obj->setEmptyAnimations(value); +} + +spine_track_entry spine_animation_state_get_current(spine_animation_state obj, spine_size_t trackIndex) { + if (!obj) return nullptr; + AnimationState *_obj = (AnimationState *) obj; + return (spine_track_entry) _obj->getCurrent(trackIndex); +} + +spine_animation_state_data spine_animation_state_get_data(spine_animation_state obj) { + if (!obj) return nullptr; + AnimationState *_obj = (AnimationState *) obj; + return (spine_animation_state_data) _obj->getData(); +} + +void * spine_animation_state_get_tracks(spine_animation_state obj) { + if (!obj) return nullptr; + AnimationState *_obj = (AnimationState *) obj; + return (void *) _obj->getTracks(); +} + +int32_t spine_animation_state_get_num_tracks(spine_animation_state obj) { + if (!obj) return 0; + AnimationState *_obj = (AnimationState *) obj; + return (int32_t) _obj->getTracks().size(); +} + +spine_track_entry *spine_animation_state_get_tracks(spine_animation_state obj) { + if (!obj) return nullptr; + AnimationState *_obj = (AnimationState *) obj; + return (spine_track_entry *) _obj->getTracks().buffer(); +} + +float spine_animation_state_get_time_scale(spine_animation_state obj) { + if (!obj) return 0; + AnimationState *_obj = (AnimationState *) obj; + return _obj->getTimeScale(); +} + +void spine_animation_state_set_time_scale(spine_animation_state obj, float value) { + if (!obj) return; + AnimationState *_obj = (AnimationState *) obj; + _obj->setTimeScale(value); +} + +void spine_animation_state_dispose_track_entry(spine_animation_state obj, spine_track_entry entry) { + if (!obj) return ; + AnimationState *_obj = (AnimationState *) obj; + _obj->disposeTrackEntry((TrackEntry *) entry); +} + +spine_void spine_animation_state_get_renderer_object(spine_animation_state obj) { + if (!obj) return nullptr; + AnimationState *_obj = (AnimationState *) obj; + return (spine_void) _obj->getRendererObject(); +} + +void spine_animation_state_set_renderer_object(spine_animation_state obj, spine_void rendererObject, spine_dispose_renderer_object dispose) { + if (!obj) return ; + AnimationState *_obj = (AnimationState *) obj; + _obj->setRendererObject((void *) rendererObject, dispose); +} diff --git a/spine-c-new/src/generated/animation_state.h b/spine-c-new/src/generated/animation_state.h new file mode 100644 index 000000000..54e29ad29 --- /dev/null +++ b/spine-c-new/src/generated/animation_state.h @@ -0,0 +1,69 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#ifndef SPINE_C_ANIMATIONSTATE_H +#define SPINE_C_ANIMATIONSTATE_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include "../custom.h" + +SPINE_OPAQUE_TYPE(spine_animation_state) + +SPINE_C_EXPORT spine_animation_state spine_animation_state_create(spine_animation_state_data data); +SPINE_C_EXPORT void spine_animation_state_dispose(spine_animation_state obj); +SPINE_C_EXPORT void spine_animation_state_update(spine_animation_state obj, float delta); +SPINE_C_EXPORT spine_bool spine_animation_state_apply(spine_animation_state obj, spine_skeleton skeleton); +SPINE_C_EXPORT void spine_animation_state_clear_tracks(spine_animation_state obj); +SPINE_C_EXPORT void spine_animation_state_clear_track(spine_animation_state obj, spine_size_t trackIndex); +SPINE_C_EXPORT spine_track_entry spine_animation_state_set_animation(spine_animation_state obj, spine_size_t trackIndex, const utf8 * animationName, spine_bool loop); +SPINE_C_EXPORT spine_track_entry spine_animation_state_set_animation(spine_animation_state obj, spine_size_t trackIndex, spine_animation animation, spine_bool loop); +SPINE_C_EXPORT spine_track_entry spine_animation_state_add_animation(spine_animation_state obj, spine_size_t trackIndex, const utf8 * animationName, spine_bool loop, float delay); +SPINE_C_EXPORT spine_track_entry spine_animation_state_add_animation(spine_animation_state obj, spine_size_t trackIndex, spine_animation animation, spine_bool loop, float delay); +SPINE_C_EXPORT spine_track_entry spine_animation_state_set_empty_animation(spine_animation_state obj, spine_size_t trackIndex, float mixDuration); +SPINE_C_EXPORT spine_track_entry spine_animation_state_add_empty_animation(spine_animation_state obj, spine_size_t trackIndex, float mixDuration, float delay); +SPINE_C_EXPORT void spine_animation_state_set_empty_animations(spine_animation_state obj, float value); +SPINE_C_EXPORT spine_track_entry spine_animation_state_get_current(spine_animation_state obj, spine_size_t trackIndex); +SPINE_C_EXPORT spine_animation_state_data spine_animation_state_get_data(spine_animation_state obj); +SPINE_C_EXPORT void * spine_animation_state_get_tracks(spine_animation_state obj); +SPINE_C_EXPORT int32_t spine_animation_state_get_num_tracks(spine_animation_state obj); +SPINE_C_EXPORT spine_track_entry *spine_animation_state_get_tracks(spine_animation_state obj); +SPINE_C_EXPORT float spine_animation_state_get_time_scale(spine_animation_state obj); +SPINE_C_EXPORT void spine_animation_state_set_time_scale(spine_animation_state obj, float value); +SPINE_C_EXPORT void spine_animation_state_dispose_track_entry(spine_animation_state obj, spine_track_entry entry); +SPINE_C_EXPORT spine_void spine_animation_state_get_renderer_object(spine_animation_state obj); +SPINE_C_EXPORT void spine_animation_state_set_renderer_object(spine_animation_state obj, spine_void rendererObject, spine_dispose_renderer_object dispose); + +#ifdef __cplusplus +} +#endif + +#endif // SPINE_C_ANIMATIONSTATE_H \ No newline at end of file diff --git a/spine-c-new/src/generated/animation_state_data.cpp b/spine-c-new/src/generated/animation_state_data.cpp new file mode 100644 index 000000000..d39988f1d --- /dev/null +++ b/spine-c-new/src/generated/animation_state_data.cpp @@ -0,0 +1,85 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#include "animation_state_data.h" +#include + +using namespace spine; + +spine_animation_state_data spine_animation_state_data_create(spine_skeleton_data skeletonData) { + AnimationStateData *obj = new (__FILE__, __LINE__) AnimationStateData((SkeletonData *) skeletonData); + return (spine_animation_state_data) obj; +} + +void spine_animation_state_data_dispose(spine_animation_state_data obj) { + if (!obj) return; + delete (AnimationStateData *) obj; +} + +spine_skeleton_data spine_animation_state_data_get_skeleton_data(spine_animation_state_data obj) { + if (!obj) return nullptr; + AnimationStateData *_obj = (AnimationStateData *) obj; + return (spine_skeleton_data) _obj->getSkeletonData(); +} + +float spine_animation_state_data_get_default_mix(spine_animation_state_data obj) { + if (!obj) return 0; + AnimationStateData *_obj = (AnimationStateData *) obj; + return _obj->getDefaultMix(); +} + +void spine_animation_state_data_set_default_mix(spine_animation_state_data obj, float value) { + if (!obj) return; + AnimationStateData *_obj = (AnimationStateData *) obj; + _obj->setDefaultMix(value); +} + +void spine_animation_state_data_set_mix(spine_animation_state_data obj, const utf8 * fromName, const utf8 * toName, float duration) { + if (!obj) return ; + AnimationStateData *_obj = (AnimationStateData *) obj; + _obj->setMix(String(fromName), String(toName), duration); +} + +void spine_animation_state_data_set_mix(spine_animation_state_data obj, spine_animation from, spine_animation to, float duration) { + if (!obj) return ; + AnimationStateData *_obj = (AnimationStateData *) obj; + _obj->setMix((Animation *) from, (Animation *) to, duration); +} + +float spine_animation_state_data_get_mix(spine_animation_state_data obj, spine_animation from, spine_animation to) { + if (!obj) return 0; + AnimationStateData *_obj = (AnimationStateData *) obj; + return _obj->getMix((Animation *) from, (Animation *) to); +} + +void spine_animation_state_data_clear(spine_animation_state_data obj) { + if (!obj) return ; + AnimationStateData *_obj = (AnimationStateData *) obj; + _obj->clear(); +} diff --git a/spine-c-new/src/generated/animation_state_data.h b/spine-c-new/src/generated/animation_state_data.h new file mode 100644 index 000000000..f0c347a6d --- /dev/null +++ b/spine-c-new/src/generated/animation_state_data.h @@ -0,0 +1,55 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#ifndef SPINE_C_ANIMATIONSTATEDATA_H +#define SPINE_C_ANIMATIONSTATEDATA_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include "../custom.h" + +SPINE_OPAQUE_TYPE(spine_animation_state_data) + +SPINE_C_EXPORT spine_animation_state_data spine_animation_state_data_create(spine_skeleton_data skeletonData); +SPINE_C_EXPORT void spine_animation_state_data_dispose(spine_animation_state_data obj); +SPINE_C_EXPORT spine_skeleton_data spine_animation_state_data_get_skeleton_data(spine_animation_state_data obj); +SPINE_C_EXPORT float spine_animation_state_data_get_default_mix(spine_animation_state_data obj); +SPINE_C_EXPORT void spine_animation_state_data_set_default_mix(spine_animation_state_data obj, float value); +SPINE_C_EXPORT void spine_animation_state_data_set_mix(spine_animation_state_data obj, const utf8 * fromName, const utf8 * toName, float duration); +SPINE_C_EXPORT void spine_animation_state_data_set_mix(spine_animation_state_data obj, spine_animation from, spine_animation to, float duration); +SPINE_C_EXPORT float spine_animation_state_data_get_mix(spine_animation_state_data obj, spine_animation from, spine_animation to); +SPINE_C_EXPORT void spine_animation_state_data_clear(spine_animation_state_data obj); + +#ifdef __cplusplus +} +#endif + +#endif // SPINE_C_ANIMATIONSTATEDATA_H \ No newline at end of file diff --git a/spine-c-new/src/generated/atlas.cpp b/spine-c-new/src/generated/atlas.cpp new file mode 100644 index 000000000..4db4e56dd --- /dev/null +++ b/spine-c-new/src/generated/atlas.cpp @@ -0,0 +1,96 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#include "atlas.h" +#include + +using namespace spine; + +spine_atlas spine_atlas_create(const utf8 * path, spine_texture_loader textureLoader, spine_bool createTexture) { + Atlas *obj = new (__FILE__, __LINE__) Atlas(String(path), (TextureLoader *) textureLoader, createTexture); + return (spine_atlas) obj; +} + +spine_atlas spine_atlas_create_with_string_int_string_texture_loader_bool(const utf8 * data, int32_t length, const utf8 * dir, spine_texture_loader textureLoader, spine_bool createTexture) { + Atlas *obj = new (__FILE__, __LINE__) Atlas((const char *) data, length, (const char *) dir, (TextureLoader *) textureLoader, createTexture); + return (spine_atlas) obj; +} + +void spine_atlas_dispose(spine_atlas obj) { + if (!obj) return; + delete (Atlas *) obj; +} + +void spine_atlas_flip_v(spine_atlas obj) { + if (!obj) return ; + Atlas *_obj = (Atlas *) obj; + _obj->flipV(); +} + +spine_atlas_region spine_atlas_find_region(spine_atlas obj, const utf8 * name) { + if (!obj) return nullptr; + Atlas *_obj = (Atlas *) obj; + return (spine_atlas_region) _obj->findRegion(String(name)); +} + +void * spine_atlas_get_pages(spine_atlas obj) { + if (!obj) return nullptr; + Atlas *_obj = (Atlas *) obj; + return (void *) _obj->getPages(); +} + +int32_t spine_atlas_get_num_pages(spine_atlas obj) { + if (!obj) return 0; + Atlas *_obj = (Atlas *) obj; + return (int32_t) _obj->getPages().size(); +} + +spine_atlas_page *spine_atlas_get_pages(spine_atlas obj) { + if (!obj) return nullptr; + Atlas *_obj = (Atlas *) obj; + return (spine_atlas_page *) _obj->getPages().buffer(); +} + +void * spine_atlas_get_regions(spine_atlas obj) { + if (!obj) return nullptr; + Atlas *_obj = (Atlas *) obj; + return (void *) _obj->getRegions(); +} + +int32_t spine_atlas_get_num_regions(spine_atlas obj) { + if (!obj) return 0; + Atlas *_obj = (Atlas *) obj; + return (int32_t) _obj->getRegions().size(); +} + +spine_atlas_region *spine_atlas_get_regions(spine_atlas obj) { + if (!obj) return nullptr; + Atlas *_obj = (Atlas *) obj; + return (spine_atlas_region *) _obj->getRegions().buffer(); +} diff --git a/spine-c-new/src/generated/atlas.h b/spine-c-new/src/generated/atlas.h new file mode 100644 index 000000000..d194218ab --- /dev/null +++ b/spine-c-new/src/generated/atlas.h @@ -0,0 +1,57 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#ifndef SPINE_C_ATLAS_H +#define SPINE_C_ATLAS_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include "../custom.h" + +SPINE_OPAQUE_TYPE(spine_atlas) + +SPINE_C_EXPORT spine_atlas spine_atlas_create(const utf8 * path, spine_texture_loader textureLoader, spine_bool createTexture); +SPINE_C_EXPORT spine_atlas spine_atlas_create_with_string_int_string_texture_loader_bool(const utf8 * data, int32_t length, const utf8 * dir, spine_texture_loader textureLoader, spine_bool createTexture); +SPINE_C_EXPORT void spine_atlas_dispose(spine_atlas obj); +SPINE_C_EXPORT void spine_atlas_flip_v(spine_atlas obj); +SPINE_C_EXPORT spine_atlas_region spine_atlas_find_region(spine_atlas obj, const utf8 * name); +SPINE_C_EXPORT void * spine_atlas_get_pages(spine_atlas obj); +SPINE_C_EXPORT int32_t spine_atlas_get_num_pages(spine_atlas obj); +SPINE_C_EXPORT spine_atlas_page *spine_atlas_get_pages(spine_atlas obj); +SPINE_C_EXPORT void * spine_atlas_get_regions(spine_atlas obj); +SPINE_C_EXPORT int32_t spine_atlas_get_num_regions(spine_atlas obj); +SPINE_C_EXPORT spine_atlas_region *spine_atlas_get_regions(spine_atlas obj); + +#ifdef __cplusplus +} +#endif + +#endif // SPINE_C_ATLAS_H \ No newline at end of file diff --git a/spine-c-new/src/generated/atlas_attachment_loader.cpp b/spine-c-new/src/generated/atlas_attachment_loader.cpp new file mode 100644 index 000000000..2b51d1c4e --- /dev/null +++ b/spine-c-new/src/generated/atlas_attachment_loader.cpp @@ -0,0 +1,85 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#include "atlas_attachment_loader.h" +#include + +using namespace spine; + +spine_atlas_attachment_loader spine_atlas_attachment_loader_create(spine_atlas atlas) { + AtlasAttachmentLoader *obj = new (__FILE__, __LINE__) AtlasAttachmentLoader((Atlas *) atlas); + return (spine_atlas_attachment_loader) obj; +} + +void spine_atlas_attachment_loader_dispose(spine_atlas_attachment_loader obj) { + if (!obj) return; + delete (AtlasAttachmentLoader *) obj; +} + +spine_region_attachment spine_atlas_attachment_loader_new_region_attachment(spine_atlas_attachment_loader obj, spine_skin skin, const utf8 * name, const utf8 * path, spine_sequence sequence) { + if (!obj) return nullptr; + AtlasAttachmentLoader *_obj = (AtlasAttachmentLoader *) obj; + return (spine_region_attachment) _obj->newRegionAttachment(skin, String(name), String(path), (Sequence *) sequence); +} + +spine_mesh_attachment spine_atlas_attachment_loader_new_mesh_attachment(spine_atlas_attachment_loader obj, spine_skin skin, const utf8 * name, const utf8 * path, spine_sequence sequence) { + if (!obj) return nullptr; + AtlasAttachmentLoader *_obj = (AtlasAttachmentLoader *) obj; + return (spine_mesh_attachment) _obj->newMeshAttachment(skin, String(name), String(path), (Sequence *) sequence); +} + +spine_bounding_box_attachment spine_atlas_attachment_loader_new_bounding_box_attachment(spine_atlas_attachment_loader obj, spine_skin skin, const utf8 * name) { + if (!obj) return nullptr; + AtlasAttachmentLoader *_obj = (AtlasAttachmentLoader *) obj; + return (spine_bounding_box_attachment) _obj->newBoundingBoxAttachment(skin, String(name)); +} + +spine_path_attachment spine_atlas_attachment_loader_new_path_attachment(spine_atlas_attachment_loader obj, spine_skin skin, const utf8 * name) { + if (!obj) return nullptr; + AtlasAttachmentLoader *_obj = (AtlasAttachmentLoader *) obj; + return (spine_path_attachment) _obj->newPathAttachment(skin, String(name)); +} + +spine_point_attachment spine_atlas_attachment_loader_new_point_attachment(spine_atlas_attachment_loader obj, spine_skin skin, const utf8 * name) { + if (!obj) return 0; + AtlasAttachmentLoader *_obj = (AtlasAttachmentLoader *) obj; + return (spine_point_attachment) _obj->newPointAttachment(skin, String(name)); +} + +spine_clipping_attachment spine_atlas_attachment_loader_new_clipping_attachment(spine_atlas_attachment_loader obj, spine_skin skin, const utf8 * name) { + if (!obj) return nullptr; + AtlasAttachmentLoader *_obj = (AtlasAttachmentLoader *) obj; + return (spine_clipping_attachment) _obj->newClippingAttachment(skin, String(name)); +} + +spine_atlas_region spine_atlas_attachment_loader_find_region(spine_atlas_attachment_loader obj, const utf8 * name) { + if (!obj) return nullptr; + AtlasAttachmentLoader *_obj = (AtlasAttachmentLoader *) obj; + return (spine_atlas_region) _obj->findRegion(String(name)); +} diff --git a/spine-c-new/src/generated/atlas_attachment_loader.h b/spine-c-new/src/generated/atlas_attachment_loader.h new file mode 100644 index 000000000..3d91ffd58 --- /dev/null +++ b/spine-c-new/src/generated/atlas_attachment_loader.h @@ -0,0 +1,55 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#ifndef SPINE_C_ATLASATTACHMENTLOADER_H +#define SPINE_C_ATLASATTACHMENTLOADER_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include "../custom.h" + +SPINE_OPAQUE_TYPE(spine_atlas_attachment_loader) + +SPINE_C_EXPORT spine_atlas_attachment_loader spine_atlas_attachment_loader_create(spine_atlas atlas); +SPINE_C_EXPORT void spine_atlas_attachment_loader_dispose(spine_atlas_attachment_loader obj); +SPINE_C_EXPORT spine_region_attachment spine_atlas_attachment_loader_new_region_attachment(spine_atlas_attachment_loader obj, spine_skin skin, const utf8 * name, const utf8 * path, spine_sequence sequence); +SPINE_C_EXPORT spine_mesh_attachment spine_atlas_attachment_loader_new_mesh_attachment(spine_atlas_attachment_loader obj, spine_skin skin, const utf8 * name, const utf8 * path, spine_sequence sequence); +SPINE_C_EXPORT spine_bounding_box_attachment spine_atlas_attachment_loader_new_bounding_box_attachment(spine_atlas_attachment_loader obj, spine_skin skin, const utf8 * name); +SPINE_C_EXPORT spine_path_attachment spine_atlas_attachment_loader_new_path_attachment(spine_atlas_attachment_loader obj, spine_skin skin, const utf8 * name); +SPINE_C_EXPORT spine_point_attachment spine_atlas_attachment_loader_new_point_attachment(spine_atlas_attachment_loader obj, spine_skin skin, const utf8 * name); +SPINE_C_EXPORT spine_clipping_attachment spine_atlas_attachment_loader_new_clipping_attachment(spine_atlas_attachment_loader obj, spine_skin skin, const utf8 * name); +SPINE_C_EXPORT spine_atlas_region spine_atlas_attachment_loader_find_region(spine_atlas_attachment_loader obj, const utf8 * name); + +#ifdef __cplusplus +} +#endif + +#endif // SPINE_C_ATLASATTACHMENTLOADER_H \ No newline at end of file diff --git a/spine-c-new/src/generated/atlas_page.cpp b/spine-c-new/src/generated/atlas_page.cpp new file mode 100644 index 000000000..1b28c9eb0 --- /dev/null +++ b/spine-c-new/src/generated/atlas_page.cpp @@ -0,0 +1,43 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#include "atlas_page.h" +#include + +using namespace spine; + +spine_atlas_page spine_atlas_page_create(const utf8 * inName) { + AtlasPage *obj = new (__FILE__, __LINE__) AtlasPage(String(inName)); + return (spine_atlas_page) obj; +} + +void spine_atlas_page_dispose(spine_atlas_page obj) { + if (!obj) return; + delete (AtlasPage *) obj; +} diff --git a/spine-c-new/src/generated/atlas_page.h b/spine-c-new/src/generated/atlas_page.h new file mode 100644 index 000000000..448db63f5 --- /dev/null +++ b/spine-c-new/src/generated/atlas_page.h @@ -0,0 +1,48 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#ifndef SPINE_C_ATLASPAGE_H +#define SPINE_C_ATLASPAGE_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include "../custom.h" + +SPINE_OPAQUE_TYPE(spine_atlas_page) + +SPINE_C_EXPORT spine_atlas_page spine_atlas_page_create(const utf8 * inName); +SPINE_C_EXPORT void spine_atlas_page_dispose(spine_atlas_page obj); + +#ifdef __cplusplus +} +#endif + +#endif // SPINE_C_ATLASPAGE_H \ No newline at end of file diff --git a/spine-c-new/src/generated/atlas_region.cpp b/spine-c-new/src/generated/atlas_region.cpp new file mode 100644 index 000000000..34f6f9faa --- /dev/null +++ b/spine-c-new/src/generated/atlas_region.cpp @@ -0,0 +1,38 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#include "atlas_region.h" +#include + +using namespace spine; + +void spine_atlas_region_dispose(spine_atlas_region obj) { + if (!obj) return; + delete (AtlasRegion *) obj; +} diff --git a/spine-c-new/src/generated/atlas_region.h b/spine-c-new/src/generated/atlas_region.h new file mode 100644 index 000000000..99243d452 --- /dev/null +++ b/spine-c-new/src/generated/atlas_region.h @@ -0,0 +1,47 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#ifndef SPINE_C_ATLASREGION_H +#define SPINE_C_ATLASREGION_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include "../custom.h" + +SPINE_OPAQUE_TYPE(spine_atlas_region) + +SPINE_C_EXPORT void spine_atlas_region_dispose(spine_atlas_region obj); + +#ifdef __cplusplus +} +#endif + +#endif // SPINE_C_ATLASREGION_H \ No newline at end of file diff --git a/spine-c-new/src/generated/attachment.cpp b/spine-c-new/src/generated/attachment.cpp new file mode 100644 index 000000000..f78e4697d --- /dev/null +++ b/spine-c-new/src/generated/attachment.cpp @@ -0,0 +1,142 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#include "attachment.h" +#include + +using namespace spine; + +spine_attachment spine_attachment_create(const utf8 * name) { + Attachment *obj = new (__FILE__, __LINE__) Attachment(String(name)); + return (spine_attachment) obj; +} + +void spine_attachment_dispose(spine_attachment obj) { + if (!obj) return; + delete (Attachment *) obj; +} + +spine_rtti spine_attachment_get_rtti(spine_attachment obj) { + if (!obj) return nullptr; + Attachment *_obj = (Attachment *) obj; + return (spine_rtti) &_obj->getRTTI(); +} + +const utf8 * spine_attachment_get_name(spine_attachment obj) { + if (!obj) return nullptr; + Attachment *_obj = (Attachment *) obj; + return (const utf8 *) _obj->getName().buffer(); +} + +spine_attachment spine_attachment_copy(spine_attachment obj) { + if (!obj) return nullptr; + Attachment *_obj = (Attachment *) obj; + return (spine_attachment) _obj->copy(); +} + +int32_t spine_attachment_get_ref_count(spine_attachment obj) { + if (!obj) return 0; + Attachment *_obj = (Attachment *) obj; + return _obj->getRefCount(); +} + +void spine_attachment_reference(spine_attachment obj) { + if (!obj) return ; + Attachment *_obj = (Attachment *) obj; + _obj->reference(); +} + +void spine_attachment_dereference(spine_attachment obj) { + if (!obj) return ; + Attachment *_obj = (Attachment *) obj; + _obj->dereference(); +} + +spine_bool spine_attachment_is_type(spine_attachment obj, spine_attachment_type type) { + if (!obj) return 0; + Attachment *_obj = (Attachment *) obj; + + switch (type) { + case SPINE_TYPE_ATTACHMENT_POINT_ATTACHMENT: + return _obj->getRTTI().instanceOf(PointAttachment::rtti); + case SPINE_TYPE_ATTACHMENT_REGION_ATTACHMENT: + return _obj->getRTTI().instanceOf(RegionAttachment::rtti); + case SPINE_TYPE_ATTACHMENT_BOUNDING_BOX_ATTACHMENT: + return _obj->getRTTI().instanceOf(BoundingBoxAttachment::rtti); + case SPINE_TYPE_ATTACHMENT_CLIPPING_ATTACHMENT: + return _obj->getRTTI().instanceOf(ClippingAttachment::rtti); + case SPINE_TYPE_ATTACHMENT_MESH_ATTACHMENT: + return _obj->getRTTI().instanceOf(MeshAttachment::rtti); + case SPINE_TYPE_ATTACHMENT_PATH_ATTACHMENT: + return _obj->getRTTI().instanceOf(PathAttachment::rtti); + } + return 0; +} + +spine_point_attachment spine_attachment_as_point_attachment(spine_attachment obj) { + if (!obj) return nullptr; + Attachment *_obj = (Attachment *) obj; + if (!_obj->getRTTI().instanceOf(PointAttachment::rtti)) return nullptr; + return (spine_point_attachment) obj; +} + +spine_region_attachment spine_attachment_as_region_attachment(spine_attachment obj) { + if (!obj) return nullptr; + Attachment *_obj = (Attachment *) obj; + if (!_obj->getRTTI().instanceOf(RegionAttachment::rtti)) return nullptr; + return (spine_region_attachment) obj; +} + +spine_bounding_box_attachment spine_attachment_as_bounding_box_attachment(spine_attachment obj) { + if (!obj) return nullptr; + Attachment *_obj = (Attachment *) obj; + if (!_obj->getRTTI().instanceOf(BoundingBoxAttachment::rtti)) return nullptr; + return (spine_bounding_box_attachment) obj; +} + +spine_clipping_attachment spine_attachment_as_clipping_attachment(spine_attachment obj) { + if (!obj) return nullptr; + Attachment *_obj = (Attachment *) obj; + if (!_obj->getRTTI().instanceOf(ClippingAttachment::rtti)) return nullptr; + return (spine_clipping_attachment) obj; +} + +spine_mesh_attachment spine_attachment_as_mesh_attachment(spine_attachment obj) { + if (!obj) return nullptr; + Attachment *_obj = (Attachment *) obj; + if (!_obj->getRTTI().instanceOf(MeshAttachment::rtti)) return nullptr; + return (spine_mesh_attachment) obj; +} + +spine_path_attachment spine_attachment_as_path_attachment(spine_attachment obj) { + if (!obj) return nullptr; + Attachment *_obj = (Attachment *) obj; + if (!_obj->getRTTI().instanceOf(PathAttachment::rtti)) return nullptr; + return (spine_path_attachment) obj; +} diff --git a/spine-c-new/src/generated/attachment.h b/spine-c-new/src/generated/attachment.h new file mode 100644 index 000000000..5031da627 --- /dev/null +++ b/spine-c-new/src/generated/attachment.h @@ -0,0 +1,83 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#ifndef SPINE_C_ATTACHMENT_H +#define SPINE_C_ATTACHMENT_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include "../custom.h" + +SPINE_OPAQUE_TYPE(spine_attachment) + +SPINE_C_EXPORT spine_attachment spine_attachment_create(const utf8 * name); +SPINE_C_EXPORT void spine_attachment_dispose(spine_attachment obj); +SPINE_C_EXPORT spine_rtti spine_attachment_get_rtti(spine_attachment obj); +SPINE_C_EXPORT const utf8 * spine_attachment_get_name(spine_attachment obj); +SPINE_C_EXPORT spine_attachment spine_attachment_copy(spine_attachment obj); +SPINE_C_EXPORT int32_t spine_attachment_get_ref_count(spine_attachment obj); +SPINE_C_EXPORT void spine_attachment_reference(spine_attachment obj); +SPINE_C_EXPORT void spine_attachment_dereference(spine_attachment obj); +struct spine_point_attachment_wrapper; +typedef struct spine_point_attachment_wrapper *spine_point_attachment; +struct spine_region_attachment_wrapper; +typedef struct spine_region_attachment_wrapper *spine_region_attachment; +struct spine_bounding_box_attachment_wrapper; +typedef struct spine_bounding_box_attachment_wrapper *spine_bounding_box_attachment; +struct spine_clipping_attachment_wrapper; +typedef struct spine_clipping_attachment_wrapper *spine_clipping_attachment; +struct spine_mesh_attachment_wrapper; +typedef struct spine_mesh_attachment_wrapper *spine_mesh_attachment; +struct spine_path_attachment_wrapper; +typedef struct spine_path_attachment_wrapper *spine_path_attachment; + +typedef enum spine_attachment_type { + SPINE_TYPE_ATTACHMENT_POINT_ATTACHMENT = 0, + SPINE_TYPE_ATTACHMENT_REGION_ATTACHMENT = 1, + SPINE_TYPE_ATTACHMENT_BOUNDING_BOX_ATTACHMENT = 2, + SPINE_TYPE_ATTACHMENT_CLIPPING_ATTACHMENT = 3, + SPINE_TYPE_ATTACHMENT_MESH_ATTACHMENT = 4, + SPINE_TYPE_ATTACHMENT_PATH_ATTACHMENT = 5 +} spine_attachment_type; + +SPINE_C_EXPORT spine_bool spine_attachment_is_type(spine_attachment obj, spine_attachment_type type); +SPINE_C_EXPORT spine_point_attachment spine_attachment_as_point_attachment(spine_attachment obj); +SPINE_C_EXPORT spine_region_attachment spine_attachment_as_region_attachment(spine_attachment obj); +SPINE_C_EXPORT spine_bounding_box_attachment spine_attachment_as_bounding_box_attachment(spine_attachment obj); +SPINE_C_EXPORT spine_clipping_attachment spine_attachment_as_clipping_attachment(spine_attachment obj); +SPINE_C_EXPORT spine_mesh_attachment spine_attachment_as_mesh_attachment(spine_attachment obj); +SPINE_C_EXPORT spine_path_attachment spine_attachment_as_path_attachment(spine_attachment obj); + +#ifdef __cplusplus +} +#endif + +#endif // SPINE_C_ATTACHMENT_H \ No newline at end of file diff --git a/spine-c-new/src/generated/attachment_loader.cpp b/spine-c-new/src/generated/attachment_loader.cpp new file mode 100644 index 000000000..9aa900ac3 --- /dev/null +++ b/spine-c-new/src/generated/attachment_loader.cpp @@ -0,0 +1,79 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#include "attachment_loader.h" +#include + +using namespace spine; + +spine_attachment_loader spine_attachment_loader_create(void) { + AttachmentLoader *obj = new (__FILE__, __LINE__) AttachmentLoader(); + return (spine_attachment_loader) obj; +} + +void spine_attachment_loader_dispose(spine_attachment_loader obj) { + if (!obj) return; + delete (AttachmentLoader *) obj; +} + +spine_region_attachment spine_attachment_loader_new_region_attachment(spine_attachment_loader obj, spine_skin skin, const utf8 * name, const utf8 * path, spine_sequence sequence) { + if (!obj) return nullptr; + AttachmentLoader *_obj = (AttachmentLoader *) obj; + return (spine_region_attachment) _obj->newRegionAttachment(skin, String(name), String(path), (Sequence *) sequence); +} + +spine_mesh_attachment spine_attachment_loader_new_mesh_attachment(spine_attachment_loader obj, spine_skin skin, const utf8 * name, const utf8 * path, spine_sequence sequence) { + if (!obj) return nullptr; + AttachmentLoader *_obj = (AttachmentLoader *) obj; + return (spine_mesh_attachment) _obj->newMeshAttachment(skin, String(name), String(path), (Sequence *) sequence); +} + +spine_bounding_box_attachment spine_attachment_loader_new_bounding_box_attachment(spine_attachment_loader obj, spine_skin skin, const utf8 * name) { + if (!obj) return nullptr; + AttachmentLoader *_obj = (AttachmentLoader *) obj; + return (spine_bounding_box_attachment) _obj->newBoundingBoxAttachment(skin, String(name)); +} + +spine_path_attachment spine_attachment_loader_new_path_attachment(spine_attachment_loader obj, spine_skin skin, const utf8 * name) { + if (!obj) return nullptr; + AttachmentLoader *_obj = (AttachmentLoader *) obj; + return (spine_path_attachment) _obj->newPathAttachment(skin, String(name)); +} + +spine_point_attachment spine_attachment_loader_new_point_attachment(spine_attachment_loader obj, spine_skin skin, const utf8 * name) { + if (!obj) return 0; + AttachmentLoader *_obj = (AttachmentLoader *) obj; + return (spine_point_attachment) _obj->newPointAttachment(skin, String(name)); +} + +spine_clipping_attachment spine_attachment_loader_new_clipping_attachment(spine_attachment_loader obj, spine_skin skin, const utf8 * name) { + if (!obj) return nullptr; + AttachmentLoader *_obj = (AttachmentLoader *) obj; + return (spine_clipping_attachment) _obj->newClippingAttachment(skin, String(name)); +} diff --git a/spine-c-new/src/generated/attachment_loader.h b/spine-c-new/src/generated/attachment_loader.h new file mode 100644 index 000000000..80524df30 --- /dev/null +++ b/spine-c-new/src/generated/attachment_loader.h @@ -0,0 +1,54 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#ifndef SPINE_C_ATTACHMENTLOADER_H +#define SPINE_C_ATTACHMENTLOADER_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include "../custom.h" + +SPINE_OPAQUE_TYPE(spine_attachment_loader) + +SPINE_C_EXPORT spine_attachment_loader spine_attachment_loader_create(void); +SPINE_C_EXPORT void spine_attachment_loader_dispose(spine_attachment_loader obj); +SPINE_C_EXPORT spine_region_attachment spine_attachment_loader_new_region_attachment(spine_attachment_loader obj, spine_skin skin, const utf8 * name, const utf8 * path, spine_sequence sequence); +SPINE_C_EXPORT spine_mesh_attachment spine_attachment_loader_new_mesh_attachment(spine_attachment_loader obj, spine_skin skin, const utf8 * name, const utf8 * path, spine_sequence sequence); +SPINE_C_EXPORT spine_bounding_box_attachment spine_attachment_loader_new_bounding_box_attachment(spine_attachment_loader obj, spine_skin skin, const utf8 * name); +SPINE_C_EXPORT spine_path_attachment spine_attachment_loader_new_path_attachment(spine_attachment_loader obj, spine_skin skin, const utf8 * name); +SPINE_C_EXPORT spine_point_attachment spine_attachment_loader_new_point_attachment(spine_attachment_loader obj, spine_skin skin, const utf8 * name); +SPINE_C_EXPORT spine_clipping_attachment spine_attachment_loader_new_clipping_attachment(spine_attachment_loader obj, spine_skin skin, const utf8 * name); + +#ifdef __cplusplus +} +#endif + +#endif // SPINE_C_ATTACHMENTLOADER_H \ No newline at end of file diff --git a/spine-c-new/src/generated/attachment_timeline.cpp b/spine-c-new/src/generated/attachment_timeline.cpp new file mode 100644 index 000000000..bbe9d9a58 --- /dev/null +++ b/spine-c-new/src/generated/attachment_timeline.cpp @@ -0,0 +1,145 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#include "attachment_timeline.h" +#include + +using namespace spine; + +spine_attachment_timeline spine_attachment_timeline_create(spine_size_t frameCount, int32_t slotIndex) { + AttachmentTimeline *obj = new (__FILE__, __LINE__) AttachmentTimeline(frameCount, slotIndex); + return (spine_attachment_timeline) obj; +} + +void spine_attachment_timeline_dispose(spine_attachment_timeline obj) { + if (!obj) return; + delete (AttachmentTimeline *) obj; +} + +spine_rtti spine_attachment_timeline_get_rtti(spine_attachment_timeline obj) { + if (!obj) return nullptr; + AttachmentTimeline *_obj = (AttachmentTimeline *) obj; + return (spine_rtti) &_obj->getRTTI(); +} + +void spine_attachment_timeline_apply(spine_attachment_timeline obj, spine_skeleton skeleton, float lastTime, float time, void * pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction, spine_bool appliedPose) { + if (!obj) return ; + AttachmentTimeline *_obj = (AttachmentTimeline *) obj; + _obj->apply(skeleton, lastTime, time, (Vector *) pEvents, alpha, blend, direction, appliedPose); +} + +void spine_attachment_timeline_set_frame(spine_attachment_timeline obj, int32_t frame, float time, const utf8 * attachmentName) { + if (!obj) return ; + AttachmentTimeline *_obj = (AttachmentTimeline *) obj; + _obj->setFrame(frame, time, String(attachmentName)); +} + +void * spine_attachment_timeline_get_attachment_names(spine_attachment_timeline obj) { + if (!obj) return nullptr; + AttachmentTimeline *_obj = (AttachmentTimeline *) obj; + return _obj->getAttachmentNames(); +} + +int32_t spine_attachment_timeline_get_num_attachment_names(spine_attachment_timeline obj) { + if (!obj) return 0; + AttachmentTimeline *_obj = (AttachmentTimeline *) obj; + return (int32_t) _obj->getAttachmentNames().size(); +} + +spine_string *spine_attachment_timeline_get_attachment_names(spine_attachment_timeline obj) { + if (!obj) return nullptr; + AttachmentTimeline *_obj = (AttachmentTimeline *) obj; + return (spine_string *) _obj->getAttachmentNames().buffer(); +} + +spine_size_t spine_attachment_timeline_get_frame_entries(spine_attachment_timeline obj) { + if (!obj) return nullptr; + AttachmentTimeline *_obj = (AttachmentTimeline *) obj; + return _obj->getFrameEntries(); +} + +spine_size_t spine_attachment_timeline_get_frame_count(spine_attachment_timeline obj) { + if (!obj) return nullptr; + AttachmentTimeline *_obj = (AttachmentTimeline *) obj; + return _obj->getFrameCount(); +} + +void * spine_attachment_timeline_get_frames(spine_attachment_timeline obj) { + if (!obj) return nullptr; + AttachmentTimeline *_obj = (AttachmentTimeline *) obj; + return _obj->getFrames(); +} + +int32_t spine_attachment_timeline_get_num_frames(spine_attachment_timeline obj) { + if (!obj) return 0; + AttachmentTimeline *_obj = (AttachmentTimeline *) obj; + return (int32_t) _obj->getFrames().size(); +} + +spine_float *spine_attachment_timeline_get_frames(spine_attachment_timeline obj) { + if (!obj) return nullptr; + AttachmentTimeline *_obj = (AttachmentTimeline *) obj; + return (spine_float *) _obj->getFrames().buffer(); +} + +float spine_attachment_timeline_get_duration(spine_attachment_timeline obj) { + if (!obj) return 0; + AttachmentTimeline *_obj = (AttachmentTimeline *) obj; + return _obj->getDuration(); +} + +void * spine_attachment_timeline_get_property_ids(spine_attachment_timeline obj) { + if (!obj) return nullptr; + AttachmentTimeline *_obj = (AttachmentTimeline *) obj; + return _obj->getPropertyIds(); +} + +int32_t spine_attachment_timeline_get_num_property_ids(spine_attachment_timeline obj) { + if (!obj) return 0; + AttachmentTimeline *_obj = (AttachmentTimeline *) obj; + return (int32_t) _obj->getPropertyIds().size(); +} + +spine_property_id *spine_attachment_timeline_get_property_ids(spine_attachment_timeline obj) { + if (!obj) return nullptr; + AttachmentTimeline *_obj = (AttachmentTimeline *) obj; + return (spine_property_id *) _obj->getPropertyIds().buffer(); +} + +int32_t spine_attachment_timeline_get_slot_index(spine_attachment_timeline obj) { + if (!obj) return 0; + AttachmentTimeline *_obj = (AttachmentTimeline *) obj; + return _obj->getSlotIndex(); +} + +void spine_attachment_timeline_set_slot_index(spine_attachment_timeline obj, int32_t value) { + if (!obj) return; + AttachmentTimeline *_obj = (AttachmentTimeline *) obj; + _obj->setSlotIndex(value); +} diff --git a/spine-c-new/src/generated/attachment_timeline.h b/spine-c-new/src/generated/attachment_timeline.h new file mode 100644 index 000000000..cd5dcb399 --- /dev/null +++ b/spine-c-new/src/generated/attachment_timeline.h @@ -0,0 +1,65 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#ifndef SPINE_C_ATTACHMENTTIMELINE_H +#define SPINE_C_ATTACHMENTTIMELINE_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include "../custom.h" + +SPINE_OPAQUE_TYPE(spine_attachment_timeline) + +SPINE_C_EXPORT spine_attachment_timeline spine_attachment_timeline_create(spine_size_t frameCount, int32_t slotIndex); +SPINE_C_EXPORT void spine_attachment_timeline_dispose(spine_attachment_timeline obj); +SPINE_C_EXPORT spine_rtti spine_attachment_timeline_get_rtti(spine_attachment_timeline obj); +SPINE_C_EXPORT void spine_attachment_timeline_apply(spine_attachment_timeline obj, spine_skeleton skeleton, float lastTime, float time, void * pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction, spine_bool appliedPose); +SPINE_C_EXPORT void spine_attachment_timeline_set_frame(spine_attachment_timeline obj, int32_t frame, float time, const utf8 * attachmentName); +SPINE_C_EXPORT void * spine_attachment_timeline_get_attachment_names(spine_attachment_timeline obj); +SPINE_C_EXPORT int32_t spine_attachment_timeline_get_num_attachment_names(spine_attachment_timeline obj); +SPINE_C_EXPORT spine_string *spine_attachment_timeline_get_attachment_names(spine_attachment_timeline obj); +SPINE_C_EXPORT spine_size_t spine_attachment_timeline_get_frame_entries(spine_attachment_timeline obj); +SPINE_C_EXPORT spine_size_t spine_attachment_timeline_get_frame_count(spine_attachment_timeline obj); +SPINE_C_EXPORT void * spine_attachment_timeline_get_frames(spine_attachment_timeline obj); +SPINE_C_EXPORT int32_t spine_attachment_timeline_get_num_frames(spine_attachment_timeline obj); +SPINE_C_EXPORT spine_float *spine_attachment_timeline_get_frames(spine_attachment_timeline obj); +SPINE_C_EXPORT float spine_attachment_timeline_get_duration(spine_attachment_timeline obj); +SPINE_C_EXPORT void * spine_attachment_timeline_get_property_ids(spine_attachment_timeline obj); +SPINE_C_EXPORT int32_t spine_attachment_timeline_get_num_property_ids(spine_attachment_timeline obj); +SPINE_C_EXPORT spine_property_id *spine_attachment_timeline_get_property_ids(spine_attachment_timeline obj); +SPINE_C_EXPORT int32_t spine_attachment_timeline_get_slot_index(spine_attachment_timeline obj); +SPINE_C_EXPORT void spine_attachment_timeline_set_slot_index(spine_attachment_timeline obj, int32_t value); + +#ifdef __cplusplus +} +#endif + +#endif // SPINE_C_ATTACHMENTTIMELINE_H \ No newline at end of file diff --git a/spine-c-new/src/generated/attachment_type.h b/spine-c-new/src/generated/attachment_type.h new file mode 100644 index 000000000..2ccdb81d5 --- /dev/null +++ b/spine-c-new/src/generated/attachment_type.h @@ -0,0 +1,53 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#ifndef SPINE_C_ATTACHMENTTYPE_H +#define SPINE_C_ATTACHMENTTYPE_H + +#include "../../custom.h" + +#ifdef __cplusplus +extern "C" { +#endif + +typedef enum spine_attachment_type { + SPINE_ATTACHMENT_TYPE_ATTACHMENT_TYPE_REGION, + SPINE_ATTACHMENT_TYPE_ATTACHMENT_TYPE_BOUNDINGBOX, + SPINE_ATTACHMENT_TYPE_ATTACHMENT_TYPE_MESH, + SPINE_ATTACHMENT_TYPE_ATTACHMENT_TYPE_LINKEDMESH, + SPINE_ATTACHMENT_TYPE_ATTACHMENT_TYPE_PATH, + SPINE_ATTACHMENT_TYPE_ATTACHMENT_TYPE_POINT, + SPINE_ATTACHMENT_TYPE_ATTACHMENT_TYPE_CLIPPING +} spine_attachment_type; + +#ifdef __cplusplus +} +#endif + +#endif // SPINE_C_ATTACHMENTTYPE_H \ No newline at end of file diff --git a/spine-c-new/src/generated/blend_mode.h b/spine-c-new/src/generated/blend_mode.h new file mode 100644 index 000000000..9db601041 --- /dev/null +++ b/spine-c-new/src/generated/blend_mode.h @@ -0,0 +1,50 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#ifndef SPINE_C_BLENDMODE_H +#define SPINE_C_BLENDMODE_H + +#include "../../custom.h" + +#ifdef __cplusplus +extern "C" { +#endif + +typedef enum spine_blend_mode { + SPINE_BLEND_MODE_BLEND_MODE_NORMAL = 0, + SPINE_BLEND_MODE_BLEND_MODE_ADDITIVE, + SPINE_BLEND_MODE_BLEND_MODE_MULTIPLY, + SPINE_BLEND_MODE_BLEND_MODE_SCREEN +} spine_blend_mode; + +#ifdef __cplusplus +} +#endif + +#endif // SPINE_C_BLENDMODE_H \ No newline at end of file diff --git a/spine-c-new/src/generated/block.cpp b/spine-c-new/src/generated/block.cpp new file mode 100644 index 000000000..ebd9e9cee --- /dev/null +++ b/spine-c-new/src/generated/block.cpp @@ -0,0 +1,56 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#include "block.h" +#include + +using namespace spine; + +void spine_block_dispose(spine_block obj) { + if (!obj) return; + delete (Block *) obj; +} + +int32_t spine_block_free(spine_block obj) { + if (!obj) return 0; + Block *_obj = (Block *) obj; + return _obj->free(); +} + +spine_bool spine_block_can_fit(spine_block obj, int32_t numBytes) { + if (!obj) return 0; + Block *_obj = (Block *) obj; + return _obj->canFit(numBytes); +} + +spine_uint8_t spine_block_allocate(spine_block obj, int32_t numBytes) { + if (!obj) return 0; + Block *_obj = (Block *) obj; + return (spine_uint8_t) _obj->allocate(numBytes); +} diff --git a/spine-c-new/src/generated/block.h b/spine-c-new/src/generated/block.h new file mode 100644 index 000000000..8d70b4d98 --- /dev/null +++ b/spine-c-new/src/generated/block.h @@ -0,0 +1,50 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#ifndef SPINE_C_BLOCK_H +#define SPINE_C_BLOCK_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include "../custom.h" + +SPINE_OPAQUE_TYPE(spine_block) + +SPINE_C_EXPORT void spine_block_dispose(spine_block obj); +SPINE_C_EXPORT int32_t spine_block_free(spine_block obj); +SPINE_C_EXPORT spine_bool spine_block_can_fit(spine_block obj, int32_t numBytes); +SPINE_C_EXPORT spine_uint8_t spine_block_allocate(spine_block obj, int32_t numBytes); + +#ifdef __cplusplus +} +#endif + +#endif // SPINE_C_BLOCK_H \ No newline at end of file diff --git a/spine-c-new/src/generated/bone.cpp b/spine-c-new/src/generated/bone.cpp new file mode 100644 index 000000000..eae6f62d2 --- /dev/null +++ b/spine-c-new/src/generated/bone.cpp @@ -0,0 +1,138 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#include "bone.h" +#include + +using namespace spine; + +spine_bone spine_bone_create(spine_bone_data data, spine_bone parent) { + Bone *obj = new (__FILE__, __LINE__) Bone(data, (Bone *) parent); + return (spine_bone) obj; +} + +spine_bone spine_bone_create_with_bone_bone(spine_bone bone, spine_bone parent) { + Bone *obj = new (__FILE__, __LINE__) Bone(bone, (Bone *) parent); + return (spine_bone) obj; +} + +void spine_bone_dispose(spine_bone obj) { + if (!obj) return; + delete (Bone *) obj; +} + +spine_rtti spine_bone_get_rtti(spine_bone obj) { + if (!obj) return nullptr; + Bone *_obj = (Bone *) obj; + return (spine_rtti) &_obj->getRTTI(); +} + +spine_bone spine_bone_get_parent(spine_bone obj) { + if (!obj) return nullptr; + Bone *_obj = (Bone *) obj; + return (spine_bone) _obj->getParent(); +} + +void * spine_bone_get_children(spine_bone obj) { + if (!obj) return nullptr; + Bone *_obj = (Bone *) obj; + return (void *) _obj->getChildren(); +} + +int32_t spine_bone_get_num_children(spine_bone obj) { + if (!obj) return 0; + Bone *_obj = (Bone *) obj; + return (int32_t) _obj->getChildren().size(); +} + +spine_bone *spine_bone_get_children(spine_bone obj) { + if (!obj) return nullptr; + Bone *_obj = (Bone *) obj; + return (spine_bone *) _obj->getChildren().buffer(); +} + +void spine_bone_setup_pose(spine_bone obj) { + if (!obj) return ; + Bone *_obj = (Bone *) obj; + _obj->setupPose(); +} + +spine_bone_data spine_bone_get_data(spine_bone obj) { + if (!obj) return nullptr; + Bone *_obj = (Bone *) obj; + return _obj->getData(); +} + +spine_bone_local spine_bone_get_pose(spine_bone obj) { + if (!obj) return nullptr; + Bone *_obj = (Bone *) obj; + return _obj->getPose(); +} + +spine_bone_pose spine_bone_get_applied_pose(spine_bone obj) { + if (!obj) return nullptr; + Bone *_obj = (Bone *) obj; + return _obj->getAppliedPose(); +} + +void spine_bone_reset_constrained(spine_bone obj) { + if (!obj) return ; + Bone *_obj = (Bone *) obj; + _obj->resetConstrained(); +} + +void spine_bone_pose(spine_bone obj) { + if (!obj) return ; + Bone *_obj = (Bone *) obj; + _obj->pose(); +} + +void spine_bone_constrained(spine_bone obj) { + if (!obj) return ; + Bone *_obj = (Bone *) obj; + _obj->constrained(); +} + +spine_bool spine_bone_is_pose_equal_to_applied(spine_bone obj) { + if (!obj) return 0; + Bone *_obj = (Bone *) obj; + return _obj->isPoseEqualToApplied(); +} + +spine_bool spine_bone_is_active(spine_bone obj) { + if (!obj) return 0; + Bone *_obj = (Bone *) obj; + return _obj->isActive(); +} + +void spine_bone_set_active(spine_bone obj, spine_bool value) { + if (!obj) return; + Bone *_obj = (Bone *) obj; + _obj->setActive(value); +} diff --git a/spine-c-new/src/generated/bone.h b/spine-c-new/src/generated/bone.h new file mode 100644 index 000000000..e56f56b3b --- /dev/null +++ b/spine-c-new/src/generated/bone.h @@ -0,0 +1,64 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#ifndef SPINE_C_BONE_H +#define SPINE_C_BONE_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include "../custom.h" + +SPINE_OPAQUE_TYPE(spine_bone) + +SPINE_C_EXPORT spine_bone spine_bone_create(spine_bone_data data, spine_bone parent); +SPINE_C_EXPORT spine_bone spine_bone_create_with_bone_bone(spine_bone bone, spine_bone parent); +SPINE_C_EXPORT void spine_bone_dispose(spine_bone obj); +SPINE_C_EXPORT spine_rtti spine_bone_get_rtti(spine_bone obj); +SPINE_C_EXPORT spine_bone spine_bone_get_parent(spine_bone obj); +SPINE_C_EXPORT void * spine_bone_get_children(spine_bone obj); +SPINE_C_EXPORT int32_t spine_bone_get_num_children(spine_bone obj); +SPINE_C_EXPORT spine_bone *spine_bone_get_children(spine_bone obj); +SPINE_C_EXPORT void spine_bone_setup_pose(spine_bone obj); +SPINE_C_EXPORT spine_bone_data spine_bone_get_data(spine_bone obj); +SPINE_C_EXPORT spine_bone_local spine_bone_get_pose(spine_bone obj); +SPINE_C_EXPORT spine_bone_pose spine_bone_get_applied_pose(spine_bone obj); +SPINE_C_EXPORT void spine_bone_reset_constrained(spine_bone obj); +SPINE_C_EXPORT void spine_bone_pose(spine_bone obj); +SPINE_C_EXPORT void spine_bone_constrained(spine_bone obj); +SPINE_C_EXPORT spine_bool spine_bone_is_pose_equal_to_applied(spine_bone obj); +SPINE_C_EXPORT spine_bool spine_bone_is_active(spine_bone obj); +SPINE_C_EXPORT void spine_bone_set_active(spine_bone obj, spine_bool value); + +#ifdef __cplusplus +} +#endif + +#endif // SPINE_C_BONE_H \ No newline at end of file diff --git a/spine-c-new/src/generated/bone_data.cpp b/spine-c-new/src/generated/bone_data.cpp new file mode 100644 index 000000000..1acd51359 --- /dev/null +++ b/spine-c-new/src/generated/bone_data.cpp @@ -0,0 +1,109 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#include "bone_data.h" +#include + +using namespace spine; + +spine_bone_data spine_bone_data_create(int32_t index, const utf8 * name, spine_bone_data parent) { + BoneData *obj = new (__FILE__, __LINE__) BoneData(index, String(name), (BoneData *) parent); + return (spine_bone_data) obj; +} + +void spine_bone_data_dispose(spine_bone_data obj) { + if (!obj) return; + delete (BoneData *) obj; +} + +int32_t spine_bone_data_get_index(spine_bone_data obj) { + if (!obj) return 0; + BoneData *_obj = (BoneData *) obj; + return _obj->getIndex(); +} + +spine_bone_data spine_bone_data_get_parent(spine_bone_data obj) { + if (!obj) return nullptr; + BoneData *_obj = (BoneData *) obj; + return (spine_bone_data) _obj->getParent(); +} + +float spine_bone_data_get_length(spine_bone_data obj) { + if (!obj) return 0; + BoneData *_obj = (BoneData *) obj; + return _obj->getLength(); +} + +void spine_bone_data_set_length(spine_bone_data obj, float value) { + if (!obj) return; + BoneData *_obj = (BoneData *) obj; + _obj->setLength(value); +} + +spine_color spine_bone_data_get_color(spine_bone_data obj) { + if (!obj) return nullptr; + BoneData *_obj = (BoneData *) obj; + return (spine_color) &_obj->getColor(); +} + +const utf8 * spine_bone_data_get_icon(spine_bone_data obj) { + if (!obj) return nullptr; + BoneData *_obj = (BoneData *) obj; + return (const utf8 *) _obj->getIcon().buffer(); +} + +void spine_bone_data_set_icon(spine_bone_data obj, const utf8 * value) { + if (!obj) return; + BoneData *_obj = (BoneData *) obj; + _obj->setIcon(String(value)); +} + +spine_bool spine_bone_data_get_visible(spine_bone_data obj) { + if (!obj) return 0; + BoneData *_obj = (BoneData *) obj; + return _obj->getVisible(); +} + +void spine_bone_data_set_visible(spine_bone_data obj, spine_bool value) { + if (!obj) return; + BoneData *_obj = (BoneData *) obj; + _obj->setVisible(value); +} + +spine_bone_local spine_bone_data_get_setup_pose(spine_bone_data obj) { + if (!obj) return nullptr; + BoneData *_obj = (BoneData *) obj; + return _obj->getSetupPose(); +} + +spine_bone_local spine_bone_data_get_setup_pose(spine_bone_data obj) { + if (!obj) return nullptr; + BoneData *_obj = (BoneData *) obj; + return _obj->getSetupPose(); +} diff --git a/spine-c-new/src/generated/bone_data.h b/spine-c-new/src/generated/bone_data.h new file mode 100644 index 000000000..f24d5e7cd --- /dev/null +++ b/spine-c-new/src/generated/bone_data.h @@ -0,0 +1,59 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#ifndef SPINE_C_BONEDATA_H +#define SPINE_C_BONEDATA_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include "../custom.h" + +SPINE_OPAQUE_TYPE(spine_bone_data) + +SPINE_C_EXPORT spine_bone_data spine_bone_data_create(int32_t index, const utf8 * name, spine_bone_data parent); +SPINE_C_EXPORT void spine_bone_data_dispose(spine_bone_data obj); +SPINE_C_EXPORT int32_t spine_bone_data_get_index(spine_bone_data obj); +SPINE_C_EXPORT spine_bone_data spine_bone_data_get_parent(spine_bone_data obj); +SPINE_C_EXPORT float spine_bone_data_get_length(spine_bone_data obj); +SPINE_C_EXPORT void spine_bone_data_set_length(spine_bone_data obj, float value); +SPINE_C_EXPORT spine_color spine_bone_data_get_color(spine_bone_data obj); +SPINE_C_EXPORT const utf8 * spine_bone_data_get_icon(spine_bone_data obj); +SPINE_C_EXPORT void spine_bone_data_set_icon(spine_bone_data obj, const utf8 * value); +SPINE_C_EXPORT spine_bool spine_bone_data_get_visible(spine_bone_data obj); +SPINE_C_EXPORT void spine_bone_data_set_visible(spine_bone_data obj, spine_bool value); +SPINE_C_EXPORT spine_bone_local spine_bone_data_get_setup_pose(spine_bone_data obj); +SPINE_C_EXPORT spine_bone_local spine_bone_data_get_setup_pose(spine_bone_data obj); + +#ifdef __cplusplus +} +#endif + +#endif // SPINE_C_BONEDATA_H \ No newline at end of file diff --git a/spine-c-new/src/generated/bone_local.cpp b/spine-c-new/src/generated/bone_local.cpp new file mode 100644 index 000000000..2ce8fe320 --- /dev/null +++ b/spine-c-new/src/generated/bone_local.cpp @@ -0,0 +1,163 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#include "bone_local.h" +#include + +using namespace spine; + +spine_bone_local spine_bone_local_create(void) { + BoneLocal *obj = new (__FILE__, __LINE__) BoneLocal(); + return (spine_bone_local) obj; +} + +void spine_bone_local_dispose(spine_bone_local obj) { + if (!obj) return; + delete (BoneLocal *) obj; +} + +void spine_bone_local_set(spine_bone_local obj, spine_bone_local value) { + if (!obj) return; + BoneLocal *_obj = (BoneLocal *) obj; + _obj->set(value); +} + +float spine_bone_local_get_x(spine_bone_local obj) { + if (!obj) return 0; + BoneLocal *_obj = (BoneLocal *) obj; + return _obj->getX(); +} + +void spine_bone_local_set_x(spine_bone_local obj, float value) { + if (!obj) return; + BoneLocal *_obj = (BoneLocal *) obj; + _obj->setX(value); +} + +float spine_bone_local_get_y(spine_bone_local obj) { + if (!obj) return 0; + BoneLocal *_obj = (BoneLocal *) obj; + return _obj->getY(); +} + +void spine_bone_local_set_y(spine_bone_local obj, float value) { + if (!obj) return; + BoneLocal *_obj = (BoneLocal *) obj; + _obj->setY(value); +} + +void spine_bone_local_set_position(spine_bone_local obj, float x, float y) { + if (!obj) return ; + BoneLocal *_obj = (BoneLocal *) obj; + _obj->setPosition(x, y); +} + +float spine_bone_local_get_rotation(spine_bone_local obj) { + if (!obj) return 0; + BoneLocal *_obj = (BoneLocal *) obj; + return _obj->getRotation(); +} + +void spine_bone_local_set_rotation(spine_bone_local obj, float value) { + if (!obj) return; + BoneLocal *_obj = (BoneLocal *) obj; + _obj->setRotation(value); +} + +float spine_bone_local_get_scale_x(spine_bone_local obj) { + if (!obj) return 0; + BoneLocal *_obj = (BoneLocal *) obj; + return _obj->getScaleX(); +} + +void spine_bone_local_set_scale_x(spine_bone_local obj, float value) { + if (!obj) return; + BoneLocal *_obj = (BoneLocal *) obj; + _obj->setScaleX(value); +} + +float spine_bone_local_get_scale_y(spine_bone_local obj) { + if (!obj) return 0; + BoneLocal *_obj = (BoneLocal *) obj; + return _obj->getScaleY(); +} + +void spine_bone_local_set_scale_y(spine_bone_local obj, float value) { + if (!obj) return; + BoneLocal *_obj = (BoneLocal *) obj; + _obj->setScaleY(value); +} + +void spine_bone_local_set_scale(spine_bone_local obj, float scaleX, float scaleY) { + if (!obj) return ; + BoneLocal *_obj = (BoneLocal *) obj; + _obj->setScale(scaleX, scaleY); +} + +void spine_bone_local_set_scale(spine_bone_local obj, float value) { + if (!obj) return; + BoneLocal *_obj = (BoneLocal *) obj; + _obj->setScale(value); +} + +float spine_bone_local_get_shear_x(spine_bone_local obj) { + if (!obj) return 0; + BoneLocal *_obj = (BoneLocal *) obj; + return _obj->getShearX(); +} + +void spine_bone_local_set_shear_x(spine_bone_local obj, float value) { + if (!obj) return; + BoneLocal *_obj = (BoneLocal *) obj; + _obj->setShearX(value); +} + +float spine_bone_local_get_shear_y(spine_bone_local obj) { + if (!obj) return 0; + BoneLocal *_obj = (BoneLocal *) obj; + return _obj->getShearY(); +} + +void spine_bone_local_set_shear_y(spine_bone_local obj, float value) { + if (!obj) return; + BoneLocal *_obj = (BoneLocal *) obj; + _obj->setShearY(value); +} + +spine_inherit spine_bone_local_get_inherit(spine_bone_local obj) { + if (!obj) return nullptr; + BoneLocal *_obj = (BoneLocal *) obj; + return _obj->getInherit(); +} + +void spine_bone_local_set_inherit(spine_bone_local obj, spine_inherit value) { + if (!obj) return; + BoneLocal *_obj = (BoneLocal *) obj; + _obj->setInherit(value); +} diff --git a/spine-c-new/src/generated/bone_local.h b/spine-c-new/src/generated/bone_local.h new file mode 100644 index 000000000..6dcc3319d --- /dev/null +++ b/spine-c-new/src/generated/bone_local.h @@ -0,0 +1,68 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#ifndef SPINE_C_BONELOCAL_H +#define SPINE_C_BONELOCAL_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include "../custom.h" + +SPINE_OPAQUE_TYPE(spine_bone_local) + +SPINE_C_EXPORT spine_bone_local spine_bone_local_create(void); +SPINE_C_EXPORT void spine_bone_local_dispose(spine_bone_local obj); +SPINE_C_EXPORT void spine_bone_local_set(spine_bone_local obj, spine_bone_local value); +SPINE_C_EXPORT float spine_bone_local_get_x(spine_bone_local obj); +SPINE_C_EXPORT void spine_bone_local_set_x(spine_bone_local obj, float value); +SPINE_C_EXPORT float spine_bone_local_get_y(spine_bone_local obj); +SPINE_C_EXPORT void spine_bone_local_set_y(spine_bone_local obj, float value); +SPINE_C_EXPORT void spine_bone_local_set_position(spine_bone_local obj, float x, float y); +SPINE_C_EXPORT float spine_bone_local_get_rotation(spine_bone_local obj); +SPINE_C_EXPORT void spine_bone_local_set_rotation(spine_bone_local obj, float value); +SPINE_C_EXPORT float spine_bone_local_get_scale_x(spine_bone_local obj); +SPINE_C_EXPORT void spine_bone_local_set_scale_x(spine_bone_local obj, float value); +SPINE_C_EXPORT float spine_bone_local_get_scale_y(spine_bone_local obj); +SPINE_C_EXPORT void spine_bone_local_set_scale_y(spine_bone_local obj, float value); +SPINE_C_EXPORT void spine_bone_local_set_scale(spine_bone_local obj, float scaleX, float scaleY); +SPINE_C_EXPORT void spine_bone_local_set_scale(spine_bone_local obj, float value); +SPINE_C_EXPORT float spine_bone_local_get_shear_x(spine_bone_local obj); +SPINE_C_EXPORT void spine_bone_local_set_shear_x(spine_bone_local obj, float value); +SPINE_C_EXPORT float spine_bone_local_get_shear_y(spine_bone_local obj); +SPINE_C_EXPORT void spine_bone_local_set_shear_y(spine_bone_local obj, float value); +SPINE_C_EXPORT spine_inherit spine_bone_local_get_inherit(spine_bone_local obj); +SPINE_C_EXPORT void spine_bone_local_set_inherit(spine_bone_local obj, spine_inherit value); + +#ifdef __cplusplus +} +#endif + +#endif // SPINE_C_BONELOCAL_H \ No newline at end of file diff --git a/spine-c-new/src/generated/bone_pose.cpp b/spine-c-new/src/generated/bone_pose.cpp new file mode 100644 index 000000000..4db4463f1 --- /dev/null +++ b/spine-c-new/src/generated/bone_pose.cpp @@ -0,0 +1,349 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#include "bone_pose.h" +#include + +using namespace spine; + +spine_bone_pose spine_bone_pose_create(void) { + BonePose *obj = new (__FILE__, __LINE__) BonePose(); + return (spine_bone_pose) obj; +} + +void spine_bone_pose_dispose(spine_bone_pose obj) { + if (!obj) return; + delete (BonePose *) obj; +} + +void spine_bone_pose_update(spine_bone_pose obj, spine_skeleton skeleton, spine_physics physics) { + if (!obj) return ; + BonePose *_obj = (BonePose *) obj; + _obj->update(skeleton, physics); +} + +void spine_bone_pose_update_world_transform(spine_bone_pose obj, spine_skeleton skeleton) { + if (!obj) return ; + BonePose *_obj = (BonePose *) obj; + _obj->updateWorldTransform(skeleton); +} + +void spine_bone_pose_update_local_transform(spine_bone_pose obj, spine_skeleton skeleton) { + if (!obj) return ; + BonePose *_obj = (BonePose *) obj; + _obj->updateLocalTransform(skeleton); +} + +void spine_bone_pose_validate_local_transform(spine_bone_pose obj, spine_skeleton skeleton) { + if (!obj) return ; + BonePose *_obj = (BonePose *) obj; + _obj->validateLocalTransform(skeleton); +} + +void spine_bone_pose_modify_local(spine_bone_pose obj, spine_skeleton skeleton) { + if (!obj) return ; + BonePose *_obj = (BonePose *) obj; + _obj->modifyLocal(skeleton); +} + +void spine_bone_pose_modify_world(spine_bone_pose obj, int32_t update) { + if (!obj) return ; + BonePose *_obj = (BonePose *) obj; + _obj->modifyWorld(update); +} + +void spine_bone_pose_reset_world(spine_bone_pose obj, int32_t update) { + if (!obj) return ; + BonePose *_obj = (BonePose *) obj; + _obj->resetWorld(update); +} + +float spine_bone_pose_get_a(spine_bone_pose obj) { + if (!obj) return 0; + BonePose *_obj = (BonePose *) obj; + return _obj->getA(); +} + +void spine_bone_pose_set_a(spine_bone_pose obj, float value) { + if (!obj) return; + BonePose *_obj = (BonePose *) obj; + _obj->setA(value); +} + +float spine_bone_pose_get_b(spine_bone_pose obj) { + if (!obj) return 0; + BonePose *_obj = (BonePose *) obj; + return _obj->getB(); +} + +void spine_bone_pose_set_b(spine_bone_pose obj, float value) { + if (!obj) return; + BonePose *_obj = (BonePose *) obj; + _obj->setB(value); +} + +float spine_bone_pose_get_c(spine_bone_pose obj) { + if (!obj) return 0; + BonePose *_obj = (BonePose *) obj; + return _obj->getC(); +} + +void spine_bone_pose_set_c(spine_bone_pose obj, float value) { + if (!obj) return; + BonePose *_obj = (BonePose *) obj; + _obj->setC(value); +} + +float spine_bone_pose_get_d(spine_bone_pose obj) { + if (!obj) return 0; + BonePose *_obj = (BonePose *) obj; + return _obj->getD(); +} + +void spine_bone_pose_set_d(spine_bone_pose obj, float value) { + if (!obj) return; + BonePose *_obj = (BonePose *) obj; + _obj->setD(value); +} + +float spine_bone_pose_get_world_x(spine_bone_pose obj) { + if (!obj) return 0; + BonePose *_obj = (BonePose *) obj; + return _obj->getWorldX(); +} + +void spine_bone_pose_set_world_x(spine_bone_pose obj, float value) { + if (!obj) return; + BonePose *_obj = (BonePose *) obj; + _obj->setWorldX(value); +} + +float spine_bone_pose_get_world_y(spine_bone_pose obj) { + if (!obj) return 0; + BonePose *_obj = (BonePose *) obj; + return _obj->getWorldY(); +} + +void spine_bone_pose_set_world_y(spine_bone_pose obj, float value) { + if (!obj) return; + BonePose *_obj = (BonePose *) obj; + _obj->setWorldY(value); +} + +float spine_bone_pose_get_world_rotation_x(spine_bone_pose obj) { + if (!obj) return 0; + BonePose *_obj = (BonePose *) obj; + return _obj->getWorldRotationX(); +} + +float spine_bone_pose_get_world_rotation_y(spine_bone_pose obj) { + if (!obj) return 0; + BonePose *_obj = (BonePose *) obj; + return _obj->getWorldRotationY(); +} + +float spine_bone_pose_get_world_scale_x(spine_bone_pose obj) { + if (!obj) return 0; + BonePose *_obj = (BonePose *) obj; + return _obj->getWorldScaleX(); +} + +float spine_bone_pose_get_world_scale_y(spine_bone_pose obj) { + if (!obj) return 0; + BonePose *_obj = (BonePose *) obj; + return _obj->getWorldScaleY(); +} + +void spine_bone_pose_world_to_local(spine_bone_pose obj, float worldX, float worldY, float outLocalX, float outLocalY) { + if (!obj) return ; + BonePose *_obj = (BonePose *) obj; + _obj->worldToLocal(worldX, worldY, outLocalX, outLocalY); +} + +void spine_bone_pose_local_to_world(spine_bone_pose obj, float localX, float localY, float outWorldX, float outWorldY) { + if (!obj) return ; + BonePose *_obj = (BonePose *) obj; + _obj->localToWorld(localX, localY, outWorldX, outWorldY); +} + +void spine_bone_pose_world_to_parent(spine_bone_pose obj, float worldX, float worldY, float outParentX, float outParentY) { + if (!obj) return ; + BonePose *_obj = (BonePose *) obj; + _obj->worldToParent(worldX, worldY, outParentX, outParentY); +} + +void spine_bone_pose_parent_to_world(spine_bone_pose obj, float parentX, float parentY, float outWorldX, float outWorldY) { + if (!obj) return ; + BonePose *_obj = (BonePose *) obj; + _obj->parentToWorld(parentX, parentY, outWorldX, outWorldY); +} + +float spine_bone_pose_world_to_local_rotation(spine_bone_pose obj, float worldRotation) { + if (!obj) return 0; + BonePose *_obj = (BonePose *) obj; + return _obj->worldToLocalRotation(worldRotation); +} + +float spine_bone_pose_local_to_world_rotation(spine_bone_pose obj, float localRotation) { + if (!obj) return 0; + BonePose *_obj = (BonePose *) obj; + return _obj->localToWorldRotation(localRotation); +} + +void spine_bone_pose_rotate_world(spine_bone_pose obj, float degrees) { + if (!obj) return ; + BonePose *_obj = (BonePose *) obj; + _obj->rotateWorld(degrees); +} + +void spine_bone_pose_set(spine_bone_pose obj, spine_bone_local value) { + if (!obj) return; + BonePose *_obj = (BonePose *) obj; + _obj->set(value); +} + +float spine_bone_pose_get_x(spine_bone_pose obj) { + if (!obj) return 0; + BonePose *_obj = (BonePose *) obj; + return _obj->getX(); +} + +void spine_bone_pose_set_x(spine_bone_pose obj, float value) { + if (!obj) return; + BonePose *_obj = (BonePose *) obj; + _obj->setX(value); +} + +float spine_bone_pose_get_y(spine_bone_pose obj) { + if (!obj) return 0; + BonePose *_obj = (BonePose *) obj; + return _obj->getY(); +} + +void spine_bone_pose_set_y(spine_bone_pose obj, float value) { + if (!obj) return; + BonePose *_obj = (BonePose *) obj; + _obj->setY(value); +} + +void spine_bone_pose_set_position(spine_bone_pose obj, float x, float y) { + if (!obj) return ; + BonePose *_obj = (BonePose *) obj; + _obj->setPosition(x, y); +} + +float spine_bone_pose_get_rotation(spine_bone_pose obj) { + if (!obj) return 0; + BonePose *_obj = (BonePose *) obj; + return _obj->getRotation(); +} + +void spine_bone_pose_set_rotation(spine_bone_pose obj, float value) { + if (!obj) return; + BonePose *_obj = (BonePose *) obj; + _obj->setRotation(value); +} + +float spine_bone_pose_get_scale_x(spine_bone_pose obj) { + if (!obj) return 0; + BonePose *_obj = (BonePose *) obj; + return _obj->getScaleX(); +} + +void spine_bone_pose_set_scale_x(spine_bone_pose obj, float value) { + if (!obj) return; + BonePose *_obj = (BonePose *) obj; + _obj->setScaleX(value); +} + +float spine_bone_pose_get_scale_y(spine_bone_pose obj) { + if (!obj) return 0; + BonePose *_obj = (BonePose *) obj; + return _obj->getScaleY(); +} + +void spine_bone_pose_set_scale_y(spine_bone_pose obj, float value) { + if (!obj) return; + BonePose *_obj = (BonePose *) obj; + _obj->setScaleY(value); +} + +void spine_bone_pose_set_scale(spine_bone_pose obj, float scaleX, float scaleY) { + if (!obj) return ; + BonePose *_obj = (BonePose *) obj; + _obj->setScale(scaleX, scaleY); +} + +void spine_bone_pose_set_scale(spine_bone_pose obj, float value) { + if (!obj) return; + BonePose *_obj = (BonePose *) obj; + _obj->setScale(value); +} + +float spine_bone_pose_get_shear_x(spine_bone_pose obj) { + if (!obj) return 0; + BonePose *_obj = (BonePose *) obj; + return _obj->getShearX(); +} + +void spine_bone_pose_set_shear_x(spine_bone_pose obj, float value) { + if (!obj) return; + BonePose *_obj = (BonePose *) obj; + _obj->setShearX(value); +} + +float spine_bone_pose_get_shear_y(spine_bone_pose obj) { + if (!obj) return 0; + BonePose *_obj = (BonePose *) obj; + return _obj->getShearY(); +} + +void spine_bone_pose_set_shear_y(spine_bone_pose obj, float value) { + if (!obj) return; + BonePose *_obj = (BonePose *) obj; + _obj->setShearY(value); +} + +spine_inherit spine_bone_pose_get_inherit(spine_bone_pose obj) { + if (!obj) return nullptr; + BonePose *_obj = (BonePose *) obj; + return _obj->getInherit(); +} + +void spine_bone_pose_set_inherit(spine_bone_pose obj, spine_inherit value) { + if (!obj) return; + BonePose *_obj = (BonePose *) obj; + _obj->setInherit(value); +} + +spine_rtti spine_bone_pose_get_rtti(spine_bone_pose obj) { + if (!obj) return nullptr; + BonePose *_obj = (BonePose *) obj; + return (spine_rtti) &_obj->getRTTI(); +} diff --git a/spine-c-new/src/generated/bone_pose.h b/spine-c-new/src/generated/bone_pose.h new file mode 100644 index 000000000..a9a6a4589 --- /dev/null +++ b/spine-c-new/src/generated/bone_pose.h @@ -0,0 +1,99 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#ifndef SPINE_C_BONEPOSE_H +#define SPINE_C_BONEPOSE_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include "../custom.h" + +SPINE_OPAQUE_TYPE(spine_bone_pose) + +SPINE_C_EXPORT spine_bone_pose spine_bone_pose_create(void); +SPINE_C_EXPORT void spine_bone_pose_dispose(spine_bone_pose obj); +SPINE_C_EXPORT void spine_bone_pose_update(spine_bone_pose obj, spine_skeleton skeleton, spine_physics physics); +SPINE_C_EXPORT void spine_bone_pose_update_world_transform(spine_bone_pose obj, spine_skeleton skeleton); +SPINE_C_EXPORT void spine_bone_pose_update_local_transform(spine_bone_pose obj, spine_skeleton skeleton); +SPINE_C_EXPORT void spine_bone_pose_validate_local_transform(spine_bone_pose obj, spine_skeleton skeleton); +SPINE_C_EXPORT void spine_bone_pose_modify_local(spine_bone_pose obj, spine_skeleton skeleton); +SPINE_C_EXPORT void spine_bone_pose_modify_world(spine_bone_pose obj, int32_t update); +SPINE_C_EXPORT void spine_bone_pose_reset_world(spine_bone_pose obj, int32_t update); +SPINE_C_EXPORT float spine_bone_pose_get_a(spine_bone_pose obj); +SPINE_C_EXPORT void spine_bone_pose_set_a(spine_bone_pose obj, float value); +SPINE_C_EXPORT float spine_bone_pose_get_b(spine_bone_pose obj); +SPINE_C_EXPORT void spine_bone_pose_set_b(spine_bone_pose obj, float value); +SPINE_C_EXPORT float spine_bone_pose_get_c(spine_bone_pose obj); +SPINE_C_EXPORT void spine_bone_pose_set_c(spine_bone_pose obj, float value); +SPINE_C_EXPORT float spine_bone_pose_get_d(spine_bone_pose obj); +SPINE_C_EXPORT void spine_bone_pose_set_d(spine_bone_pose obj, float value); +SPINE_C_EXPORT float spine_bone_pose_get_world_x(spine_bone_pose obj); +SPINE_C_EXPORT void spine_bone_pose_set_world_x(spine_bone_pose obj, float value); +SPINE_C_EXPORT float spine_bone_pose_get_world_y(spine_bone_pose obj); +SPINE_C_EXPORT void spine_bone_pose_set_world_y(spine_bone_pose obj, float value); +SPINE_C_EXPORT float spine_bone_pose_get_world_rotation_x(spine_bone_pose obj); +SPINE_C_EXPORT float spine_bone_pose_get_world_rotation_y(spine_bone_pose obj); +SPINE_C_EXPORT float spine_bone_pose_get_world_scale_x(spine_bone_pose obj); +SPINE_C_EXPORT float spine_bone_pose_get_world_scale_y(spine_bone_pose obj); +SPINE_C_EXPORT void spine_bone_pose_world_to_local(spine_bone_pose obj, float worldX, float worldY, float outLocalX, float outLocalY); +SPINE_C_EXPORT void spine_bone_pose_local_to_world(spine_bone_pose obj, float localX, float localY, float outWorldX, float outWorldY); +SPINE_C_EXPORT void spine_bone_pose_world_to_parent(spine_bone_pose obj, float worldX, float worldY, float outParentX, float outParentY); +SPINE_C_EXPORT void spine_bone_pose_parent_to_world(spine_bone_pose obj, float parentX, float parentY, float outWorldX, float outWorldY); +SPINE_C_EXPORT float spine_bone_pose_world_to_local_rotation(spine_bone_pose obj, float worldRotation); +SPINE_C_EXPORT float spine_bone_pose_local_to_world_rotation(spine_bone_pose obj, float localRotation); +SPINE_C_EXPORT void spine_bone_pose_rotate_world(spine_bone_pose obj, float degrees); +SPINE_C_EXPORT void spine_bone_pose_set(spine_bone_pose obj, spine_bone_local value); +SPINE_C_EXPORT float spine_bone_pose_get_x(spine_bone_pose obj); +SPINE_C_EXPORT void spine_bone_pose_set_x(spine_bone_pose obj, float value); +SPINE_C_EXPORT float spine_bone_pose_get_y(spine_bone_pose obj); +SPINE_C_EXPORT void spine_bone_pose_set_y(spine_bone_pose obj, float value); +SPINE_C_EXPORT void spine_bone_pose_set_position(spine_bone_pose obj, float x, float y); +SPINE_C_EXPORT float spine_bone_pose_get_rotation(spine_bone_pose obj); +SPINE_C_EXPORT void spine_bone_pose_set_rotation(spine_bone_pose obj, float value); +SPINE_C_EXPORT float spine_bone_pose_get_scale_x(spine_bone_pose obj); +SPINE_C_EXPORT void spine_bone_pose_set_scale_x(spine_bone_pose obj, float value); +SPINE_C_EXPORT float spine_bone_pose_get_scale_y(spine_bone_pose obj); +SPINE_C_EXPORT void spine_bone_pose_set_scale_y(spine_bone_pose obj, float value); +SPINE_C_EXPORT void spine_bone_pose_set_scale(spine_bone_pose obj, float scaleX, float scaleY); +SPINE_C_EXPORT void spine_bone_pose_set_scale(spine_bone_pose obj, float value); +SPINE_C_EXPORT float spine_bone_pose_get_shear_x(spine_bone_pose obj); +SPINE_C_EXPORT void spine_bone_pose_set_shear_x(spine_bone_pose obj, float value); +SPINE_C_EXPORT float spine_bone_pose_get_shear_y(spine_bone_pose obj); +SPINE_C_EXPORT void spine_bone_pose_set_shear_y(spine_bone_pose obj, float value); +SPINE_C_EXPORT spine_inherit spine_bone_pose_get_inherit(spine_bone_pose obj); +SPINE_C_EXPORT void spine_bone_pose_set_inherit(spine_bone_pose obj, spine_inherit value); +SPINE_C_EXPORT spine_rtti spine_bone_pose_get_rtti(spine_bone_pose obj); + +#ifdef __cplusplus +} +#endif + +#endif // SPINE_C_BONEPOSE_H \ No newline at end of file diff --git a/spine-c-new/src/generated/bone_timeline.cpp b/spine-c-new/src/generated/bone_timeline.cpp new file mode 100644 index 000000000..5df8f5d07 --- /dev/null +++ b/spine-c-new/src/generated/bone_timeline.cpp @@ -0,0 +1,61 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#include "bone_timeline.h" +#include + +using namespace spine; + +spine_bone_timeline spine_bone_timeline_create(int32_t boneIndex) { + BoneTimeline *obj = new (__FILE__, __LINE__) BoneTimeline(boneIndex); + return (spine_bone_timeline) obj; +} + +void spine_bone_timeline_dispose(spine_bone_timeline obj) { + if (!obj) return; + delete (BoneTimeline *) obj; +} + +spine_rtti spine_bone_timeline_get_rtti(spine_bone_timeline obj) { + if (!obj) return nullptr; + BoneTimeline *_obj = (BoneTimeline *) obj; + return (spine_rtti) &_obj->getRTTI(); +} + +int32_t spine_bone_timeline_get_bone_index(spine_bone_timeline obj) { + if (!obj) return 0; + BoneTimeline *_obj = (BoneTimeline *) obj; + return _obj->getBoneIndex(); +} + +void spine_bone_timeline_set_bone_index(spine_bone_timeline obj, int32_t value) { + if (!obj) return; + BoneTimeline *_obj = (BoneTimeline *) obj; + _obj->setBoneIndex(value); +} diff --git a/spine-c-new/src/generated/bone_timeline.h b/spine-c-new/src/generated/bone_timeline.h new file mode 100644 index 000000000..89023e2e3 --- /dev/null +++ b/spine-c-new/src/generated/bone_timeline.h @@ -0,0 +1,51 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#ifndef SPINE_C_BONETIMELINE_H +#define SPINE_C_BONETIMELINE_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include "../custom.h" + +SPINE_OPAQUE_TYPE(spine_bone_timeline) + +SPINE_C_EXPORT spine_bone_timeline spine_bone_timeline_create(int32_t boneIndex); +SPINE_C_EXPORT void spine_bone_timeline_dispose(spine_bone_timeline obj); +SPINE_C_EXPORT spine_rtti spine_bone_timeline_get_rtti(spine_bone_timeline obj); +SPINE_C_EXPORT int32_t spine_bone_timeline_get_bone_index(spine_bone_timeline obj); +SPINE_C_EXPORT void spine_bone_timeline_set_bone_index(spine_bone_timeline obj, int32_t value); + +#ifdef __cplusplus +} +#endif + +#endif // SPINE_C_BONETIMELINE_H \ No newline at end of file diff --git a/spine-c-new/src/generated/bone_timeline1.cpp b/spine-c-new/src/generated/bone_timeline1.cpp new file mode 100644 index 000000000..fefe46280 --- /dev/null +++ b/spine-c-new/src/generated/bone_timeline1.cpp @@ -0,0 +1,103 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#include "bone_timeline1.h" +#include + +using namespace spine; + +spine_bone_timeline1 spine_bone_timeline1_create(spine_size_t frameCount, spine_size_t bezierCount, int32_t boneIndex, spine_property property) { + BoneTimeline1 *obj = new (__FILE__, __LINE__) BoneTimeline1(frameCount, bezierCount, boneIndex, property); + return (spine_bone_timeline1) obj; +} + +void spine_bone_timeline1_dispose(spine_bone_timeline1 obj) { + if (!obj) return; + delete (BoneTimeline1 *) obj; +} + +spine_rtti spine_bone_timeline1_get_rtti(spine_bone_timeline1 obj) { + if (!obj) return nullptr; + BoneTimeline1 *_obj = (BoneTimeline1 *) obj; + return (spine_rtti) &_obj->getRTTI(); +} + +void spine_bone_timeline1_apply(spine_bone_timeline1 obj, spine_skeleton skeleton, float lastTime, float time, void * pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction, spine_bool appliedPose) { + if (!obj) return ; + BoneTimeline1 *_obj = (BoneTimeline1 *) obj; + _obj->apply(skeleton, lastTime, time, (Vector *) pEvents, alpha, blend, direction, appliedPose); +} + +void spine_bone_timeline1_set_frame(spine_bone_timeline1 obj, spine_size_t frame, float time, float value) { + if (!obj) return ; + BoneTimeline1 *_obj = (BoneTimeline1 *) obj; + _obj->setFrame(frame, time, value); +} + +float spine_bone_timeline1_get_curve_value(spine_bone_timeline1 obj, float time) { + if (!obj) return 0; + BoneTimeline1 *_obj = (BoneTimeline1 *) obj; + return _obj->getCurveValue(time); +} + +float spine_bone_timeline1_get_relative_value(spine_bone_timeline1 obj, float time, float alpha, spine_mix_blend blend, float current, float setup) { + if (!obj) return 0; + BoneTimeline1 *_obj = (BoneTimeline1 *) obj; + return _obj->getRelativeValue(time, alpha, blend, current, setup); +} + +float spine_bone_timeline1_get_absolute_value(spine_bone_timeline1 obj, float time, float alpha, spine_mix_blend blend, float current, float setup) { + if (!obj) return 0; + BoneTimeline1 *_obj = (BoneTimeline1 *) obj; + return _obj->getAbsoluteValue(time, alpha, blend, current, setup); +} + +float spine_bone_timeline1_get_absolute_value(spine_bone_timeline1 obj, float time, float alpha, spine_mix_blend blend, float current, float setup, float value) { + if (!obj) return 0; + BoneTimeline1 *_obj = (BoneTimeline1 *) obj; + return _obj->getAbsoluteValue(time, alpha, blend, current, setup, value); +} + +float spine_bone_timeline1_get_scale_value(spine_bone_timeline1 obj, float time, float alpha, spine_mix_blend blend, spine_mix_direction direction, float current, float setup) { + if (!obj) return 0; + BoneTimeline1 *_obj = (BoneTimeline1 *) obj; + return _obj->getScaleValue(time, alpha, blend, direction, current, setup); +} + +int32_t spine_bone_timeline1_get_bone_index(spine_bone_timeline1 obj) { + if (!obj) return 0; + BoneTimeline1 *_obj = (BoneTimeline1 *) obj; + return _obj->getBoneIndex(); +} + +void spine_bone_timeline1_set_bone_index(spine_bone_timeline1 obj, int32_t value) { + if (!obj) return; + BoneTimeline1 *_obj = (BoneTimeline1 *) obj; + _obj->setBoneIndex(value); +} diff --git a/spine-c-new/src/generated/bone_timeline1.h b/spine-c-new/src/generated/bone_timeline1.h new file mode 100644 index 000000000..01d7c0558 --- /dev/null +++ b/spine-c-new/src/generated/bone_timeline1.h @@ -0,0 +1,58 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#ifndef SPINE_C_BONETIMELINE1_H +#define SPINE_C_BONETIMELINE1_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include "../custom.h" + +SPINE_OPAQUE_TYPE(spine_bone_timeline1) + +SPINE_C_EXPORT spine_bone_timeline1 spine_bone_timeline1_create(spine_size_t frameCount, spine_size_t bezierCount, int32_t boneIndex, spine_property property); +SPINE_C_EXPORT void spine_bone_timeline1_dispose(spine_bone_timeline1 obj); +SPINE_C_EXPORT spine_rtti spine_bone_timeline1_get_rtti(spine_bone_timeline1 obj); +SPINE_C_EXPORT void spine_bone_timeline1_apply(spine_bone_timeline1 obj, spine_skeleton skeleton, float lastTime, float time, void * pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction, spine_bool appliedPose); +SPINE_C_EXPORT void spine_bone_timeline1_set_frame(spine_bone_timeline1 obj, spine_size_t frame, float time, float value); +SPINE_C_EXPORT float spine_bone_timeline1_get_curve_value(spine_bone_timeline1 obj, float time); +SPINE_C_EXPORT float spine_bone_timeline1_get_relative_value(spine_bone_timeline1 obj, float time, float alpha, spine_mix_blend blend, float current, float setup); +SPINE_C_EXPORT float spine_bone_timeline1_get_absolute_value(spine_bone_timeline1 obj, float time, float alpha, spine_mix_blend blend, float current, float setup); +SPINE_C_EXPORT float spine_bone_timeline1_get_absolute_value(spine_bone_timeline1 obj, float time, float alpha, spine_mix_blend blend, float current, float setup, float value); +SPINE_C_EXPORT float spine_bone_timeline1_get_scale_value(spine_bone_timeline1 obj, float time, float alpha, spine_mix_blend blend, spine_mix_direction direction, float current, float setup); +SPINE_C_EXPORT int32_t spine_bone_timeline1_get_bone_index(spine_bone_timeline1 obj); +SPINE_C_EXPORT void spine_bone_timeline1_set_bone_index(spine_bone_timeline1 obj, int32_t value); + +#ifdef __cplusplus +} +#endif + +#endif // SPINE_C_BONETIMELINE1_H \ No newline at end of file diff --git a/spine-c-new/src/generated/bone_timeline2.cpp b/spine-c-new/src/generated/bone_timeline2.cpp new file mode 100644 index 000000000..bc60d8354 --- /dev/null +++ b/spine-c-new/src/generated/bone_timeline2.cpp @@ -0,0 +1,79 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#include "bone_timeline2.h" +#include + +using namespace spine; + +spine_bone_timeline2 spine_bone_timeline2_create(spine_size_t frameCount, spine_size_t bezierCount, int32_t boneIndex, spine_property property1, spine_property property2) { + BoneTimeline2 *obj = new (__FILE__, __LINE__) BoneTimeline2(frameCount, bezierCount, boneIndex, property1, property2); + return (spine_bone_timeline2) obj; +} + +void spine_bone_timeline2_dispose(spine_bone_timeline2 obj) { + if (!obj) return; + delete (BoneTimeline2 *) obj; +} + +spine_rtti spine_bone_timeline2_get_rtti(spine_bone_timeline2 obj) { + if (!obj) return nullptr; + BoneTimeline2 *_obj = (BoneTimeline2 *) obj; + return (spine_rtti) &_obj->getRTTI(); +} + +void spine_bone_timeline2_apply(spine_bone_timeline2 obj, spine_skeleton skeleton, float lastTime, float time, void * pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction, spine_bool appliedPose) { + if (!obj) return ; + BoneTimeline2 *_obj = (BoneTimeline2 *) obj; + _obj->apply(skeleton, lastTime, time, (Vector *) pEvents, alpha, blend, direction, appliedPose); +} + +void spine_bone_timeline2_set_frame(spine_bone_timeline2 obj, spine_size_t frame, float time, float value1, float value2) { + if (!obj) return ; + BoneTimeline2 *_obj = (BoneTimeline2 *) obj; + _obj->setFrame(frame, time, value1, value2); +} + +float spine_bone_timeline2_get_curve_value(spine_bone_timeline2 obj, float time) { + if (!obj) return 0; + BoneTimeline2 *_obj = (BoneTimeline2 *) obj; + return _obj->getCurveValue(time); +} + +int32_t spine_bone_timeline2_get_bone_index(spine_bone_timeline2 obj) { + if (!obj) return 0; + BoneTimeline2 *_obj = (BoneTimeline2 *) obj; + return _obj->getBoneIndex(); +} + +void spine_bone_timeline2_set_bone_index(spine_bone_timeline2 obj, int32_t value) { + if (!obj) return; + BoneTimeline2 *_obj = (BoneTimeline2 *) obj; + _obj->setBoneIndex(value); +} diff --git a/spine-c-new/src/generated/bone_timeline2.h b/spine-c-new/src/generated/bone_timeline2.h new file mode 100644 index 000000000..e064d0b3b --- /dev/null +++ b/spine-c-new/src/generated/bone_timeline2.h @@ -0,0 +1,54 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#ifndef SPINE_C_BONETIMELINE2_H +#define SPINE_C_BONETIMELINE2_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include "../custom.h" + +SPINE_OPAQUE_TYPE(spine_bone_timeline2) + +SPINE_C_EXPORT spine_bone_timeline2 spine_bone_timeline2_create(spine_size_t frameCount, spine_size_t bezierCount, int32_t boneIndex, spine_property property1, spine_property property2); +SPINE_C_EXPORT void spine_bone_timeline2_dispose(spine_bone_timeline2 obj); +SPINE_C_EXPORT spine_rtti spine_bone_timeline2_get_rtti(spine_bone_timeline2 obj); +SPINE_C_EXPORT void spine_bone_timeline2_apply(spine_bone_timeline2 obj, spine_skeleton skeleton, float lastTime, float time, void * pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction, spine_bool appliedPose); +SPINE_C_EXPORT void spine_bone_timeline2_set_frame(spine_bone_timeline2 obj, spine_size_t frame, float time, float value1, float value2); +SPINE_C_EXPORT float spine_bone_timeline2_get_curve_value(spine_bone_timeline2 obj, float time); +SPINE_C_EXPORT int32_t spine_bone_timeline2_get_bone_index(spine_bone_timeline2 obj); +SPINE_C_EXPORT void spine_bone_timeline2_set_bone_index(spine_bone_timeline2 obj, int32_t value); + +#ifdef __cplusplus +} +#endif + +#endif // SPINE_C_BONETIMELINE2_H \ No newline at end of file diff --git a/spine-c-new/src/generated/bounding_box_attachment.cpp b/spine-c-new/src/generated/bounding_box_attachment.cpp new file mode 100644 index 000000000..e2543a738 --- /dev/null +++ b/spine-c-new/src/generated/bounding_box_attachment.cpp @@ -0,0 +1,157 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#include "bounding_box_attachment.h" +#include + +using namespace spine; + +spine_bounding_box_attachment spine_bounding_box_attachment_create(const utf8 * name) { + BoundingBoxAttachment *obj = new (__FILE__, __LINE__) BoundingBoxAttachment(String(name)); + return (spine_bounding_box_attachment) obj; +} + +void spine_bounding_box_attachment_dispose(spine_bounding_box_attachment obj) { + if (!obj) return; + delete (BoundingBoxAttachment *) obj; +} + +spine_rtti spine_bounding_box_attachment_get_rtti(spine_bounding_box_attachment obj) { + if (!obj) return nullptr; + BoundingBoxAttachment *_obj = (BoundingBoxAttachment *) obj; + return (spine_rtti) &_obj->getRTTI(); +} + +spine_color spine_bounding_box_attachment_get_color(spine_bounding_box_attachment obj) { + if (!obj) return nullptr; + BoundingBoxAttachment *_obj = (BoundingBoxAttachment *) obj; + return (spine_color) &_obj->getColor(); +} + +spine_attachment spine_bounding_box_attachment_copy(spine_bounding_box_attachment obj) { + if (!obj) return nullptr; + BoundingBoxAttachment *_obj = (BoundingBoxAttachment *) obj; + return (spine_attachment) _obj->copy(); +} + +void spine_bounding_box_attachment_compute_world_vertices(spine_bounding_box_attachment obj, spine_skeleton skeleton, spine_slot slot, spine_size_t start, spine_size_t count, spine_float worldVertices, spine_size_t offset, spine_size_t stride) { + if (!obj) return ; + BoundingBoxAttachment *_obj = (BoundingBoxAttachment *) obj; + _obj->computeWorldVertices(skeleton, slot, start, count, (float *) worldVertices, offset, stride); +} + +void spine_bounding_box_attachment_compute_world_vertices(spine_bounding_box_attachment obj, spine_skeleton skeleton, spine_slot slot, spine_size_t start, spine_size_t count, void * worldVertices, spine_size_t offset, spine_size_t stride) { + if (!obj) return ; + BoundingBoxAttachment *_obj = (BoundingBoxAttachment *) obj; + _obj->computeWorldVertices(skeleton, slot, start, count, (Vector &) worldVertices, offset, stride); +} + +int32_t spine_bounding_box_attachment_get_id(spine_bounding_box_attachment obj) { + if (!obj) return 0; + BoundingBoxAttachment *_obj = (BoundingBoxAttachment *) obj; + return _obj->getId(); +} + +int32_t * spine_bounding_box_attachment_get_bones(spine_bounding_box_attachment obj) { + if (!obj) return 0; + BoundingBoxAttachment *_obj = (BoundingBoxAttachment *) obj; + return _obj->getBones(); +} + +int32_t spine_bounding_box_attachment_get_num_bones(spine_bounding_box_attachment obj) { + if (!obj) return 0; + BoundingBoxAttachment *_obj = (BoundingBoxAttachment *) obj; + return (int32_t) _obj->getBones().size(); +} + +int32_t *spine_bounding_box_attachment_get_bones(spine_bounding_box_attachment obj) { + if (!obj) return nullptr; + BoundingBoxAttachment *_obj = (BoundingBoxAttachment *) obj; + return (int32_t *) _obj->getBones().buffer(); +} + +void spine_bounding_box_attachment_set_bones(spine_bounding_box_attachment obj, int32_t * value) { + if (!obj) return; + BoundingBoxAttachment *_obj = (BoundingBoxAttachment *) obj; + _obj->setBones((Vector &) value); +} + +void * spine_bounding_box_attachment_get_vertices(spine_bounding_box_attachment obj) { + if (!obj) return nullptr; + BoundingBoxAttachment *_obj = (BoundingBoxAttachment *) obj; + return _obj->getVertices(); +} + +int32_t spine_bounding_box_attachment_get_num_vertices(spine_bounding_box_attachment obj) { + if (!obj) return 0; + BoundingBoxAttachment *_obj = (BoundingBoxAttachment *) obj; + return (int32_t) _obj->getVertices().size(); +} + +spine_float *spine_bounding_box_attachment_get_vertices(spine_bounding_box_attachment obj) { + if (!obj) return nullptr; + BoundingBoxAttachment *_obj = (BoundingBoxAttachment *) obj; + return (spine_float *) _obj->getVertices().buffer(); +} + +void spine_bounding_box_attachment_set_vertices(spine_bounding_box_attachment obj, void * value) { + if (!obj) return; + BoundingBoxAttachment *_obj = (BoundingBoxAttachment *) obj; + _obj->setVertices((Vector &) value); +} + +spine_size_t spine_bounding_box_attachment_get_world_vertices_length(spine_bounding_box_attachment obj) { + if (!obj) return nullptr; + BoundingBoxAttachment *_obj = (BoundingBoxAttachment *) obj; + return _obj->getWorldVerticesLength(); +} + +void spine_bounding_box_attachment_set_world_vertices_length(spine_bounding_box_attachment obj, spine_size_t value) { + if (!obj) return; + BoundingBoxAttachment *_obj = (BoundingBoxAttachment *) obj; + _obj->setWorldVerticesLength(value); +} + +spine_attachment spine_bounding_box_attachment_get_timeline_attachment(spine_bounding_box_attachment obj) { + if (!obj) return nullptr; + BoundingBoxAttachment *_obj = (BoundingBoxAttachment *) obj; + return (spine_attachment) _obj->getTimelineAttachment(); +} + +void spine_bounding_box_attachment_set_timeline_attachment(spine_bounding_box_attachment obj, spine_attachment value) { + if (!obj) return; + BoundingBoxAttachment *_obj = (BoundingBoxAttachment *) obj; + _obj->setTimelineAttachment((Attachment *) value); +} + +void spine_bounding_box_attachment_copy_to(spine_bounding_box_attachment obj, spine_vertex_attachment other) { + if (!obj) return ; + BoundingBoxAttachment *_obj = (BoundingBoxAttachment *) obj; + _obj->copyTo((VertexAttachment *) other); +} diff --git a/spine-c-new/src/generated/bounding_box_attachment.h b/spine-c-new/src/generated/bounding_box_attachment.h new file mode 100644 index 000000000..1af24ef0e --- /dev/null +++ b/spine-c-new/src/generated/bounding_box_attachment.h @@ -0,0 +1,67 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#ifndef SPINE_C_BOUNDINGBOXATTACHMENT_H +#define SPINE_C_BOUNDINGBOXATTACHMENT_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include "../custom.h" + +SPINE_OPAQUE_TYPE(spine_bounding_box_attachment) + +SPINE_C_EXPORT spine_bounding_box_attachment spine_bounding_box_attachment_create(const utf8 * name); +SPINE_C_EXPORT void spine_bounding_box_attachment_dispose(spine_bounding_box_attachment obj); +SPINE_C_EXPORT spine_rtti spine_bounding_box_attachment_get_rtti(spine_bounding_box_attachment obj); +SPINE_C_EXPORT spine_color spine_bounding_box_attachment_get_color(spine_bounding_box_attachment obj); +SPINE_C_EXPORT spine_attachment spine_bounding_box_attachment_copy(spine_bounding_box_attachment obj); +SPINE_C_EXPORT void spine_bounding_box_attachment_compute_world_vertices(spine_bounding_box_attachment obj, spine_skeleton skeleton, spine_slot slot, spine_size_t start, spine_size_t count, spine_float worldVertices, spine_size_t offset, spine_size_t stride); +SPINE_C_EXPORT void spine_bounding_box_attachment_compute_world_vertices(spine_bounding_box_attachment obj, spine_skeleton skeleton, spine_slot slot, spine_size_t start, spine_size_t count, void * worldVertices, spine_size_t offset, spine_size_t stride); +SPINE_C_EXPORT int32_t spine_bounding_box_attachment_get_id(spine_bounding_box_attachment obj); +SPINE_C_EXPORT int32_t * spine_bounding_box_attachment_get_bones(spine_bounding_box_attachment obj); +SPINE_C_EXPORT int32_t spine_bounding_box_attachment_get_num_bones(spine_bounding_box_attachment obj); +SPINE_C_EXPORT int32_t *spine_bounding_box_attachment_get_bones(spine_bounding_box_attachment obj); +SPINE_C_EXPORT void spine_bounding_box_attachment_set_bones(spine_bounding_box_attachment obj, int32_t * value); +SPINE_C_EXPORT void * spine_bounding_box_attachment_get_vertices(spine_bounding_box_attachment obj); +SPINE_C_EXPORT int32_t spine_bounding_box_attachment_get_num_vertices(spine_bounding_box_attachment obj); +SPINE_C_EXPORT spine_float *spine_bounding_box_attachment_get_vertices(spine_bounding_box_attachment obj); +SPINE_C_EXPORT void spine_bounding_box_attachment_set_vertices(spine_bounding_box_attachment obj, void * value); +SPINE_C_EXPORT spine_size_t spine_bounding_box_attachment_get_world_vertices_length(spine_bounding_box_attachment obj); +SPINE_C_EXPORT void spine_bounding_box_attachment_set_world_vertices_length(spine_bounding_box_attachment obj, spine_size_t value); +SPINE_C_EXPORT spine_attachment spine_bounding_box_attachment_get_timeline_attachment(spine_bounding_box_attachment obj); +SPINE_C_EXPORT void spine_bounding_box_attachment_set_timeline_attachment(spine_bounding_box_attachment obj, spine_attachment value); +SPINE_C_EXPORT void spine_bounding_box_attachment_copy_to(spine_bounding_box_attachment obj, spine_vertex_attachment other); + +#ifdef __cplusplus +} +#endif + +#endif // SPINE_C_BOUNDINGBOXATTACHMENT_H \ No newline at end of file diff --git a/spine-c-new/src/generated/clipping_attachment.cpp b/spine-c-new/src/generated/clipping_attachment.cpp new file mode 100644 index 000000000..516ae8dd5 --- /dev/null +++ b/spine-c-new/src/generated/clipping_attachment.cpp @@ -0,0 +1,169 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#include "clipping_attachment.h" +#include + +using namespace spine; + +spine_clipping_attachment spine_clipping_attachment_create(const utf8 * name) { + ClippingAttachment *obj = new (__FILE__, __LINE__) ClippingAttachment(String(name)); + return (spine_clipping_attachment) obj; +} + +void spine_clipping_attachment_dispose(spine_clipping_attachment obj) { + if (!obj) return; + delete (ClippingAttachment *) obj; +} + +spine_rtti spine_clipping_attachment_get_rtti(spine_clipping_attachment obj) { + if (!obj) return nullptr; + ClippingAttachment *_obj = (ClippingAttachment *) obj; + return (spine_rtti) &_obj->getRTTI(); +} + +spine_slot_data spine_clipping_attachment_get_end_slot(spine_clipping_attachment obj) { + if (!obj) return nullptr; + ClippingAttachment *_obj = (ClippingAttachment *) obj; + return (spine_slot_data) _obj->getEndSlot(); +} + +void spine_clipping_attachment_set_end_slot(spine_clipping_attachment obj, spine_slot_data value) { + if (!obj) return; + ClippingAttachment *_obj = (ClippingAttachment *) obj; + _obj->setEndSlot((SlotData *) value); +} + +spine_color spine_clipping_attachment_get_color(spine_clipping_attachment obj) { + if (!obj) return nullptr; + ClippingAttachment *_obj = (ClippingAttachment *) obj; + return (spine_color) &_obj->getColor(); +} + +spine_attachment spine_clipping_attachment_copy(spine_clipping_attachment obj) { + if (!obj) return nullptr; + ClippingAttachment *_obj = (ClippingAttachment *) obj; + return (spine_attachment) _obj->copy(); +} + +void spine_clipping_attachment_compute_world_vertices(spine_clipping_attachment obj, spine_skeleton skeleton, spine_slot slot, spine_size_t start, spine_size_t count, spine_float worldVertices, spine_size_t offset, spine_size_t stride) { + if (!obj) return ; + ClippingAttachment *_obj = (ClippingAttachment *) obj; + _obj->computeWorldVertices(skeleton, slot, start, count, (float *) worldVertices, offset, stride); +} + +void spine_clipping_attachment_compute_world_vertices(spine_clipping_attachment obj, spine_skeleton skeleton, spine_slot slot, spine_size_t start, spine_size_t count, void * worldVertices, spine_size_t offset, spine_size_t stride) { + if (!obj) return ; + ClippingAttachment *_obj = (ClippingAttachment *) obj; + _obj->computeWorldVertices(skeleton, slot, start, count, (Vector &) worldVertices, offset, stride); +} + +int32_t spine_clipping_attachment_get_id(spine_clipping_attachment obj) { + if (!obj) return 0; + ClippingAttachment *_obj = (ClippingAttachment *) obj; + return _obj->getId(); +} + +int32_t * spine_clipping_attachment_get_bones(spine_clipping_attachment obj) { + if (!obj) return 0; + ClippingAttachment *_obj = (ClippingAttachment *) obj; + return _obj->getBones(); +} + +int32_t spine_clipping_attachment_get_num_bones(spine_clipping_attachment obj) { + if (!obj) return 0; + ClippingAttachment *_obj = (ClippingAttachment *) obj; + return (int32_t) _obj->getBones().size(); +} + +int32_t *spine_clipping_attachment_get_bones(spine_clipping_attachment obj) { + if (!obj) return nullptr; + ClippingAttachment *_obj = (ClippingAttachment *) obj; + return (int32_t *) _obj->getBones().buffer(); +} + +void spine_clipping_attachment_set_bones(spine_clipping_attachment obj, int32_t * value) { + if (!obj) return; + ClippingAttachment *_obj = (ClippingAttachment *) obj; + _obj->setBones((Vector &) value); +} + +void * spine_clipping_attachment_get_vertices(spine_clipping_attachment obj) { + if (!obj) return nullptr; + ClippingAttachment *_obj = (ClippingAttachment *) obj; + return _obj->getVertices(); +} + +int32_t spine_clipping_attachment_get_num_vertices(spine_clipping_attachment obj) { + if (!obj) return 0; + ClippingAttachment *_obj = (ClippingAttachment *) obj; + return (int32_t) _obj->getVertices().size(); +} + +spine_float *spine_clipping_attachment_get_vertices(spine_clipping_attachment obj) { + if (!obj) return nullptr; + ClippingAttachment *_obj = (ClippingAttachment *) obj; + return (spine_float *) _obj->getVertices().buffer(); +} + +void spine_clipping_attachment_set_vertices(spine_clipping_attachment obj, void * value) { + if (!obj) return; + ClippingAttachment *_obj = (ClippingAttachment *) obj; + _obj->setVertices((Vector &) value); +} + +spine_size_t spine_clipping_attachment_get_world_vertices_length(spine_clipping_attachment obj) { + if (!obj) return nullptr; + ClippingAttachment *_obj = (ClippingAttachment *) obj; + return _obj->getWorldVerticesLength(); +} + +void spine_clipping_attachment_set_world_vertices_length(spine_clipping_attachment obj, spine_size_t value) { + if (!obj) return; + ClippingAttachment *_obj = (ClippingAttachment *) obj; + _obj->setWorldVerticesLength(value); +} + +spine_attachment spine_clipping_attachment_get_timeline_attachment(spine_clipping_attachment obj) { + if (!obj) return nullptr; + ClippingAttachment *_obj = (ClippingAttachment *) obj; + return (spine_attachment) _obj->getTimelineAttachment(); +} + +void spine_clipping_attachment_set_timeline_attachment(spine_clipping_attachment obj, spine_attachment value) { + if (!obj) return; + ClippingAttachment *_obj = (ClippingAttachment *) obj; + _obj->setTimelineAttachment((Attachment *) value); +} + +void spine_clipping_attachment_copy_to(spine_clipping_attachment obj, spine_vertex_attachment other) { + if (!obj) return ; + ClippingAttachment *_obj = (ClippingAttachment *) obj; + _obj->copyTo((VertexAttachment *) other); +} diff --git a/spine-c-new/src/generated/clipping_attachment.h b/spine-c-new/src/generated/clipping_attachment.h new file mode 100644 index 000000000..00179de12 --- /dev/null +++ b/spine-c-new/src/generated/clipping_attachment.h @@ -0,0 +1,69 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#ifndef SPINE_C_CLIPPINGATTACHMENT_H +#define SPINE_C_CLIPPINGATTACHMENT_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include "../custom.h" + +SPINE_OPAQUE_TYPE(spine_clipping_attachment) + +SPINE_C_EXPORT spine_clipping_attachment spine_clipping_attachment_create(const utf8 * name); +SPINE_C_EXPORT void spine_clipping_attachment_dispose(spine_clipping_attachment obj); +SPINE_C_EXPORT spine_rtti spine_clipping_attachment_get_rtti(spine_clipping_attachment obj); +SPINE_C_EXPORT spine_slot_data spine_clipping_attachment_get_end_slot(spine_clipping_attachment obj); +SPINE_C_EXPORT void spine_clipping_attachment_set_end_slot(spine_clipping_attachment obj, spine_slot_data value); +SPINE_C_EXPORT spine_color spine_clipping_attachment_get_color(spine_clipping_attachment obj); +SPINE_C_EXPORT spine_attachment spine_clipping_attachment_copy(spine_clipping_attachment obj); +SPINE_C_EXPORT void spine_clipping_attachment_compute_world_vertices(spine_clipping_attachment obj, spine_skeleton skeleton, spine_slot slot, spine_size_t start, spine_size_t count, spine_float worldVertices, spine_size_t offset, spine_size_t stride); +SPINE_C_EXPORT void spine_clipping_attachment_compute_world_vertices(spine_clipping_attachment obj, spine_skeleton skeleton, spine_slot slot, spine_size_t start, spine_size_t count, void * worldVertices, spine_size_t offset, spine_size_t stride); +SPINE_C_EXPORT int32_t spine_clipping_attachment_get_id(spine_clipping_attachment obj); +SPINE_C_EXPORT int32_t * spine_clipping_attachment_get_bones(spine_clipping_attachment obj); +SPINE_C_EXPORT int32_t spine_clipping_attachment_get_num_bones(spine_clipping_attachment obj); +SPINE_C_EXPORT int32_t *spine_clipping_attachment_get_bones(spine_clipping_attachment obj); +SPINE_C_EXPORT void spine_clipping_attachment_set_bones(spine_clipping_attachment obj, int32_t * value); +SPINE_C_EXPORT void * spine_clipping_attachment_get_vertices(spine_clipping_attachment obj); +SPINE_C_EXPORT int32_t spine_clipping_attachment_get_num_vertices(spine_clipping_attachment obj); +SPINE_C_EXPORT spine_float *spine_clipping_attachment_get_vertices(spine_clipping_attachment obj); +SPINE_C_EXPORT void spine_clipping_attachment_set_vertices(spine_clipping_attachment obj, void * value); +SPINE_C_EXPORT spine_size_t spine_clipping_attachment_get_world_vertices_length(spine_clipping_attachment obj); +SPINE_C_EXPORT void spine_clipping_attachment_set_world_vertices_length(spine_clipping_attachment obj, spine_size_t value); +SPINE_C_EXPORT spine_attachment spine_clipping_attachment_get_timeline_attachment(spine_clipping_attachment obj); +SPINE_C_EXPORT void spine_clipping_attachment_set_timeline_attachment(spine_clipping_attachment obj, spine_attachment value); +SPINE_C_EXPORT void spine_clipping_attachment_copy_to(spine_clipping_attachment obj, spine_vertex_attachment other); + +#ifdef __cplusplus +} +#endif + +#endif // SPINE_C_CLIPPINGATTACHMENT_H \ No newline at end of file diff --git a/spine-c-new/src/generated/color.cpp b/spine-c-new/src/generated/color.cpp new file mode 100644 index 000000000..3127d9096 --- /dev/null +++ b/spine-c-new/src/generated/color.cpp @@ -0,0 +1,90 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#include "color.h" +#include + +using namespace spine; + +spine_color spine_color_create(void) { + Color *obj = new (__FILE__, __LINE__) Color(); + return (spine_color) obj; +} + +spine_color spine_color_create_with_float_float_float_float(float r, float g, float b, float a) { + Color *obj = new (__FILE__, __LINE__) Color(r, g, b, a); + return (spine_color) obj; +} + +void spine_color_dispose(spine_color obj) { + if (!obj) return; + delete (Color *) obj; +} + +spine_color spine_color_set(spine_color obj, float _r, float _g, float _b, float _a) { + if (!obj) return nullptr; + Color *_obj = (Color *) obj; + return (spine_color) &_obj->set(_r, _g, _b, _a); +} + +spine_color spine_color_set(spine_color obj, float _r, float _g, float _b) { + if (!obj) return nullptr; + Color *_obj = (Color *) obj; + return (spine_color) &_obj->set(_r, _g, _b); +} + +void spine_color_set(spine_color obj, spine_color value) { + if (!obj) return; + Color *_obj = (Color *) obj; + _obj->set(value); +} + +spine_color spine_color_add(spine_color obj, float _r, float _g, float _b, float _a) { + if (!obj) return nullptr; + Color *_obj = (Color *) obj; + return (spine_color) &_obj->add(_r, _g, _b, _a); +} + +spine_color spine_color_add(spine_color obj, float _r, float _g, float _b) { + if (!obj) return nullptr; + Color *_obj = (Color *) obj; + return (spine_color) &_obj->add(_r, _g, _b); +} + +spine_color spine_color_add(spine_color obj, spine_color other) { + if (!obj) return nullptr; + Color *_obj = (Color *) obj; + return (spine_color) &_obj->add(other); +} + +spine_color spine_color_clamp(spine_color obj) { + if (!obj) return nullptr; + Color *_obj = (Color *) obj; + return (spine_color) &_obj->clamp(); +} diff --git a/spine-c-new/src/generated/color.h b/spine-c-new/src/generated/color.h new file mode 100644 index 000000000..5c9c0cdc1 --- /dev/null +++ b/spine-c-new/src/generated/color.h @@ -0,0 +1,56 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#ifndef SPINE_C_COLOR_H +#define SPINE_C_COLOR_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include "../custom.h" + +SPINE_OPAQUE_TYPE(spine_color) + +SPINE_C_EXPORT spine_color spine_color_create(void); +SPINE_C_EXPORT spine_color spine_color_create_with_float_float_float_float(float r, float g, float b, float a); +SPINE_C_EXPORT void spine_color_dispose(spine_color obj); +SPINE_C_EXPORT spine_color spine_color_set(spine_color obj, float _r, float _g, float _b, float _a); +SPINE_C_EXPORT spine_color spine_color_set(spine_color obj, float _r, float _g, float _b); +SPINE_C_EXPORT void spine_color_set(spine_color obj, spine_color value); +SPINE_C_EXPORT spine_color spine_color_add(spine_color obj, float _r, float _g, float _b, float _a); +SPINE_C_EXPORT spine_color spine_color_add(spine_color obj, float _r, float _g, float _b); +SPINE_C_EXPORT spine_color spine_color_add(spine_color obj, spine_color other); +SPINE_C_EXPORT spine_color spine_color_clamp(spine_color obj); + +#ifdef __cplusplus +} +#endif + +#endif // SPINE_C_COLOR_H \ No newline at end of file diff --git a/spine-c-new/src/generated/constraint.cpp b/spine-c-new/src/generated/constraint.cpp new file mode 100644 index 000000000..895723aa6 --- /dev/null +++ b/spine-c-new/src/generated/constraint.cpp @@ -0,0 +1,103 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#include "constraint.h" +#include + +using namespace spine; + +spine_constraint spine_constraint_create(void) { + Constraint *obj = new (__FILE__, __LINE__) Constraint(); + return (spine_constraint) obj; +} + +void spine_constraint_dispose(spine_constraint obj) { + if (!obj) return; + delete (Constraint *) obj; +} + +spine_rtti spine_constraint_get_rtti(spine_constraint obj) { + if (!obj) return nullptr; + Constraint *_obj = (Constraint *) obj; + return (spine_rtti) &_obj->getRTTI(); +} + +spine_constraint_data spine_constraint_get_data(spine_constraint obj) { + if (!obj) return 0; + Constraint *_obj = (Constraint *) obj; + return _obj->getData(); +} + +void spine_constraint_sort(spine_constraint obj, spine_skeleton skeleton) { + if (!obj) return ; + Constraint *_obj = (Constraint *) obj; + _obj->sort(skeleton); +} + +spine_bool spine_constraint_is_source_active(spine_constraint obj) { + if (!obj) return 0; + Constraint *_obj = (Constraint *) obj; + return _obj->isSourceActive(); +} + +void spine_constraint_pose(spine_constraint obj) { + if (!obj) return ; + Constraint *_obj = (Constraint *) obj; + _obj->pose(); +} + +void spine_constraint_setup_pose(spine_constraint obj) { + if (!obj) return ; + Constraint *_obj = (Constraint *) obj; + _obj->setupPose(); +} + +void spine_constraint_update(spine_constraint obj, spine_skeleton skeleton, spine_physics physics) { + if (!obj) return ; + Constraint *_obj = (Constraint *) obj; + _obj->update(skeleton, physics); +} + +spine_bool spine_constraint_is_type(spine_constraint obj, spine_constraint_type type) { + if (!obj) return 0; + Constraint *_obj = (Constraint *) obj; + + switch (type) { + case SPINE_TYPE_CONSTRAINT_CONSTRAINT_GENERIC: + return _obj->getRTTI().instanceOf(ConstraintGeneric::rtti); + } + return 0; +} + +spine_constraint_generic spine_constraint_as_constraint_generic(spine_constraint obj) { + if (!obj) return nullptr; + Constraint *_obj = (Constraint *) obj; + if (!_obj->getRTTI().instanceOf(ConstraintGeneric::rtti)) return nullptr; + return (spine_constraint_generic) obj; +} diff --git a/spine-c-new/src/generated/constraint.h b/spine-c-new/src/generated/constraint.h new file mode 100644 index 000000000..2a175bc1e --- /dev/null +++ b/spine-c-new/src/generated/constraint.h @@ -0,0 +1,64 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#ifndef SPINE_C_CONSTRAINT_H +#define SPINE_C_CONSTRAINT_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include "../custom.h" + +SPINE_OPAQUE_TYPE(spine_constraint) + +SPINE_C_EXPORT spine_constraint spine_constraint_create(void); +SPINE_C_EXPORT void spine_constraint_dispose(spine_constraint obj); +SPINE_C_EXPORT spine_rtti spine_constraint_get_rtti(spine_constraint obj); +SPINE_C_EXPORT spine_constraint_data spine_constraint_get_data(spine_constraint obj); +SPINE_C_EXPORT void spine_constraint_sort(spine_constraint obj, spine_skeleton skeleton); +SPINE_C_EXPORT spine_bool spine_constraint_is_source_active(spine_constraint obj); +SPINE_C_EXPORT void spine_constraint_pose(spine_constraint obj); +SPINE_C_EXPORT void spine_constraint_setup_pose(spine_constraint obj); +SPINE_C_EXPORT void spine_constraint_update(spine_constraint obj, spine_skeleton skeleton, spine_physics physics); +struct spine_constraint_generic_wrapper; +typedef struct spine_constraint_generic_wrapper *spine_constraint_generic; + +typedef enum spine_constraint_type { + SPINE_TYPE_CONSTRAINT_CONSTRAINT_GENERIC = 0 +} spine_constraint_type; + +SPINE_C_EXPORT spine_bool spine_constraint_is_type(spine_constraint obj, spine_constraint_type type); +SPINE_C_EXPORT spine_constraint_generic spine_constraint_as_constraint_generic(spine_constraint obj); + +#ifdef __cplusplus +} +#endif + +#endif // SPINE_C_CONSTRAINT_H \ No newline at end of file diff --git a/spine-c-new/src/generated/constraint_data.cpp b/spine-c-new/src/generated/constraint_data.cpp new file mode 100644 index 000000000..a80da8843 --- /dev/null +++ b/spine-c-new/src/generated/constraint_data.cpp @@ -0,0 +1,76 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#include "constraint_data.h" +#include + +using namespace spine; + +spine_constraint_data spine_constraint_data_create(const utf8 * name) { + ConstraintData *obj = new (__FILE__, __LINE__) ConstraintData(String(name)); + return (spine_constraint_data) obj; +} + +void spine_constraint_data_dispose(spine_constraint_data obj) { + if (!obj) return; + delete (ConstraintData *) obj; +} + +spine_rtti spine_constraint_data_get_rtti(spine_constraint_data obj) { + if (!obj) return nullptr; + ConstraintData *_obj = (ConstraintData *) obj; + return (spine_rtti) &_obj->getRTTI(); +} + +spine_constraint spine_constraint_data_create(spine_constraint_data obj, spine_skeleton skeleton) { + if (!obj) return 0; + ConstraintData *_obj = (ConstraintData *) obj; + return (spine_constraint) _obj->create(skeleton); +} + +const utf8 * spine_constraint_data_get_name(spine_constraint_data obj) { + if (!obj) return nullptr; + ConstraintData *_obj = (ConstraintData *) obj; + return (const utf8 *) _obj->getName().buffer(); +} + +spine_bool spine_constraint_data_is_skin_required(spine_constraint_data obj) { + if (!obj) return 0; + ConstraintData *_obj = (ConstraintData *) obj; + return _obj->isSkinRequired(); +} + +spine_bool spine_constraint_data_is_type(spine_constraint_data obj, spine_constraint_data_type type) { + if (!obj) return 0; + ConstraintData *_obj = (ConstraintData *) obj; + + switch (type) { + } + return 0; +} diff --git a/spine-c-new/src/generated/constraint_data.h b/spine-c-new/src/generated/constraint_data.h new file mode 100644 index 000000000..0cb3fd608 --- /dev/null +++ b/spine-c-new/src/generated/constraint_data.h @@ -0,0 +1,57 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#ifndef SPINE_C_CONSTRAINTDATA_H +#define SPINE_C_CONSTRAINTDATA_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include "../custom.h" + +SPINE_OPAQUE_TYPE(spine_constraint_data) + +SPINE_C_EXPORT spine_constraint_data spine_constraint_data_create(const utf8 * name); +SPINE_C_EXPORT void spine_constraint_data_dispose(spine_constraint_data obj); +SPINE_C_EXPORT spine_rtti spine_constraint_data_get_rtti(spine_constraint_data obj); +SPINE_C_EXPORT spine_constraint spine_constraint_data_create(spine_constraint_data obj, spine_skeleton skeleton); +SPINE_C_EXPORT const utf8 * spine_constraint_data_get_name(spine_constraint_data obj); +SPINE_C_EXPORT spine_bool spine_constraint_data_is_skin_required(spine_constraint_data obj); + +typedef enum spine_constraint_data_type { +} spine_constraint_data_type; + +SPINE_C_EXPORT spine_bool spine_constraint_data_is_type(spine_constraint_data obj, spine_constraint_data_type type); + +#ifdef __cplusplus +} +#endif + +#endif // SPINE_C_CONSTRAINTDATA_H \ No newline at end of file diff --git a/spine-c-new/src/generated/constraint_data_generic.cpp b/spine-c-new/src/generated/constraint_data_generic.cpp new file mode 100644 index 000000000..7eea6cdb2 --- /dev/null +++ b/spine-c-new/src/generated/constraint_data_generic.cpp @@ -0,0 +1,79 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#include "constraint_data_generic.h" +#include + +using namespace spine; + +spine_constraint_data_generic spine_constraint_data_generic_create(const utf8 * name) { + ConstraintDataGeneric *obj = new (__FILE__, __LINE__) ConstraintDataGeneric(String(name)); + return (spine_constraint_data_generic) obj; +} + +void spine_constraint_data_generic_dispose(spine_constraint_data_generic obj) { + if (!obj) return; + delete (ConstraintDataGeneric *) obj; +} + +spine_constraint spine_constraint_data_generic_create(spine_constraint_data_generic obj, spine_skeleton skeleton) { + if (!obj) return 0; + ConstraintDataGeneric *_obj = (ConstraintDataGeneric *) obj; + return (spine_constraint) _obj->create(skeleton); +} + +const utf8 * spine_constraint_data_generic_get_name(spine_constraint_data_generic obj) { + if (!obj) return nullptr; + ConstraintDataGeneric *_obj = (ConstraintDataGeneric *) obj; + return (const utf8 *) _obj->getName().buffer(); +} + +spine_bool spine_constraint_data_generic_is_skin_required(spine_constraint_data_generic obj) { + if (!obj) return 0; + ConstraintDataGeneric *_obj = (ConstraintDataGeneric *) obj; + return _obj->isSkinRequired(); +} + +spine_p spine_constraint_data_generic_get_setup_pose(spine_constraint_data_generic obj) { + if (!obj) return nullptr; + ConstraintDataGeneric *_obj = (ConstraintDataGeneric *) obj; + return _obj->getSetupPose(); +} + +spine_p spine_constraint_data_generic_get_setup_pose(spine_constraint_data_generic obj) { + if (!obj) return nullptr; + ConstraintDataGeneric *_obj = (ConstraintDataGeneric *) obj; + return _obj->getSetupPose(); +} + +spine_rtti spine_constraint_data_generic_get_rtti(spine_constraint_data_generic obj) { + if (!obj) return nullptr; + ConstraintDataGeneric *_obj = (ConstraintDataGeneric *) obj; + return (spine_rtti) &_obj->getRTTI(); +} diff --git a/spine-c-new/src/generated/constraint_data_generic.h b/spine-c-new/src/generated/constraint_data_generic.h new file mode 100644 index 000000000..a8ea20326 --- /dev/null +++ b/spine-c-new/src/generated/constraint_data_generic.h @@ -0,0 +1,54 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#ifndef SPINE_C_CONSTRAINTDATAGENERIC_H +#define SPINE_C_CONSTRAINTDATAGENERIC_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include "../custom.h" + +SPINE_OPAQUE_TYPE(spine_constraint_data_generic) + +SPINE_C_EXPORT spine_constraint_data_generic spine_constraint_data_generic_create(const utf8 * name); +SPINE_C_EXPORT void spine_constraint_data_generic_dispose(spine_constraint_data_generic obj); +SPINE_C_EXPORT spine_constraint spine_constraint_data_generic_create(spine_constraint_data_generic obj, spine_skeleton skeleton); +SPINE_C_EXPORT const utf8 * spine_constraint_data_generic_get_name(spine_constraint_data_generic obj); +SPINE_C_EXPORT spine_bool spine_constraint_data_generic_is_skin_required(spine_constraint_data_generic obj); +SPINE_C_EXPORT spine_p spine_constraint_data_generic_get_setup_pose(spine_constraint_data_generic obj); +SPINE_C_EXPORT spine_p spine_constraint_data_generic_get_setup_pose(spine_constraint_data_generic obj); +SPINE_C_EXPORT spine_rtti spine_constraint_data_generic_get_rtti(spine_constraint_data_generic obj); + +#ifdef __cplusplus +} +#endif + +#endif // SPINE_C_CONSTRAINTDATAGENERIC_H \ No newline at end of file diff --git a/spine-c-new/src/generated/constraint_generic.cpp b/spine-c-new/src/generated/constraint_generic.cpp new file mode 100644 index 000000000..f9a0c6860 --- /dev/null +++ b/spine-c-new/src/generated/constraint_generic.cpp @@ -0,0 +1,127 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#include "constraint_generic.h" +#include + +using namespace spine; + +spine_constraint_generic spine_constraint_generic_create(spine_d data) { + ConstraintGeneric *obj = new (__FILE__, __LINE__) ConstraintGeneric(data); + return (spine_constraint_generic) obj; +} + +void spine_constraint_generic_dispose(spine_constraint_generic obj) { + if (!obj) return; + delete (ConstraintGeneric *) obj; +} + +spine_constraint_data spine_constraint_generic_get_data(spine_constraint_generic obj) { + if (!obj) return 0; + ConstraintGeneric *_obj = (ConstraintGeneric *) obj; + return _obj->getData(); +} + +void spine_constraint_generic_pose(spine_constraint_generic obj) { + if (!obj) return ; + ConstraintGeneric *_obj = (ConstraintGeneric *) obj; + _obj->pose(); +} + +void spine_constraint_generic_setup_pose(spine_constraint_generic obj) { + if (!obj) return ; + ConstraintGeneric *_obj = (ConstraintGeneric *) obj; + _obj->setupPose(); +} + +spine_p spine_constraint_generic_get_pose(spine_constraint_generic obj) { + if (!obj) return nullptr; + ConstraintGeneric *_obj = (ConstraintGeneric *) obj; + return _obj->getPose(); +} + +spine_p spine_constraint_generic_get_applied_pose(spine_constraint_generic obj) { + if (!obj) return nullptr; + ConstraintGeneric *_obj = (ConstraintGeneric *) obj; + return _obj->getAppliedPose(); +} + +void spine_constraint_generic_reset_constrained(spine_constraint_generic obj) { + if (!obj) return ; + ConstraintGeneric *_obj = (ConstraintGeneric *) obj; + _obj->resetConstrained(); +} + +void spine_constraint_generic_constrained(spine_constraint_generic obj) { + if (!obj) return ; + ConstraintGeneric *_obj = (ConstraintGeneric *) obj; + _obj->constrained(); +} + +spine_bool spine_constraint_generic_is_pose_equal_to_applied(spine_constraint_generic obj) { + if (!obj) return 0; + ConstraintGeneric *_obj = (ConstraintGeneric *) obj; + return _obj->isPoseEqualToApplied(); +} + +spine_bool spine_constraint_generic_is_active(spine_constraint_generic obj) { + if (!obj) return 0; + ConstraintGeneric *_obj = (ConstraintGeneric *) obj; + return _obj->isActive(); +} + +void spine_constraint_generic_set_active(spine_constraint_generic obj, spine_bool value) { + if (!obj) return; + ConstraintGeneric *_obj = (ConstraintGeneric *) obj; + _obj->setActive(value); +} + +spine_rtti spine_constraint_generic_get_rtti(spine_constraint_generic obj) { + if (!obj) return nullptr; + ConstraintGeneric *_obj = (ConstraintGeneric *) obj; + return (spine_rtti) &_obj->getRTTI(); +} + +void spine_constraint_generic_sort(spine_constraint_generic obj, spine_skeleton skeleton) { + if (!obj) return ; + ConstraintGeneric *_obj = (ConstraintGeneric *) obj; + _obj->sort(skeleton); +} + +spine_bool spine_constraint_generic_is_source_active(spine_constraint_generic obj) { + if (!obj) return 0; + ConstraintGeneric *_obj = (ConstraintGeneric *) obj; + return _obj->isSourceActive(); +} + +void spine_constraint_generic_update(spine_constraint_generic obj, spine_skeleton skeleton, spine_physics physics) { + if (!obj) return ; + ConstraintGeneric *_obj = (ConstraintGeneric *) obj; + _obj->update(skeleton, physics); +} diff --git a/spine-c-new/src/generated/constraint_generic.h b/spine-c-new/src/generated/constraint_generic.h new file mode 100644 index 000000000..e67b93de6 --- /dev/null +++ b/spine-c-new/src/generated/constraint_generic.h @@ -0,0 +1,62 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#ifndef SPINE_C_CONSTRAINTGENERIC_H +#define SPINE_C_CONSTRAINTGENERIC_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include "../custom.h" + +SPINE_OPAQUE_TYPE(spine_constraint_generic) + +SPINE_C_EXPORT spine_constraint_generic spine_constraint_generic_create(spine_d data); +SPINE_C_EXPORT void spine_constraint_generic_dispose(spine_constraint_generic obj); +SPINE_C_EXPORT spine_constraint_data spine_constraint_generic_get_data(spine_constraint_generic obj); +SPINE_C_EXPORT void spine_constraint_generic_pose(spine_constraint_generic obj); +SPINE_C_EXPORT void spine_constraint_generic_setup_pose(spine_constraint_generic obj); +SPINE_C_EXPORT spine_p spine_constraint_generic_get_pose(spine_constraint_generic obj); +SPINE_C_EXPORT spine_p spine_constraint_generic_get_applied_pose(spine_constraint_generic obj); +SPINE_C_EXPORT void spine_constraint_generic_reset_constrained(spine_constraint_generic obj); +SPINE_C_EXPORT void spine_constraint_generic_constrained(spine_constraint_generic obj); +SPINE_C_EXPORT spine_bool spine_constraint_generic_is_pose_equal_to_applied(spine_constraint_generic obj); +SPINE_C_EXPORT spine_bool spine_constraint_generic_is_active(spine_constraint_generic obj); +SPINE_C_EXPORT void spine_constraint_generic_set_active(spine_constraint_generic obj, spine_bool value); +SPINE_C_EXPORT spine_rtti spine_constraint_generic_get_rtti(spine_constraint_generic obj); +SPINE_C_EXPORT void spine_constraint_generic_sort(spine_constraint_generic obj, spine_skeleton skeleton); +SPINE_C_EXPORT spine_bool spine_constraint_generic_is_source_active(spine_constraint_generic obj); +SPINE_C_EXPORT void spine_constraint_generic_update(spine_constraint_generic obj, spine_skeleton skeleton, spine_physics physics); + +#ifdef __cplusplus +} +#endif + +#endif // SPINE_C_CONSTRAINTGENERIC_H \ No newline at end of file diff --git a/spine-c-new/src/generated/constraint_timeline.cpp b/spine-c-new/src/generated/constraint_timeline.cpp new file mode 100644 index 000000000..f2a4e50ca --- /dev/null +++ b/spine-c-new/src/generated/constraint_timeline.cpp @@ -0,0 +1,61 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#include "constraint_timeline.h" +#include + +using namespace spine; + +spine_constraint_timeline spine_constraint_timeline_create(int32_t constraintIndex) { + ConstraintTimeline *obj = new (__FILE__, __LINE__) ConstraintTimeline(constraintIndex); + return (spine_constraint_timeline) obj; +} + +void spine_constraint_timeline_dispose(spine_constraint_timeline obj) { + if (!obj) return; + delete (ConstraintTimeline *) obj; +} + +spine_rtti spine_constraint_timeline_get_rtti(spine_constraint_timeline obj) { + if (!obj) return nullptr; + ConstraintTimeline *_obj = (ConstraintTimeline *) obj; + return (spine_rtti) &_obj->getRTTI(); +} + +int32_t spine_constraint_timeline_get_constraint_index(spine_constraint_timeline obj) { + if (!obj) return 0; + ConstraintTimeline *_obj = (ConstraintTimeline *) obj; + return _obj->getConstraintIndex(); +} + +void spine_constraint_timeline_set_constraint_index(spine_constraint_timeline obj, int32_t value) { + if (!obj) return; + ConstraintTimeline *_obj = (ConstraintTimeline *) obj; + _obj->setConstraintIndex(value); +} diff --git a/spine-c-new/src/generated/constraint_timeline.h b/spine-c-new/src/generated/constraint_timeline.h new file mode 100644 index 000000000..b4dae80db --- /dev/null +++ b/spine-c-new/src/generated/constraint_timeline.h @@ -0,0 +1,51 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#ifndef SPINE_C_CONSTRAINTTIMELINE_H +#define SPINE_C_CONSTRAINTTIMELINE_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include "../custom.h" + +SPINE_OPAQUE_TYPE(spine_constraint_timeline) + +SPINE_C_EXPORT spine_constraint_timeline spine_constraint_timeline_create(int32_t constraintIndex); +SPINE_C_EXPORT void spine_constraint_timeline_dispose(spine_constraint_timeline obj); +SPINE_C_EXPORT spine_rtti spine_constraint_timeline_get_rtti(spine_constraint_timeline obj); +SPINE_C_EXPORT int32_t spine_constraint_timeline_get_constraint_index(spine_constraint_timeline obj); +SPINE_C_EXPORT void spine_constraint_timeline_set_constraint_index(spine_constraint_timeline obj, int32_t value); + +#ifdef __cplusplus +} +#endif + +#endif // SPINE_C_CONSTRAINTTIMELINE_H \ No newline at end of file diff --git a/spine-c-new/src/generated/constraint_timeline1.cpp b/spine-c-new/src/generated/constraint_timeline1.cpp new file mode 100644 index 000000000..292173483 --- /dev/null +++ b/spine-c-new/src/generated/constraint_timeline1.cpp @@ -0,0 +1,97 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#include "constraint_timeline1.h" +#include + +using namespace spine; + +spine_constraint_timeline1 spine_constraint_timeline1_create(spine_size_t frameCount, spine_size_t bezierCount, int32_t constraintIndex, spine_property property) { + ConstraintTimeline1 *obj = new (__FILE__, __LINE__) ConstraintTimeline1(frameCount, bezierCount, constraintIndex, property); + return (spine_constraint_timeline1) obj; +} + +void spine_constraint_timeline1_dispose(spine_constraint_timeline1 obj) { + if (!obj) return; + delete (ConstraintTimeline1 *) obj; +} + +spine_rtti spine_constraint_timeline1_get_rtti(spine_constraint_timeline1 obj) { + if (!obj) return nullptr; + ConstraintTimeline1 *_obj = (ConstraintTimeline1 *) obj; + return (spine_rtti) &_obj->getRTTI(); +} + +void spine_constraint_timeline1_set_frame(spine_constraint_timeline1 obj, spine_size_t frame, float time, float value) { + if (!obj) return ; + ConstraintTimeline1 *_obj = (ConstraintTimeline1 *) obj; + _obj->setFrame(frame, time, value); +} + +float spine_constraint_timeline1_get_curve_value(spine_constraint_timeline1 obj, float time) { + if (!obj) return 0; + ConstraintTimeline1 *_obj = (ConstraintTimeline1 *) obj; + return _obj->getCurveValue(time); +} + +float spine_constraint_timeline1_get_relative_value(spine_constraint_timeline1 obj, float time, float alpha, spine_mix_blend blend, float current, float setup) { + if (!obj) return 0; + ConstraintTimeline1 *_obj = (ConstraintTimeline1 *) obj; + return _obj->getRelativeValue(time, alpha, blend, current, setup); +} + +float spine_constraint_timeline1_get_absolute_value(spine_constraint_timeline1 obj, float time, float alpha, spine_mix_blend blend, float current, float setup) { + if (!obj) return 0; + ConstraintTimeline1 *_obj = (ConstraintTimeline1 *) obj; + return _obj->getAbsoluteValue(time, alpha, blend, current, setup); +} + +float spine_constraint_timeline1_get_absolute_value(spine_constraint_timeline1 obj, float time, float alpha, spine_mix_blend blend, float current, float setup, float value) { + if (!obj) return 0; + ConstraintTimeline1 *_obj = (ConstraintTimeline1 *) obj; + return _obj->getAbsoluteValue(time, alpha, blend, current, setup, value); +} + +float spine_constraint_timeline1_get_scale_value(spine_constraint_timeline1 obj, float time, float alpha, spine_mix_blend blend, spine_mix_direction direction, float current, float setup) { + if (!obj) return 0; + ConstraintTimeline1 *_obj = (ConstraintTimeline1 *) obj; + return _obj->getScaleValue(time, alpha, blend, direction, current, setup); +} + +int32_t spine_constraint_timeline1_get_constraint_index(spine_constraint_timeline1 obj) { + if (!obj) return 0; + ConstraintTimeline1 *_obj = (ConstraintTimeline1 *) obj; + return _obj->getConstraintIndex(); +} + +void spine_constraint_timeline1_set_constraint_index(spine_constraint_timeline1 obj, int32_t value) { + if (!obj) return; + ConstraintTimeline1 *_obj = (ConstraintTimeline1 *) obj; + _obj->setConstraintIndex(value); +} diff --git a/spine-c-new/src/generated/constraint_timeline1.h b/spine-c-new/src/generated/constraint_timeline1.h new file mode 100644 index 000000000..3211163d0 --- /dev/null +++ b/spine-c-new/src/generated/constraint_timeline1.h @@ -0,0 +1,57 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#ifndef SPINE_C_CONSTRAINTTIMELINE1_H +#define SPINE_C_CONSTRAINTTIMELINE1_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include "../custom.h" + +SPINE_OPAQUE_TYPE(spine_constraint_timeline1) + +SPINE_C_EXPORT spine_constraint_timeline1 spine_constraint_timeline1_create(spine_size_t frameCount, spine_size_t bezierCount, int32_t constraintIndex, spine_property property); +SPINE_C_EXPORT void spine_constraint_timeline1_dispose(spine_constraint_timeline1 obj); +SPINE_C_EXPORT spine_rtti spine_constraint_timeline1_get_rtti(spine_constraint_timeline1 obj); +SPINE_C_EXPORT void spine_constraint_timeline1_set_frame(spine_constraint_timeline1 obj, spine_size_t frame, float time, float value); +SPINE_C_EXPORT float spine_constraint_timeline1_get_curve_value(spine_constraint_timeline1 obj, float time); +SPINE_C_EXPORT float spine_constraint_timeline1_get_relative_value(spine_constraint_timeline1 obj, float time, float alpha, spine_mix_blend blend, float current, float setup); +SPINE_C_EXPORT float spine_constraint_timeline1_get_absolute_value(spine_constraint_timeline1 obj, float time, float alpha, spine_mix_blend blend, float current, float setup); +SPINE_C_EXPORT float spine_constraint_timeline1_get_absolute_value(spine_constraint_timeline1 obj, float time, float alpha, spine_mix_blend blend, float current, float setup, float value); +SPINE_C_EXPORT float spine_constraint_timeline1_get_scale_value(spine_constraint_timeline1 obj, float time, float alpha, spine_mix_blend blend, spine_mix_direction direction, float current, float setup); +SPINE_C_EXPORT int32_t spine_constraint_timeline1_get_constraint_index(spine_constraint_timeline1 obj); +SPINE_C_EXPORT void spine_constraint_timeline1_set_constraint_index(spine_constraint_timeline1 obj, int32_t value); + +#ifdef __cplusplus +} +#endif + +#endif // SPINE_C_CONSTRAINTTIMELINE1_H \ No newline at end of file diff --git a/spine-c-new/src/generated/curve_timeline.cpp b/spine-c-new/src/generated/curve_timeline.cpp new file mode 100644 index 000000000..57cfdca19 --- /dev/null +++ b/spine-c-new/src/generated/curve_timeline.cpp @@ -0,0 +1,151 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#include "curve_timeline.h" +#include + +using namespace spine; + +spine_curve_timeline spine_curve_timeline_create(spine_size_t frameCount, spine_size_t frameEntries, spine_size_t bezierCount) { + CurveTimeline *obj = new (__FILE__, __LINE__) CurveTimeline(frameCount, frameEntries, bezierCount); + return (spine_curve_timeline) obj; +} + +void spine_curve_timeline_dispose(spine_curve_timeline obj) { + if (!obj) return; + delete (CurveTimeline *) obj; +} + +spine_rtti spine_curve_timeline_get_rtti(spine_curve_timeline obj) { + if (!obj) return nullptr; + CurveTimeline *_obj = (CurveTimeline *) obj; + return (spine_rtti) &_obj->getRTTI(); +} + +void spine_curve_timeline_set_linear(spine_curve_timeline obj, spine_size_t value) { + if (!obj) return; + CurveTimeline *_obj = (CurveTimeline *) obj; + _obj->setLinear(value); +} + +void spine_curve_timeline_set_stepped(spine_curve_timeline obj, spine_size_t value) { + if (!obj) return; + CurveTimeline *_obj = (CurveTimeline *) obj; + _obj->setStepped(value); +} + +void spine_curve_timeline_set_bezier(spine_curve_timeline obj, spine_size_t bezier, spine_size_t frame, float value, float time1, float value1, float cx1, float cy1, float cx2, float cy2, float time2, float value2) { + if (!obj) return ; + CurveTimeline *_obj = (CurveTimeline *) obj; + _obj->setBezier(bezier, frame, value, time1, value1, cx1, cy1, cx2, cy2, time2, value2); +} + +float spine_curve_timeline_get_bezier_value(spine_curve_timeline obj, float time, spine_size_t frame, spine_size_t valueOffset, spine_size_t i) { + if (!obj) return 0; + CurveTimeline *_obj = (CurveTimeline *) obj; + return _obj->getBezierValue(time, frame, valueOffset, i); +} + +void * spine_curve_timeline_get_curves(spine_curve_timeline obj) { + if (!obj) return nullptr; + CurveTimeline *_obj = (CurveTimeline *) obj; + return _obj->getCurves(); +} + +int32_t spine_curve_timeline_get_num_curves(spine_curve_timeline obj) { + if (!obj) return 0; + CurveTimeline *_obj = (CurveTimeline *) obj; + return (int32_t) _obj->getCurves().size(); +} + +spine_float *spine_curve_timeline_get_curves(spine_curve_timeline obj) { + if (!obj) return nullptr; + CurveTimeline *_obj = (CurveTimeline *) obj; + return (spine_float *) _obj->getCurves().buffer(); +} + +void spine_curve_timeline_apply(spine_curve_timeline obj, spine_skeleton skeleton, float lastTime, float time, void * pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction, spine_bool appliedPose) { + if (!obj) return ; + CurveTimeline *_obj = (CurveTimeline *) obj; + _obj->apply(skeleton, lastTime, time, (Vector *) pEvents, alpha, blend, direction, appliedPose); +} + +spine_size_t spine_curve_timeline_get_frame_entries(spine_curve_timeline obj) { + if (!obj) return nullptr; + CurveTimeline *_obj = (CurveTimeline *) obj; + return _obj->getFrameEntries(); +} + +spine_size_t spine_curve_timeline_get_frame_count(spine_curve_timeline obj) { + if (!obj) return nullptr; + CurveTimeline *_obj = (CurveTimeline *) obj; + return _obj->getFrameCount(); +} + +void * spine_curve_timeline_get_frames(spine_curve_timeline obj) { + if (!obj) return nullptr; + CurveTimeline *_obj = (CurveTimeline *) obj; + return _obj->getFrames(); +} + +int32_t spine_curve_timeline_get_num_frames(spine_curve_timeline obj) { + if (!obj) return 0; + CurveTimeline *_obj = (CurveTimeline *) obj; + return (int32_t) _obj->getFrames().size(); +} + +spine_float *spine_curve_timeline_get_frames(spine_curve_timeline obj) { + if (!obj) return nullptr; + CurveTimeline *_obj = (CurveTimeline *) obj; + return (spine_float *) _obj->getFrames().buffer(); +} + +float spine_curve_timeline_get_duration(spine_curve_timeline obj) { + if (!obj) return 0; + CurveTimeline *_obj = (CurveTimeline *) obj; + return _obj->getDuration(); +} + +void * spine_curve_timeline_get_property_ids(spine_curve_timeline obj) { + if (!obj) return nullptr; + CurveTimeline *_obj = (CurveTimeline *) obj; + return _obj->getPropertyIds(); +} + +int32_t spine_curve_timeline_get_num_property_ids(spine_curve_timeline obj) { + if (!obj) return 0; + CurveTimeline *_obj = (CurveTimeline *) obj; + return (int32_t) _obj->getPropertyIds().size(); +} + +spine_property_id *spine_curve_timeline_get_property_ids(spine_curve_timeline obj) { + if (!obj) return nullptr; + CurveTimeline *_obj = (CurveTimeline *) obj; + return (spine_property_id *) _obj->getPropertyIds().buffer(); +} diff --git a/spine-c-new/src/generated/curve_timeline.h b/spine-c-new/src/generated/curve_timeline.h new file mode 100644 index 000000000..c5c38df9c --- /dev/null +++ b/spine-c-new/src/generated/curve_timeline.h @@ -0,0 +1,66 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#ifndef SPINE_C_CURVETIMELINE_H +#define SPINE_C_CURVETIMELINE_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include "../custom.h" + +SPINE_OPAQUE_TYPE(spine_curve_timeline) + +SPINE_C_EXPORT spine_curve_timeline spine_curve_timeline_create(spine_size_t frameCount, spine_size_t frameEntries, spine_size_t bezierCount); +SPINE_C_EXPORT void spine_curve_timeline_dispose(spine_curve_timeline obj); +SPINE_C_EXPORT spine_rtti spine_curve_timeline_get_rtti(spine_curve_timeline obj); +SPINE_C_EXPORT void spine_curve_timeline_set_linear(spine_curve_timeline obj, spine_size_t value); +SPINE_C_EXPORT void spine_curve_timeline_set_stepped(spine_curve_timeline obj, spine_size_t value); +SPINE_C_EXPORT void spine_curve_timeline_set_bezier(spine_curve_timeline obj, spine_size_t bezier, spine_size_t frame, float value, float time1, float value1, float cx1, float cy1, float cx2, float cy2, float time2, float value2); +SPINE_C_EXPORT float spine_curve_timeline_get_bezier_value(spine_curve_timeline obj, float time, spine_size_t frame, spine_size_t valueOffset, spine_size_t i); +SPINE_C_EXPORT void * spine_curve_timeline_get_curves(spine_curve_timeline obj); +SPINE_C_EXPORT int32_t spine_curve_timeline_get_num_curves(spine_curve_timeline obj); +SPINE_C_EXPORT spine_float *spine_curve_timeline_get_curves(spine_curve_timeline obj); +SPINE_C_EXPORT void spine_curve_timeline_apply(spine_curve_timeline obj, spine_skeleton skeleton, float lastTime, float time, void * pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction, spine_bool appliedPose); +SPINE_C_EXPORT spine_size_t spine_curve_timeline_get_frame_entries(spine_curve_timeline obj); +SPINE_C_EXPORT spine_size_t spine_curve_timeline_get_frame_count(spine_curve_timeline obj); +SPINE_C_EXPORT void * spine_curve_timeline_get_frames(spine_curve_timeline obj); +SPINE_C_EXPORT int32_t spine_curve_timeline_get_num_frames(spine_curve_timeline obj); +SPINE_C_EXPORT spine_float *spine_curve_timeline_get_frames(spine_curve_timeline obj); +SPINE_C_EXPORT float spine_curve_timeline_get_duration(spine_curve_timeline obj); +SPINE_C_EXPORT void * spine_curve_timeline_get_property_ids(spine_curve_timeline obj); +SPINE_C_EXPORT int32_t spine_curve_timeline_get_num_property_ids(spine_curve_timeline obj); +SPINE_C_EXPORT spine_property_id *spine_curve_timeline_get_property_ids(spine_curve_timeline obj); + +#ifdef __cplusplus +} +#endif + +#endif // SPINE_C_CURVETIMELINE_H \ No newline at end of file diff --git a/spine-c-new/src/generated/curve_timeline1.cpp b/spine-c-new/src/generated/curve_timeline1.cpp new file mode 100644 index 000000000..840e10c9c --- /dev/null +++ b/spine-c-new/src/generated/curve_timeline1.cpp @@ -0,0 +1,187 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#include "curve_timeline1.h" +#include + +using namespace spine; + +spine_curve_timeline1 spine_curve_timeline1_create(spine_size_t frameCount, spine_size_t bezierCount) { + CurveTimeline1 *obj = new (__FILE__, __LINE__) CurveTimeline1(frameCount, bezierCount); + return (spine_curve_timeline1) obj; +} + +void spine_curve_timeline1_dispose(spine_curve_timeline1 obj) { + if (!obj) return; + delete (CurveTimeline1 *) obj; +} + +spine_rtti spine_curve_timeline1_get_rtti(spine_curve_timeline1 obj) { + if (!obj) return nullptr; + CurveTimeline1 *_obj = (CurveTimeline1 *) obj; + return (spine_rtti) &_obj->getRTTI(); +} + +void spine_curve_timeline1_set_frame(spine_curve_timeline1 obj, spine_size_t frame, float time, float value) { + if (!obj) return ; + CurveTimeline1 *_obj = (CurveTimeline1 *) obj; + _obj->setFrame(frame, time, value); +} + +float spine_curve_timeline1_get_curve_value(spine_curve_timeline1 obj, float time) { + if (!obj) return 0; + CurveTimeline1 *_obj = (CurveTimeline1 *) obj; + return _obj->getCurveValue(time); +} + +float spine_curve_timeline1_get_relative_value(spine_curve_timeline1 obj, float time, float alpha, spine_mix_blend blend, float current, float setup) { + if (!obj) return 0; + CurveTimeline1 *_obj = (CurveTimeline1 *) obj; + return _obj->getRelativeValue(time, alpha, blend, current, setup); +} + +float spine_curve_timeline1_get_absolute_value(spine_curve_timeline1 obj, float time, float alpha, spine_mix_blend blend, float current, float setup) { + if (!obj) return 0; + CurveTimeline1 *_obj = (CurveTimeline1 *) obj; + return _obj->getAbsoluteValue(time, alpha, blend, current, setup); +} + +float spine_curve_timeline1_get_absolute_value(spine_curve_timeline1 obj, float time, float alpha, spine_mix_blend blend, float current, float setup, float value) { + if (!obj) return 0; + CurveTimeline1 *_obj = (CurveTimeline1 *) obj; + return _obj->getAbsoluteValue(time, alpha, blend, current, setup, value); +} + +float spine_curve_timeline1_get_scale_value(spine_curve_timeline1 obj, float time, float alpha, spine_mix_blend blend, spine_mix_direction direction, float current, float setup) { + if (!obj) return 0; + CurveTimeline1 *_obj = (CurveTimeline1 *) obj; + return _obj->getScaleValue(time, alpha, blend, direction, current, setup); +} + +void spine_curve_timeline1_set_linear(spine_curve_timeline1 obj, spine_size_t value) { + if (!obj) return; + CurveTimeline1 *_obj = (CurveTimeline1 *) obj; + _obj->setLinear(value); +} + +void spine_curve_timeline1_set_stepped(spine_curve_timeline1 obj, spine_size_t value) { + if (!obj) return; + CurveTimeline1 *_obj = (CurveTimeline1 *) obj; + _obj->setStepped(value); +} + +void spine_curve_timeline1_set_bezier(spine_curve_timeline1 obj, spine_size_t bezier, spine_size_t frame, float value, float time1, float value1, float cx1, float cy1, float cx2, float cy2, float time2, float value2) { + if (!obj) return ; + CurveTimeline1 *_obj = (CurveTimeline1 *) obj; + _obj->setBezier(bezier, frame, value, time1, value1, cx1, cy1, cx2, cy2, time2, value2); +} + +float spine_curve_timeline1_get_bezier_value(spine_curve_timeline1 obj, float time, spine_size_t frame, spine_size_t valueOffset, spine_size_t i) { + if (!obj) return 0; + CurveTimeline1 *_obj = (CurveTimeline1 *) obj; + return _obj->getBezierValue(time, frame, valueOffset, i); +} + +void * spine_curve_timeline1_get_curves(spine_curve_timeline1 obj) { + if (!obj) return nullptr; + CurveTimeline1 *_obj = (CurveTimeline1 *) obj; + return _obj->getCurves(); +} + +int32_t spine_curve_timeline1_get_num_curves(spine_curve_timeline1 obj) { + if (!obj) return 0; + CurveTimeline1 *_obj = (CurveTimeline1 *) obj; + return (int32_t) _obj->getCurves().size(); +} + +spine_float *spine_curve_timeline1_get_curves(spine_curve_timeline1 obj) { + if (!obj) return nullptr; + CurveTimeline1 *_obj = (CurveTimeline1 *) obj; + return (spine_float *) _obj->getCurves().buffer(); +} + +void spine_curve_timeline1_apply(spine_curve_timeline1 obj, spine_skeleton skeleton, float lastTime, float time, void * pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction, spine_bool appliedPose) { + if (!obj) return ; + CurveTimeline1 *_obj = (CurveTimeline1 *) obj; + _obj->apply(skeleton, lastTime, time, (Vector *) pEvents, alpha, blend, direction, appliedPose); +} + +spine_size_t spine_curve_timeline1_get_frame_entries(spine_curve_timeline1 obj) { + if (!obj) return nullptr; + CurveTimeline1 *_obj = (CurveTimeline1 *) obj; + return _obj->getFrameEntries(); +} + +spine_size_t spine_curve_timeline1_get_frame_count(spine_curve_timeline1 obj) { + if (!obj) return nullptr; + CurveTimeline1 *_obj = (CurveTimeline1 *) obj; + return _obj->getFrameCount(); +} + +void * spine_curve_timeline1_get_frames(spine_curve_timeline1 obj) { + if (!obj) return nullptr; + CurveTimeline1 *_obj = (CurveTimeline1 *) obj; + return _obj->getFrames(); +} + +int32_t spine_curve_timeline1_get_num_frames(spine_curve_timeline1 obj) { + if (!obj) return 0; + CurveTimeline1 *_obj = (CurveTimeline1 *) obj; + return (int32_t) _obj->getFrames().size(); +} + +spine_float *spine_curve_timeline1_get_frames(spine_curve_timeline1 obj) { + if (!obj) return nullptr; + CurveTimeline1 *_obj = (CurveTimeline1 *) obj; + return (spine_float *) _obj->getFrames().buffer(); +} + +float spine_curve_timeline1_get_duration(spine_curve_timeline1 obj) { + if (!obj) return 0; + CurveTimeline1 *_obj = (CurveTimeline1 *) obj; + return _obj->getDuration(); +} + +void * spine_curve_timeline1_get_property_ids(spine_curve_timeline1 obj) { + if (!obj) return nullptr; + CurveTimeline1 *_obj = (CurveTimeline1 *) obj; + return _obj->getPropertyIds(); +} + +int32_t spine_curve_timeline1_get_num_property_ids(spine_curve_timeline1 obj) { + if (!obj) return 0; + CurveTimeline1 *_obj = (CurveTimeline1 *) obj; + return (int32_t) _obj->getPropertyIds().size(); +} + +spine_property_id *spine_curve_timeline1_get_property_ids(spine_curve_timeline1 obj) { + if (!obj) return nullptr; + CurveTimeline1 *_obj = (CurveTimeline1 *) obj; + return (spine_property_id *) _obj->getPropertyIds().buffer(); +} diff --git a/spine-c-new/src/generated/curve_timeline1.h b/spine-c-new/src/generated/curve_timeline1.h new file mode 100644 index 000000000..1d88f5313 --- /dev/null +++ b/spine-c-new/src/generated/curve_timeline1.h @@ -0,0 +1,72 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#ifndef SPINE_C_CURVETIMELINE1_H +#define SPINE_C_CURVETIMELINE1_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include "../custom.h" + +SPINE_OPAQUE_TYPE(spine_curve_timeline1) + +SPINE_C_EXPORT spine_curve_timeline1 spine_curve_timeline1_create(spine_size_t frameCount, spine_size_t bezierCount); +SPINE_C_EXPORT void spine_curve_timeline1_dispose(spine_curve_timeline1 obj); +SPINE_C_EXPORT spine_rtti spine_curve_timeline1_get_rtti(spine_curve_timeline1 obj); +SPINE_C_EXPORT void spine_curve_timeline1_set_frame(spine_curve_timeline1 obj, spine_size_t frame, float time, float value); +SPINE_C_EXPORT float spine_curve_timeline1_get_curve_value(spine_curve_timeline1 obj, float time); +SPINE_C_EXPORT float spine_curve_timeline1_get_relative_value(spine_curve_timeline1 obj, float time, float alpha, spine_mix_blend blend, float current, float setup); +SPINE_C_EXPORT float spine_curve_timeline1_get_absolute_value(spine_curve_timeline1 obj, float time, float alpha, spine_mix_blend blend, float current, float setup); +SPINE_C_EXPORT float spine_curve_timeline1_get_absolute_value(spine_curve_timeline1 obj, float time, float alpha, spine_mix_blend blend, float current, float setup, float value); +SPINE_C_EXPORT float spine_curve_timeline1_get_scale_value(spine_curve_timeline1 obj, float time, float alpha, spine_mix_blend blend, spine_mix_direction direction, float current, float setup); +SPINE_C_EXPORT void spine_curve_timeline1_set_linear(spine_curve_timeline1 obj, spine_size_t value); +SPINE_C_EXPORT void spine_curve_timeline1_set_stepped(spine_curve_timeline1 obj, spine_size_t value); +SPINE_C_EXPORT void spine_curve_timeline1_set_bezier(spine_curve_timeline1 obj, spine_size_t bezier, spine_size_t frame, float value, float time1, float value1, float cx1, float cy1, float cx2, float cy2, float time2, float value2); +SPINE_C_EXPORT float spine_curve_timeline1_get_bezier_value(spine_curve_timeline1 obj, float time, spine_size_t frame, spine_size_t valueOffset, spine_size_t i); +SPINE_C_EXPORT void * spine_curve_timeline1_get_curves(spine_curve_timeline1 obj); +SPINE_C_EXPORT int32_t spine_curve_timeline1_get_num_curves(spine_curve_timeline1 obj); +SPINE_C_EXPORT spine_float *spine_curve_timeline1_get_curves(spine_curve_timeline1 obj); +SPINE_C_EXPORT void spine_curve_timeline1_apply(spine_curve_timeline1 obj, spine_skeleton skeleton, float lastTime, float time, void * pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction, spine_bool appliedPose); +SPINE_C_EXPORT spine_size_t spine_curve_timeline1_get_frame_entries(spine_curve_timeline1 obj); +SPINE_C_EXPORT spine_size_t spine_curve_timeline1_get_frame_count(spine_curve_timeline1 obj); +SPINE_C_EXPORT void * spine_curve_timeline1_get_frames(spine_curve_timeline1 obj); +SPINE_C_EXPORT int32_t spine_curve_timeline1_get_num_frames(spine_curve_timeline1 obj); +SPINE_C_EXPORT spine_float *spine_curve_timeline1_get_frames(spine_curve_timeline1 obj); +SPINE_C_EXPORT float spine_curve_timeline1_get_duration(spine_curve_timeline1 obj); +SPINE_C_EXPORT void * spine_curve_timeline1_get_property_ids(spine_curve_timeline1 obj); +SPINE_C_EXPORT int32_t spine_curve_timeline1_get_num_property_ids(spine_curve_timeline1 obj); +SPINE_C_EXPORT spine_property_id *spine_curve_timeline1_get_property_ids(spine_curve_timeline1 obj); + +#ifdef __cplusplus +} +#endif + +#endif // SPINE_C_CURVETIMELINE1_H \ No newline at end of file diff --git a/spine-c-new/src/generated/curve_timeline2.cpp b/spine-c-new/src/generated/curve_timeline2.cpp new file mode 100644 index 000000000..d93648105 --- /dev/null +++ b/spine-c-new/src/generated/curve_timeline2.cpp @@ -0,0 +1,163 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#include "curve_timeline2.h" +#include + +using namespace spine; + +spine_curve_timeline2 spine_curve_timeline2_create(spine_size_t frameCount, spine_size_t bezierCount) { + CurveTimeline2 *obj = new (__FILE__, __LINE__) CurveTimeline2(frameCount, bezierCount); + return (spine_curve_timeline2) obj; +} + +void spine_curve_timeline2_dispose(spine_curve_timeline2 obj) { + if (!obj) return; + delete (CurveTimeline2 *) obj; +} + +spine_rtti spine_curve_timeline2_get_rtti(spine_curve_timeline2 obj) { + if (!obj) return nullptr; + CurveTimeline2 *_obj = (CurveTimeline2 *) obj; + return (spine_rtti) &_obj->getRTTI(); +} + +void spine_curve_timeline2_set_frame(spine_curve_timeline2 obj, spine_size_t frame, float time, float value1, float value2) { + if (!obj) return ; + CurveTimeline2 *_obj = (CurveTimeline2 *) obj; + _obj->setFrame(frame, time, value1, value2); +} + +float spine_curve_timeline2_get_curve_value(spine_curve_timeline2 obj, float time) { + if (!obj) return 0; + CurveTimeline2 *_obj = (CurveTimeline2 *) obj; + return _obj->getCurveValue(time); +} + +void spine_curve_timeline2_set_linear(spine_curve_timeline2 obj, spine_size_t value) { + if (!obj) return; + CurveTimeline2 *_obj = (CurveTimeline2 *) obj; + _obj->setLinear(value); +} + +void spine_curve_timeline2_set_stepped(spine_curve_timeline2 obj, spine_size_t value) { + if (!obj) return; + CurveTimeline2 *_obj = (CurveTimeline2 *) obj; + _obj->setStepped(value); +} + +void spine_curve_timeline2_set_bezier(spine_curve_timeline2 obj, spine_size_t bezier, spine_size_t frame, float value, float time1, float value1, float cx1, float cy1, float cx2, float cy2, float time2, float value2) { + if (!obj) return ; + CurveTimeline2 *_obj = (CurveTimeline2 *) obj; + _obj->setBezier(bezier, frame, value, time1, value1, cx1, cy1, cx2, cy2, time2, value2); +} + +float spine_curve_timeline2_get_bezier_value(spine_curve_timeline2 obj, float time, spine_size_t frame, spine_size_t valueOffset, spine_size_t i) { + if (!obj) return 0; + CurveTimeline2 *_obj = (CurveTimeline2 *) obj; + return _obj->getBezierValue(time, frame, valueOffset, i); +} + +void * spine_curve_timeline2_get_curves(spine_curve_timeline2 obj) { + if (!obj) return nullptr; + CurveTimeline2 *_obj = (CurveTimeline2 *) obj; + return _obj->getCurves(); +} + +int32_t spine_curve_timeline2_get_num_curves(spine_curve_timeline2 obj) { + if (!obj) return 0; + CurveTimeline2 *_obj = (CurveTimeline2 *) obj; + return (int32_t) _obj->getCurves().size(); +} + +spine_float *spine_curve_timeline2_get_curves(spine_curve_timeline2 obj) { + if (!obj) return nullptr; + CurveTimeline2 *_obj = (CurveTimeline2 *) obj; + return (spine_float *) _obj->getCurves().buffer(); +} + +void spine_curve_timeline2_apply(spine_curve_timeline2 obj, spine_skeleton skeleton, float lastTime, float time, void * pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction, spine_bool appliedPose) { + if (!obj) return ; + CurveTimeline2 *_obj = (CurveTimeline2 *) obj; + _obj->apply(skeleton, lastTime, time, (Vector *) pEvents, alpha, blend, direction, appliedPose); +} + +spine_size_t spine_curve_timeline2_get_frame_entries(spine_curve_timeline2 obj) { + if (!obj) return nullptr; + CurveTimeline2 *_obj = (CurveTimeline2 *) obj; + return _obj->getFrameEntries(); +} + +spine_size_t spine_curve_timeline2_get_frame_count(spine_curve_timeline2 obj) { + if (!obj) return nullptr; + CurveTimeline2 *_obj = (CurveTimeline2 *) obj; + return _obj->getFrameCount(); +} + +void * spine_curve_timeline2_get_frames(spine_curve_timeline2 obj) { + if (!obj) return nullptr; + CurveTimeline2 *_obj = (CurveTimeline2 *) obj; + return _obj->getFrames(); +} + +int32_t spine_curve_timeline2_get_num_frames(spine_curve_timeline2 obj) { + if (!obj) return 0; + CurveTimeline2 *_obj = (CurveTimeline2 *) obj; + return (int32_t) _obj->getFrames().size(); +} + +spine_float *spine_curve_timeline2_get_frames(spine_curve_timeline2 obj) { + if (!obj) return nullptr; + CurveTimeline2 *_obj = (CurveTimeline2 *) obj; + return (spine_float *) _obj->getFrames().buffer(); +} + +float spine_curve_timeline2_get_duration(spine_curve_timeline2 obj) { + if (!obj) return 0; + CurveTimeline2 *_obj = (CurveTimeline2 *) obj; + return _obj->getDuration(); +} + +void * spine_curve_timeline2_get_property_ids(spine_curve_timeline2 obj) { + if (!obj) return nullptr; + CurveTimeline2 *_obj = (CurveTimeline2 *) obj; + return _obj->getPropertyIds(); +} + +int32_t spine_curve_timeline2_get_num_property_ids(spine_curve_timeline2 obj) { + if (!obj) return 0; + CurveTimeline2 *_obj = (CurveTimeline2 *) obj; + return (int32_t) _obj->getPropertyIds().size(); +} + +spine_property_id *spine_curve_timeline2_get_property_ids(spine_curve_timeline2 obj) { + if (!obj) return nullptr; + CurveTimeline2 *_obj = (CurveTimeline2 *) obj; + return (spine_property_id *) _obj->getPropertyIds().buffer(); +} diff --git a/spine-c-new/src/generated/curve_timeline2.h b/spine-c-new/src/generated/curve_timeline2.h new file mode 100644 index 000000000..58005aae6 --- /dev/null +++ b/spine-c-new/src/generated/curve_timeline2.h @@ -0,0 +1,68 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#ifndef SPINE_C_CURVETIMELINE2_H +#define SPINE_C_CURVETIMELINE2_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include "../custom.h" + +SPINE_OPAQUE_TYPE(spine_curve_timeline2) + +SPINE_C_EXPORT spine_curve_timeline2 spine_curve_timeline2_create(spine_size_t frameCount, spine_size_t bezierCount); +SPINE_C_EXPORT void spine_curve_timeline2_dispose(spine_curve_timeline2 obj); +SPINE_C_EXPORT spine_rtti spine_curve_timeline2_get_rtti(spine_curve_timeline2 obj); +SPINE_C_EXPORT void spine_curve_timeline2_set_frame(spine_curve_timeline2 obj, spine_size_t frame, float time, float value1, float value2); +SPINE_C_EXPORT float spine_curve_timeline2_get_curve_value(spine_curve_timeline2 obj, float time); +SPINE_C_EXPORT void spine_curve_timeline2_set_linear(spine_curve_timeline2 obj, spine_size_t value); +SPINE_C_EXPORT void spine_curve_timeline2_set_stepped(spine_curve_timeline2 obj, spine_size_t value); +SPINE_C_EXPORT void spine_curve_timeline2_set_bezier(spine_curve_timeline2 obj, spine_size_t bezier, spine_size_t frame, float value, float time1, float value1, float cx1, float cy1, float cx2, float cy2, float time2, float value2); +SPINE_C_EXPORT float spine_curve_timeline2_get_bezier_value(spine_curve_timeline2 obj, float time, spine_size_t frame, spine_size_t valueOffset, spine_size_t i); +SPINE_C_EXPORT void * spine_curve_timeline2_get_curves(spine_curve_timeline2 obj); +SPINE_C_EXPORT int32_t spine_curve_timeline2_get_num_curves(spine_curve_timeline2 obj); +SPINE_C_EXPORT spine_float *spine_curve_timeline2_get_curves(spine_curve_timeline2 obj); +SPINE_C_EXPORT void spine_curve_timeline2_apply(spine_curve_timeline2 obj, spine_skeleton skeleton, float lastTime, float time, void * pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction, spine_bool appliedPose); +SPINE_C_EXPORT spine_size_t spine_curve_timeline2_get_frame_entries(spine_curve_timeline2 obj); +SPINE_C_EXPORT spine_size_t spine_curve_timeline2_get_frame_count(spine_curve_timeline2 obj); +SPINE_C_EXPORT void * spine_curve_timeline2_get_frames(spine_curve_timeline2 obj); +SPINE_C_EXPORT int32_t spine_curve_timeline2_get_num_frames(spine_curve_timeline2 obj); +SPINE_C_EXPORT spine_float *spine_curve_timeline2_get_frames(spine_curve_timeline2 obj); +SPINE_C_EXPORT float spine_curve_timeline2_get_duration(spine_curve_timeline2 obj); +SPINE_C_EXPORT void * spine_curve_timeline2_get_property_ids(spine_curve_timeline2 obj); +SPINE_C_EXPORT int32_t spine_curve_timeline2_get_num_property_ids(spine_curve_timeline2 obj); +SPINE_C_EXPORT spine_property_id *spine_curve_timeline2_get_property_ids(spine_curve_timeline2 obj); + +#ifdef __cplusplus +} +#endif + +#endif // SPINE_C_CURVETIMELINE2_H \ No newline at end of file diff --git a/spine-c-new/src/generated/deform_timeline.cpp b/spine-c-new/src/generated/deform_timeline.cpp new file mode 100644 index 000000000..76aa5640c --- /dev/null +++ b/spine-c-new/src/generated/deform_timeline.cpp @@ -0,0 +1,109 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#include "deform_timeline.h" +#include + +using namespace spine; + +spine_deform_timeline spine_deform_timeline_create(spine_size_t frameCount, spine_size_t bezierCount, int32_t slotIndex, spine_vertex_attachment attachment) { + DeformTimeline *obj = new (__FILE__, __LINE__) DeformTimeline(frameCount, bezierCount, slotIndex, (VertexAttachment *) attachment); + return (spine_deform_timeline) obj; +} + +void spine_deform_timeline_dispose(spine_deform_timeline obj) { + if (!obj) return; + delete (DeformTimeline *) obj; +} + +spine_rtti spine_deform_timeline_get_rtti(spine_deform_timeline obj) { + if (!obj) return nullptr; + DeformTimeline *_obj = (DeformTimeline *) obj; + return (spine_rtti) &_obj->getRTTI(); +} + +void spine_deform_timeline_set_frame(spine_deform_timeline obj, int32_t frameIndex, float time, void * vertices) { + if (!obj) return ; + DeformTimeline *_obj = (DeformTimeline *) obj; + _obj->setFrame(frameIndex, time, (Vector &) vertices); +} + +void * spine_deform_timeline_get_vertices(spine_deform_timeline obj) { + if (!obj) return nullptr; + DeformTimeline *_obj = (DeformTimeline *) obj; + return _obj->getVertices(); +} + +int32_t spine_deform_timeline_get_num_vertices(spine_deform_timeline obj) { + if (!obj) return 0; + DeformTimeline *_obj = (DeformTimeline *) obj; + return (int32_t) _obj->getVertices().size(); +} + +spine_vectorgetVertices().buffer(); +} + +spine_vertex_attachment spine_deform_timeline_get_attachment(spine_deform_timeline obj) { + if (!obj) return nullptr; + DeformTimeline *_obj = (DeformTimeline *) obj; + return (spine_vertex_attachment) _obj->getAttachment(); +} + +void spine_deform_timeline_set_attachment(spine_deform_timeline obj, spine_vertex_attachment value) { + if (!obj) return; + DeformTimeline *_obj = (DeformTimeline *) obj; + _obj->setAttachment((VertexAttachment *) value); +} + +void spine_deform_timeline_set_bezier(spine_deform_timeline obj, spine_size_t bezier, spine_size_t frame, float value, float time1, float value1, float cx1, float cy1, float cx2, float cy2, float time2, float value2) { + if (!obj) return ; + DeformTimeline *_obj = (DeformTimeline *) obj; + _obj->setBezier(bezier, frame, value, time1, value1, cx1, cy1, cx2, cy2, time2, value2); +} + +float spine_deform_timeline_get_curve_percent(spine_deform_timeline obj, float time, int32_t frame) { + if (!obj) return 0; + DeformTimeline *_obj = (DeformTimeline *) obj; + return _obj->getCurvePercent(time, frame); +} + +spine_size_t spine_deform_timeline_get_frame_count(spine_deform_timeline obj) { + if (!obj) return nullptr; + DeformTimeline *_obj = (DeformTimeline *) obj; + return _obj->getFrameCount(); +} + +void spine_deform_timeline_apply(spine_deform_timeline obj, spine_skeleton skeleton, float lastTime, float time, void * pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction, spine_bool appliedPose) { + if (!obj) return ; + DeformTimeline *_obj = (DeformTimeline *) obj; + _obj->apply(skeleton, lastTime, time, (Vector *) pEvents, alpha, blend, direction, appliedPose); +} diff --git a/spine-c-new/src/generated/deform_timeline.h b/spine-c-new/src/generated/deform_timeline.h new file mode 100644 index 000000000..5a0800a23 --- /dev/null +++ b/spine-c-new/src/generated/deform_timeline.h @@ -0,0 +1,59 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#ifndef SPINE_C_DEFORMTIMELINE_H +#define SPINE_C_DEFORMTIMELINE_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include "../custom.h" + +SPINE_OPAQUE_TYPE(spine_deform_timeline) + +SPINE_C_EXPORT spine_deform_timeline spine_deform_timeline_create(spine_size_t frameCount, spine_size_t bezierCount, int32_t slotIndex, spine_vertex_attachment attachment); +SPINE_C_EXPORT void spine_deform_timeline_dispose(spine_deform_timeline obj); +SPINE_C_EXPORT spine_rtti spine_deform_timeline_get_rtti(spine_deform_timeline obj); +SPINE_C_EXPORT void spine_deform_timeline_set_frame(spine_deform_timeline obj, int32_t frameIndex, float time, void * vertices); +SPINE_C_EXPORT void * spine_deform_timeline_get_vertices(spine_deform_timeline obj); +SPINE_C_EXPORT int32_t spine_deform_timeline_get_num_vertices(spine_deform_timeline obj); +SPINE_C_EXPORT spine_vector + +using namespace spine; + +spine_draw_order_timeline spine_draw_order_timeline_create(spine_size_t frameCount) { + DrawOrderTimeline *obj = new (__FILE__, __LINE__) DrawOrderTimeline(frameCount); + return (spine_draw_order_timeline) obj; +} + +void spine_draw_order_timeline_dispose(spine_draw_order_timeline obj) { + if (!obj) return; + delete (DrawOrderTimeline *) obj; +} + +spine_rtti spine_draw_order_timeline_get_rtti(spine_draw_order_timeline obj) { + if (!obj) return nullptr; + DrawOrderTimeline *_obj = (DrawOrderTimeline *) obj; + return (spine_rtti) &_obj->getRTTI(); +} + +void spine_draw_order_timeline_apply(spine_draw_order_timeline obj, spine_skeleton skeleton, float lastTime, float time, void * pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction, spine_bool appliedPose) { + if (!obj) return ; + DrawOrderTimeline *_obj = (DrawOrderTimeline *) obj; + _obj->apply(skeleton, lastTime, time, (Vector *) pEvents, alpha, blend, direction, appliedPose); +} + +spine_size_t spine_draw_order_timeline_get_frame_count(spine_draw_order_timeline obj) { + if (!obj) return nullptr; + DrawOrderTimeline *_obj = (DrawOrderTimeline *) obj; + return _obj->getFrameCount(); +} + +void * spine_draw_order_timeline_get_draw_orders(spine_draw_order_timeline obj) { + if (!obj) return nullptr; + DrawOrderTimeline *_obj = (DrawOrderTimeline *) obj; + return _obj->getDrawOrders(); +} + +int32_t spine_draw_order_timeline_get_num_draw_orders(spine_draw_order_timeline obj) { + if (!obj) return 0; + DrawOrderTimeline *_obj = (DrawOrderTimeline *) obj; + return (int32_t) _obj->getDrawOrders().size(); +} + +spine_vectorgetDrawOrders().buffer(); +} + +void spine_draw_order_timeline_set_frame(spine_draw_order_timeline obj, spine_size_t frame, float time, int32_t * drawOrder) { + if (!obj) return ; + DrawOrderTimeline *_obj = (DrawOrderTimeline *) obj; + _obj->setFrame(frame, time, (Vector *) drawOrder); +} + +spine_size_t spine_draw_order_timeline_get_frame_entries(spine_draw_order_timeline obj) { + if (!obj) return nullptr; + DrawOrderTimeline *_obj = (DrawOrderTimeline *) obj; + return _obj->getFrameEntries(); +} + +void * spine_draw_order_timeline_get_frames(spine_draw_order_timeline obj) { + if (!obj) return nullptr; + DrawOrderTimeline *_obj = (DrawOrderTimeline *) obj; + return _obj->getFrames(); +} + +int32_t spine_draw_order_timeline_get_num_frames(spine_draw_order_timeline obj) { + if (!obj) return 0; + DrawOrderTimeline *_obj = (DrawOrderTimeline *) obj; + return (int32_t) _obj->getFrames().size(); +} + +spine_float *spine_draw_order_timeline_get_frames(spine_draw_order_timeline obj) { + if (!obj) return nullptr; + DrawOrderTimeline *_obj = (DrawOrderTimeline *) obj; + return (spine_float *) _obj->getFrames().buffer(); +} + +float spine_draw_order_timeline_get_duration(spine_draw_order_timeline obj) { + if (!obj) return 0; + DrawOrderTimeline *_obj = (DrawOrderTimeline *) obj; + return _obj->getDuration(); +} + +void * spine_draw_order_timeline_get_property_ids(spine_draw_order_timeline obj) { + if (!obj) return nullptr; + DrawOrderTimeline *_obj = (DrawOrderTimeline *) obj; + return _obj->getPropertyIds(); +} + +int32_t spine_draw_order_timeline_get_num_property_ids(spine_draw_order_timeline obj) { + if (!obj) return 0; + DrawOrderTimeline *_obj = (DrawOrderTimeline *) obj; + return (int32_t) _obj->getPropertyIds().size(); +} + +spine_property_id *spine_draw_order_timeline_get_property_ids(spine_draw_order_timeline obj) { + if (!obj) return nullptr; + DrawOrderTimeline *_obj = (DrawOrderTimeline *) obj; + return (spine_property_id *) _obj->getPropertyIds().buffer(); +} diff --git a/spine-c-new/src/generated/draw_order_timeline.h b/spine-c-new/src/generated/draw_order_timeline.h new file mode 100644 index 000000000..bb66223b3 --- /dev/null +++ b/spine-c-new/src/generated/draw_order_timeline.h @@ -0,0 +1,63 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#ifndef SPINE_C_DRAWORDERTIMELINE_H +#define SPINE_C_DRAWORDERTIMELINE_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include "../custom.h" + +SPINE_OPAQUE_TYPE(spine_draw_order_timeline) + +SPINE_C_EXPORT spine_draw_order_timeline spine_draw_order_timeline_create(spine_size_t frameCount); +SPINE_C_EXPORT void spine_draw_order_timeline_dispose(spine_draw_order_timeline obj); +SPINE_C_EXPORT spine_rtti spine_draw_order_timeline_get_rtti(spine_draw_order_timeline obj); +SPINE_C_EXPORT void spine_draw_order_timeline_apply(spine_draw_order_timeline obj, spine_skeleton skeleton, float lastTime, float time, void * pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction, spine_bool appliedPose); +SPINE_C_EXPORT spine_size_t spine_draw_order_timeline_get_frame_count(spine_draw_order_timeline obj); +SPINE_C_EXPORT void * spine_draw_order_timeline_get_draw_orders(spine_draw_order_timeline obj); +SPINE_C_EXPORT int32_t spine_draw_order_timeline_get_num_draw_orders(spine_draw_order_timeline obj); +SPINE_C_EXPORT spine_vector + +using namespace spine; + +spine_event spine_event_create(float time, spine_event_data data) { + Event *obj = new (__FILE__, __LINE__) Event(time, data); + return (spine_event) obj; +} + +void spine_event_dispose(spine_event obj) { + if (!obj) return; + delete (Event *) obj; +} + +spine_event_data spine_event_get_data(spine_event obj) { + if (!obj) return nullptr; + Event *_obj = (Event *) obj; + return _obj->getData(); +} + +float spine_event_get_time(spine_event obj) { + if (!obj) return 0; + Event *_obj = (Event *) obj; + return _obj->getTime(); +} + +int32_t spine_event_get_int(spine_event obj) { + if (!obj) return 0; + Event *_obj = (Event *) obj; + return _obj->getInt(); +} + +void spine_event_set_int(spine_event obj, int32_t value) { + if (!obj) return; + Event *_obj = (Event *) obj; + _obj->setInt(value); +} + +float spine_event_get_float(spine_event obj) { + if (!obj) return 0; + Event *_obj = (Event *) obj; + return _obj->getFloat(); +} + +void spine_event_set_float(spine_event obj, float value) { + if (!obj) return; + Event *_obj = (Event *) obj; + _obj->setFloat(value); +} + +const utf8 * spine_event_get_string(spine_event obj) { + if (!obj) return nullptr; + Event *_obj = (Event *) obj; + return (const utf8 *) _obj->getString().buffer(); +} + +void spine_event_set_string(spine_event obj, const utf8 * value) { + if (!obj) return; + Event *_obj = (Event *) obj; + _obj->setString(String(value)); +} + +float spine_event_get_volume(spine_event obj) { + if (!obj) return 0; + Event *_obj = (Event *) obj; + return _obj->getVolume(); +} + +void spine_event_set_volume(spine_event obj, float value) { + if (!obj) return; + Event *_obj = (Event *) obj; + _obj->setVolume(value); +} + +float spine_event_get_balance(spine_event obj) { + if (!obj) return 0; + Event *_obj = (Event *) obj; + return _obj->getBalance(); +} + +void spine_event_set_balance(spine_event obj, float value) { + if (!obj) return; + Event *_obj = (Event *) obj; + _obj->setBalance(value); +} diff --git a/spine-c-new/src/generated/event.h b/spine-c-new/src/generated/event.h new file mode 100644 index 000000000..bf8b987ff --- /dev/null +++ b/spine-c-new/src/generated/event.h @@ -0,0 +1,60 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#ifndef SPINE_C_EVENT_H +#define SPINE_C_EVENT_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include "../custom.h" + +SPINE_OPAQUE_TYPE(spine_event) + +SPINE_C_EXPORT spine_event spine_event_create(float time, spine_event_data data); +SPINE_C_EXPORT void spine_event_dispose(spine_event obj); +SPINE_C_EXPORT spine_event_data spine_event_get_data(spine_event obj); +SPINE_C_EXPORT float spine_event_get_time(spine_event obj); +SPINE_C_EXPORT int32_t spine_event_get_int(spine_event obj); +SPINE_C_EXPORT void spine_event_set_int(spine_event obj, int32_t value); +SPINE_C_EXPORT float spine_event_get_float(spine_event obj); +SPINE_C_EXPORT void spine_event_set_float(spine_event obj, float value); +SPINE_C_EXPORT const utf8 * spine_event_get_string(spine_event obj); +SPINE_C_EXPORT void spine_event_set_string(spine_event obj, const utf8 * value); +SPINE_C_EXPORT float spine_event_get_volume(spine_event obj); +SPINE_C_EXPORT void spine_event_set_volume(spine_event obj, float value); +SPINE_C_EXPORT float spine_event_get_balance(spine_event obj); +SPINE_C_EXPORT void spine_event_set_balance(spine_event obj, float value); + +#ifdef __cplusplus +} +#endif + +#endif // SPINE_C_EVENT_H \ No newline at end of file diff --git a/spine-c-new/src/generated/event_data.cpp b/spine-c-new/src/generated/event_data.cpp new file mode 100644 index 000000000..fa036960d --- /dev/null +++ b/spine-c-new/src/generated/event_data.cpp @@ -0,0 +1,85 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#include "event_data.h" +#include + +using namespace spine; + +spine_event_data spine_event_data_create(const utf8 * name) { + EventData *obj = new (__FILE__, __LINE__) EventData(String(name)); + return (spine_event_data) obj; +} + +void spine_event_data_dispose(spine_event_data obj) { + if (!obj) return; + delete (EventData *) obj; +} + +const utf8 * spine_event_data_get_name(spine_event_data obj) { + if (!obj) return nullptr; + EventData *_obj = (EventData *) obj; + return (const utf8 *) _obj->getName().buffer(); +} + +int32_t spine_event_data_get_int_value(spine_event_data obj) { + if (!obj) return 0; + EventData *_obj = (EventData *) obj; + return _obj->getIntValue(); +} + +float spine_event_data_get_float_value(spine_event_data obj) { + if (!obj) return 0; + EventData *_obj = (EventData *) obj; + return _obj->getFloatValue(); +} + +const utf8 * spine_event_data_get_string_value(spine_event_data obj) { + if (!obj) return nullptr; + EventData *_obj = (EventData *) obj; + return (const utf8 *) _obj->getStringValue().buffer(); +} + +const utf8 * spine_event_data_get_audio_path(spine_event_data obj) { + if (!obj) return nullptr; + EventData *_obj = (EventData *) obj; + return (const utf8 *) _obj->getAudioPath().buffer(); +} + +float spine_event_data_get_volume(spine_event_data obj) { + if (!obj) return 0; + EventData *_obj = (EventData *) obj; + return _obj->getVolume(); +} + +float spine_event_data_get_balance(spine_event_data obj) { + if (!obj) return 0; + EventData *_obj = (EventData *) obj; + return _obj->getBalance(); +} diff --git a/spine-c-new/src/generated/event_data.h b/spine-c-new/src/generated/event_data.h new file mode 100644 index 000000000..7bdee5b5f --- /dev/null +++ b/spine-c-new/src/generated/event_data.h @@ -0,0 +1,55 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#ifndef SPINE_C_EVENTDATA_H +#define SPINE_C_EVENTDATA_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include "../custom.h" + +SPINE_OPAQUE_TYPE(spine_event_data) + +SPINE_C_EXPORT spine_event_data spine_event_data_create(const utf8 * name); +SPINE_C_EXPORT void spine_event_data_dispose(spine_event_data obj); +SPINE_C_EXPORT const utf8 * spine_event_data_get_name(spine_event_data obj); +SPINE_C_EXPORT int32_t spine_event_data_get_int_value(spine_event_data obj); +SPINE_C_EXPORT float spine_event_data_get_float_value(spine_event_data obj); +SPINE_C_EXPORT const utf8 * spine_event_data_get_string_value(spine_event_data obj); +SPINE_C_EXPORT const utf8 * spine_event_data_get_audio_path(spine_event_data obj); +SPINE_C_EXPORT float spine_event_data_get_volume(spine_event_data obj); +SPINE_C_EXPORT float spine_event_data_get_balance(spine_event_data obj); + +#ifdef __cplusplus +} +#endif + +#endif // SPINE_C_EVENTDATA_H \ No newline at end of file diff --git a/spine-c-new/src/generated/event_queue_entry.cpp b/spine-c-new/src/generated/event_queue_entry.cpp new file mode 100644 index 000000000..eb971e8a1 --- /dev/null +++ b/spine-c-new/src/generated/event_queue_entry.cpp @@ -0,0 +1,43 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#include "event_queue_entry.h" +#include + +using namespace spine; + +spine_event_queue_entry spine_event_queue_entry_create(spine_event_type eventType, spine_track_entry trackEntry, spine_event event) { + EventQueueEntry *obj = new (__FILE__, __LINE__) EventQueueEntry(eventType, (TrackEntry *) trackEntry, (Event *) event); + return (spine_event_queue_entry) obj; +} + +void spine_event_queue_entry_dispose(spine_event_queue_entry obj) { + if (!obj) return; + delete (EventQueueEntry *) obj; +} diff --git a/spine-c-new/src/generated/event_queue_entry.h b/spine-c-new/src/generated/event_queue_entry.h new file mode 100644 index 000000000..1912ffbe4 --- /dev/null +++ b/spine-c-new/src/generated/event_queue_entry.h @@ -0,0 +1,48 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#ifndef SPINE_C_EVENTQUEUEENTRY_H +#define SPINE_C_EVENTQUEUEENTRY_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include "../custom.h" + +SPINE_OPAQUE_TYPE(spine_event_queue_entry) + +SPINE_C_EXPORT spine_event_queue_entry spine_event_queue_entry_create(spine_event_type eventType, spine_track_entry trackEntry, spine_event event); +SPINE_C_EXPORT void spine_event_queue_entry_dispose(spine_event_queue_entry obj); + +#ifdef __cplusplus +} +#endif + +#endif // SPINE_C_EVENTQUEUEENTRY_H \ No newline at end of file diff --git a/spine-c-new/src/generated/event_timeline.cpp b/spine-c-new/src/generated/event_timeline.cpp new file mode 100644 index 000000000..254380299 --- /dev/null +++ b/spine-c-new/src/generated/event_timeline.cpp @@ -0,0 +1,133 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#include "event_timeline.h" +#include + +using namespace spine; + +spine_event_timeline spine_event_timeline_create(spine_size_t frameCount) { + EventTimeline *obj = new (__FILE__, __LINE__) EventTimeline(frameCount); + return (spine_event_timeline) obj; +} + +void spine_event_timeline_dispose(spine_event_timeline obj) { + if (!obj) return; + delete (EventTimeline *) obj; +} + +spine_rtti spine_event_timeline_get_rtti(spine_event_timeline obj) { + if (!obj) return nullptr; + EventTimeline *_obj = (EventTimeline *) obj; + return (spine_rtti) &_obj->getRTTI(); +} + +void spine_event_timeline_apply(spine_event_timeline obj, spine_skeleton skeleton, float lastTime, float time, void * pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction, spine_bool appliedPose) { + if (!obj) return ; + EventTimeline *_obj = (EventTimeline *) obj; + _obj->apply(skeleton, lastTime, time, (Vector *) pEvents, alpha, blend, direction, appliedPose); +} + +spine_size_t spine_event_timeline_get_frame_count(spine_event_timeline obj) { + if (!obj) return nullptr; + EventTimeline *_obj = (EventTimeline *) obj; + return _obj->getFrameCount(); +} + +void * spine_event_timeline_get_events(spine_event_timeline obj) { + if (!obj) return nullptr; + EventTimeline *_obj = (EventTimeline *) obj; + return (void *) _obj->getEvents(); +} + +int32_t spine_event_timeline_get_num_events(spine_event_timeline obj) { + if (!obj) return 0; + EventTimeline *_obj = (EventTimeline *) obj; + return (int32_t) _obj->getEvents().size(); +} + +spine_event *spine_event_timeline_get_events(spine_event_timeline obj) { + if (!obj) return nullptr; + EventTimeline *_obj = (EventTimeline *) obj; + return (spine_event *) _obj->getEvents().buffer(); +} + +void spine_event_timeline_set_frame(spine_event_timeline obj, spine_size_t frame, spine_event event) { + if (!obj) return ; + EventTimeline *_obj = (EventTimeline *) obj; + _obj->setFrame(frame, (Event *) event); +} + +spine_size_t spine_event_timeline_get_frame_entries(spine_event_timeline obj) { + if (!obj) return nullptr; + EventTimeline *_obj = (EventTimeline *) obj; + return _obj->getFrameEntries(); +} + +void * spine_event_timeline_get_frames(spine_event_timeline obj) { + if (!obj) return nullptr; + EventTimeline *_obj = (EventTimeline *) obj; + return _obj->getFrames(); +} + +int32_t spine_event_timeline_get_num_frames(spine_event_timeline obj) { + if (!obj) return 0; + EventTimeline *_obj = (EventTimeline *) obj; + return (int32_t) _obj->getFrames().size(); +} + +spine_float *spine_event_timeline_get_frames(spine_event_timeline obj) { + if (!obj) return nullptr; + EventTimeline *_obj = (EventTimeline *) obj; + return (spine_float *) _obj->getFrames().buffer(); +} + +float spine_event_timeline_get_duration(spine_event_timeline obj) { + if (!obj) return 0; + EventTimeline *_obj = (EventTimeline *) obj; + return _obj->getDuration(); +} + +void * spine_event_timeline_get_property_ids(spine_event_timeline obj) { + if (!obj) return nullptr; + EventTimeline *_obj = (EventTimeline *) obj; + return _obj->getPropertyIds(); +} + +int32_t spine_event_timeline_get_num_property_ids(spine_event_timeline obj) { + if (!obj) return 0; + EventTimeline *_obj = (EventTimeline *) obj; + return (int32_t) _obj->getPropertyIds().size(); +} + +spine_property_id *spine_event_timeline_get_property_ids(spine_event_timeline obj) { + if (!obj) return nullptr; + EventTimeline *_obj = (EventTimeline *) obj; + return (spine_property_id *) _obj->getPropertyIds().buffer(); +} diff --git a/spine-c-new/src/generated/event_timeline.h b/spine-c-new/src/generated/event_timeline.h new file mode 100644 index 000000000..3661c41ca --- /dev/null +++ b/spine-c-new/src/generated/event_timeline.h @@ -0,0 +1,63 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#ifndef SPINE_C_EVENTTIMELINE_H +#define SPINE_C_EVENTTIMELINE_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include "../custom.h" + +SPINE_OPAQUE_TYPE(spine_event_timeline) + +SPINE_C_EXPORT spine_event_timeline spine_event_timeline_create(spine_size_t frameCount); +SPINE_C_EXPORT void spine_event_timeline_dispose(spine_event_timeline obj); +SPINE_C_EXPORT spine_rtti spine_event_timeline_get_rtti(spine_event_timeline obj); +SPINE_C_EXPORT void spine_event_timeline_apply(spine_event_timeline obj, spine_skeleton skeleton, float lastTime, float time, void * pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction, spine_bool appliedPose); +SPINE_C_EXPORT spine_size_t spine_event_timeline_get_frame_count(spine_event_timeline obj); +SPINE_C_EXPORT void * spine_event_timeline_get_events(spine_event_timeline obj); +SPINE_C_EXPORT int32_t spine_event_timeline_get_num_events(spine_event_timeline obj); +SPINE_C_EXPORT spine_event *spine_event_timeline_get_events(spine_event_timeline obj); +SPINE_C_EXPORT void spine_event_timeline_set_frame(spine_event_timeline obj, spine_size_t frame, spine_event event); +SPINE_C_EXPORT spine_size_t spine_event_timeline_get_frame_entries(spine_event_timeline obj); +SPINE_C_EXPORT void * spine_event_timeline_get_frames(spine_event_timeline obj); +SPINE_C_EXPORT int32_t spine_event_timeline_get_num_frames(spine_event_timeline obj); +SPINE_C_EXPORT spine_float *spine_event_timeline_get_frames(spine_event_timeline obj); +SPINE_C_EXPORT float spine_event_timeline_get_duration(spine_event_timeline obj); +SPINE_C_EXPORT void * spine_event_timeline_get_property_ids(spine_event_timeline obj); +SPINE_C_EXPORT int32_t spine_event_timeline_get_num_property_ids(spine_event_timeline obj); +SPINE_C_EXPORT spine_property_id *spine_event_timeline_get_property_ids(spine_event_timeline obj); + +#ifdef __cplusplus +} +#endif + +#endif // SPINE_C_EVENTTIMELINE_H \ No newline at end of file diff --git a/spine-c-new/src/generated/event_type.h b/spine-c-new/src/generated/event_type.h new file mode 100644 index 000000000..563d86f6c --- /dev/null +++ b/spine-c-new/src/generated/event_type.h @@ -0,0 +1,52 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#ifndef SPINE_C_EVENTTYPE_H +#define SPINE_C_EVENTTYPE_H + +#include "../../custom.h" + +#ifdef __cplusplus +extern "C" { +#endif + +typedef enum spine_event_type { + SPINE_EVENT_TYPE_EVENT_TYPE_START = 0, + SPINE_EVENT_TYPE_EVENT_TYPE_INTERRUPT, + SPINE_EVENT_TYPE_EVENT_TYPE_END, + SPINE_EVENT_TYPE_EVENT_TYPE_DISPOSE, + SPINE_EVENT_TYPE_EVENT_TYPE_COMPLETE, + SPINE_EVENT_TYPE_EVENT_TYPE_EVENT +} spine_event_type; + +#ifdef __cplusplus +} +#endif + +#endif // SPINE_C_EVENTTYPE_H \ No newline at end of file diff --git a/spine-c-new/src/generated/format.h b/spine-c-new/src/generated/format.h new file mode 100644 index 000000000..261dc6ff2 --- /dev/null +++ b/spine-c-new/src/generated/format.h @@ -0,0 +1,53 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#ifndef SPINE_C_FORMAT_H +#define SPINE_C_FORMAT_H + +#include "../../custom.h" + +#ifdef __cplusplus +extern "C" { +#endif + +typedef enum spine_format { + SPINE_FORMAT_FORMAT_ALPHA, + SPINE_FORMAT_FORMAT_INTENSITY, + SPINE_FORMAT_FORMAT_LUMINANCE_ALPHA, + SPINE_FORMAT_FORMAT_RGB565, + SPINE_FORMAT_FORMAT_RGBA4444, + SPINE_FORMAT_FORMAT_RGB888, + SPINE_FORMAT_FORMAT_RGBA8888 +} spine_format; + +#ifdef __cplusplus +} +#endif + +#endif // SPINE_C_FORMAT_H \ No newline at end of file diff --git a/spine-c-new/src/generated/from_property.cpp b/spine-c-new/src/generated/from_property.cpp new file mode 100644 index 000000000..0909007ab --- /dev/null +++ b/spine-c-new/src/generated/from_property.cpp @@ -0,0 +1,49 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#include "from_property.h" +#include + +using namespace spine; + +spine_from_property spine_from_property_create(void) { + FromProperty *obj = new (__FILE__, __LINE__) FromProperty(); + return (spine_from_property) obj; +} + +void spine_from_property_dispose(spine_from_property obj) { + if (!obj) return; + delete (FromProperty *) obj; +} + +float spine_from_property_value(spine_from_property obj, spine_skeleton skeleton, spine_bone_pose source, spine_bool local, spine_float offsets) { + if (!obj) return 0; + FromProperty *_obj = (FromProperty *) obj; + return _obj->value(skeleton, source, local, (float *) offsets); +} diff --git a/spine-c-new/src/generated/from_property.h b/spine-c-new/src/generated/from_property.h new file mode 100644 index 000000000..a1aca63de --- /dev/null +++ b/spine-c-new/src/generated/from_property.h @@ -0,0 +1,49 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#ifndef SPINE_C_FROMPROPERTY_H +#define SPINE_C_FROMPROPERTY_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include "../custom.h" + +SPINE_OPAQUE_TYPE(spine_from_property) + +SPINE_C_EXPORT spine_from_property spine_from_property_create(void); +SPINE_C_EXPORT void spine_from_property_dispose(spine_from_property obj); +SPINE_C_EXPORT float spine_from_property_value(spine_from_property obj, spine_skeleton skeleton, spine_bone_pose source, spine_bool local, spine_float offsets); + +#ifdef __cplusplus +} +#endif + +#endif // SPINE_C_FROMPROPERTY_H \ No newline at end of file diff --git a/spine-c-new/src/generated/from_rotate.cpp b/spine-c-new/src/generated/from_rotate.cpp new file mode 100644 index 000000000..ba220bc6f --- /dev/null +++ b/spine-c-new/src/generated/from_rotate.cpp @@ -0,0 +1,44 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#include "from_rotate.h" +#include + +using namespace spine; + +void spine_from_rotate_dispose(spine_from_rotate obj) { + if (!obj) return; + delete (FromRotate *) obj; +} + +float spine_from_rotate_value(spine_from_rotate obj, spine_skeleton skeleton, spine_bone_pose source, spine_bool local, spine_float offsets) { + if (!obj) return 0; + FromRotate *_obj = (FromRotate *) obj; + return _obj->value(skeleton, source, local, (float *) offsets); +} diff --git a/spine-c-new/src/generated/from_rotate.h b/spine-c-new/src/generated/from_rotate.h new file mode 100644 index 000000000..f213dba5a --- /dev/null +++ b/spine-c-new/src/generated/from_rotate.h @@ -0,0 +1,48 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#ifndef SPINE_C_FROMROTATE_H +#define SPINE_C_FROMROTATE_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include "../custom.h" + +SPINE_OPAQUE_TYPE(spine_from_rotate) + +SPINE_C_EXPORT void spine_from_rotate_dispose(spine_from_rotate obj); +SPINE_C_EXPORT float spine_from_rotate_value(spine_from_rotate obj, spine_skeleton skeleton, spine_bone_pose source, spine_bool local, spine_float offsets); + +#ifdef __cplusplus +} +#endif + +#endif // SPINE_C_FROMROTATE_H \ No newline at end of file diff --git a/spine-c-new/src/generated/from_scale_x.cpp b/spine-c-new/src/generated/from_scale_x.cpp new file mode 100644 index 000000000..89c9692eb --- /dev/null +++ b/spine-c-new/src/generated/from_scale_x.cpp @@ -0,0 +1,44 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#include "from_scale_x.h" +#include + +using namespace spine; + +void spine_from_scale_x_dispose(spine_from_scale_x obj) { + if (!obj) return; + delete (FromScaleX *) obj; +} + +float spine_from_scale_x_value(spine_from_scale_x obj, spine_skeleton skeleton, spine_bone_pose source, spine_bool local, spine_float offsets) { + if (!obj) return 0; + FromScaleX *_obj = (FromScaleX *) obj; + return _obj->value(skeleton, source, local, (float *) offsets); +} diff --git a/spine-c-new/src/generated/from_scale_x.h b/spine-c-new/src/generated/from_scale_x.h new file mode 100644 index 000000000..79898b862 --- /dev/null +++ b/spine-c-new/src/generated/from_scale_x.h @@ -0,0 +1,48 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#ifndef SPINE_C_FROMSCALEX_H +#define SPINE_C_FROMSCALEX_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include "../custom.h" + +SPINE_OPAQUE_TYPE(spine_from_scale_x) + +SPINE_C_EXPORT void spine_from_scale_x_dispose(spine_from_scale_x obj); +SPINE_C_EXPORT float spine_from_scale_x_value(spine_from_scale_x obj, spine_skeleton skeleton, spine_bone_pose source, spine_bool local, spine_float offsets); + +#ifdef __cplusplus +} +#endif + +#endif // SPINE_C_FROMSCALEX_H \ No newline at end of file diff --git a/spine-c-new/src/generated/from_scale_y.cpp b/spine-c-new/src/generated/from_scale_y.cpp new file mode 100644 index 000000000..7739c7866 --- /dev/null +++ b/spine-c-new/src/generated/from_scale_y.cpp @@ -0,0 +1,44 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#include "from_scale_y.h" +#include + +using namespace spine; + +void spine_from_scale_y_dispose(spine_from_scale_y obj) { + if (!obj) return; + delete (FromScaleY *) obj; +} + +float spine_from_scale_y_value(spine_from_scale_y obj, spine_skeleton skeleton, spine_bone_pose source, spine_bool local, spine_float offsets) { + if (!obj) return 0; + FromScaleY *_obj = (FromScaleY *) obj; + return _obj->value(skeleton, source, local, (float *) offsets); +} diff --git a/spine-c-new/src/generated/from_scale_y.h b/spine-c-new/src/generated/from_scale_y.h new file mode 100644 index 000000000..ff633b0a0 --- /dev/null +++ b/spine-c-new/src/generated/from_scale_y.h @@ -0,0 +1,48 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#ifndef SPINE_C_FROMSCALEY_H +#define SPINE_C_FROMSCALEY_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include "../custom.h" + +SPINE_OPAQUE_TYPE(spine_from_scale_y) + +SPINE_C_EXPORT void spine_from_scale_y_dispose(spine_from_scale_y obj); +SPINE_C_EXPORT float spine_from_scale_y_value(spine_from_scale_y obj, spine_skeleton skeleton, spine_bone_pose source, spine_bool local, spine_float offsets); + +#ifdef __cplusplus +} +#endif + +#endif // SPINE_C_FROMSCALEY_H \ No newline at end of file diff --git a/spine-c-new/src/generated/from_shear_y.cpp b/spine-c-new/src/generated/from_shear_y.cpp new file mode 100644 index 000000000..f7d8bb240 --- /dev/null +++ b/spine-c-new/src/generated/from_shear_y.cpp @@ -0,0 +1,44 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#include "from_shear_y.h" +#include + +using namespace spine; + +void spine_from_shear_y_dispose(spine_from_shear_y obj) { + if (!obj) return; + delete (FromShearY *) obj; +} + +float spine_from_shear_y_value(spine_from_shear_y obj, spine_skeleton skeleton, spine_bone_pose source, spine_bool local, spine_float offsets) { + if (!obj) return 0; + FromShearY *_obj = (FromShearY *) obj; + return _obj->value(skeleton, source, local, (float *) offsets); +} diff --git a/spine-c-new/src/generated/from_shear_y.h b/spine-c-new/src/generated/from_shear_y.h new file mode 100644 index 000000000..19493b985 --- /dev/null +++ b/spine-c-new/src/generated/from_shear_y.h @@ -0,0 +1,48 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#ifndef SPINE_C_FROMSHEARY_H +#define SPINE_C_FROMSHEARY_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include "../custom.h" + +SPINE_OPAQUE_TYPE(spine_from_shear_y) + +SPINE_C_EXPORT void spine_from_shear_y_dispose(spine_from_shear_y obj); +SPINE_C_EXPORT float spine_from_shear_y_value(spine_from_shear_y obj, spine_skeleton skeleton, spine_bone_pose source, spine_bool local, spine_float offsets); + +#ifdef __cplusplus +} +#endif + +#endif // SPINE_C_FROMSHEARY_H \ No newline at end of file diff --git a/spine-c-new/src/generated/from_x.cpp b/spine-c-new/src/generated/from_x.cpp new file mode 100644 index 000000000..4b6bd1efc --- /dev/null +++ b/spine-c-new/src/generated/from_x.cpp @@ -0,0 +1,44 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#include "from_x.h" +#include + +using namespace spine; + +void spine_from_x_dispose(spine_from_x obj) { + if (!obj) return; + delete (FromX *) obj; +} + +float spine_from_x_value(spine_from_x obj, spine_skeleton skeleton, spine_bone_pose source, spine_bool local, spine_float offsets) { + if (!obj) return 0; + FromX *_obj = (FromX *) obj; + return _obj->value(skeleton, source, local, (float *) offsets); +} diff --git a/spine-c-new/src/generated/from_x.h b/spine-c-new/src/generated/from_x.h new file mode 100644 index 000000000..425b792d9 --- /dev/null +++ b/spine-c-new/src/generated/from_x.h @@ -0,0 +1,48 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#ifndef SPINE_C_FROMX_H +#define SPINE_C_FROMX_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include "../custom.h" + +SPINE_OPAQUE_TYPE(spine_from_x) + +SPINE_C_EXPORT void spine_from_x_dispose(spine_from_x obj); +SPINE_C_EXPORT float spine_from_x_value(spine_from_x obj, spine_skeleton skeleton, spine_bone_pose source, spine_bool local, spine_float offsets); + +#ifdef __cplusplus +} +#endif + +#endif // SPINE_C_FROMX_H \ No newline at end of file diff --git a/spine-c-new/src/generated/from_y.cpp b/spine-c-new/src/generated/from_y.cpp new file mode 100644 index 000000000..c7c940ff3 --- /dev/null +++ b/spine-c-new/src/generated/from_y.cpp @@ -0,0 +1,44 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#include "from_y.h" +#include + +using namespace spine; + +void spine_from_y_dispose(spine_from_y obj) { + if (!obj) return; + delete (FromY *) obj; +} + +float spine_from_y_value(spine_from_y obj, spine_skeleton skeleton, spine_bone_pose source, spine_bool local, spine_float offsets) { + if (!obj) return 0; + FromY *_obj = (FromY *) obj; + return _obj->value(skeleton, source, local, (float *) offsets); +} diff --git a/spine-c-new/src/generated/from_y.h b/spine-c-new/src/generated/from_y.h new file mode 100644 index 000000000..8c679e825 --- /dev/null +++ b/spine-c-new/src/generated/from_y.h @@ -0,0 +1,48 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#ifndef SPINE_C_FROMY_H +#define SPINE_C_FROMY_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include "../custom.h" + +SPINE_OPAQUE_TYPE(spine_from_y) + +SPINE_C_EXPORT void spine_from_y_dispose(spine_from_y obj); +SPINE_C_EXPORT float spine_from_y_value(spine_from_y obj, spine_skeleton skeleton, spine_bone_pose source, spine_bool local, spine_float offsets); + +#ifdef __cplusplus +} +#endif + +#endif // SPINE_C_FROMY_H \ No newline at end of file diff --git a/spine-c-new/src/generated/hash_map.cpp b/spine-c-new/src/generated/hash_map.cpp new file mode 100644 index 000000000..10debce77 --- /dev/null +++ b/spine-c-new/src/generated/hash_map.cpp @@ -0,0 +1,85 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#include "hash_map.h" +#include + +using namespace spine; + +spine_hash_map spine_hash_map_create(void) { + HashMap *obj = new (__FILE__, __LINE__) HashMap(); + return (spine_hash_map) obj; +} + +void spine_hash_map_dispose(spine_hash_map obj) { + if (!obj) return; + delete (HashMap *) obj; +} + +void spine_hash_map_clear(spine_hash_map obj) { + if (!obj) return ; + HashMap *_obj = (HashMap *) obj; + _obj->clear(); +} + +spine_size_t spine_hash_map_size(spine_hash_map obj) { + if (!obj) return nullptr; + HashMap *_obj = (HashMap *) obj; + return _obj->size(); +} + +void spine_hash_map_put(spine_hash_map obj, spine_k key, spine_v value) { + if (!obj) return ; + HashMap *_obj = (HashMap *) obj; + _obj->put(key, value); +} + +spine_bool spine_hash_map_add_all(spine_hash_map obj, void * keys, spine_v value) { + if (!obj) return 0; + HashMap *_obj = (HashMap *) obj; + return _obj->addAll((Vector &) keys, value); +} + +spine_bool spine_hash_map_contains_key(spine_hash_map obj, spine_k key) { + if (!obj) return 0; + HashMap *_obj = (HashMap *) obj; + return _obj->containsKey(key); +} + +spine_bool spine_hash_map_remove(spine_hash_map obj, spine_k key) { + if (!obj) return 0; + HashMap *_obj = (HashMap *) obj; + return _obj->remove(key); +} + +spine_entries spine_hash_map_get_entries(spine_hash_map obj) { + if (!obj) return nullptr; + HashMap *_obj = (HashMap *) obj; + return _obj->getEntries(); +} diff --git a/spine-c-new/src/generated/hash_map.h b/spine-c-new/src/generated/hash_map.h new file mode 100644 index 000000000..339f9c430 --- /dev/null +++ b/spine-c-new/src/generated/hash_map.h @@ -0,0 +1,55 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#ifndef SPINE_C_HASHMAP_H +#define SPINE_C_HASHMAP_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include "../custom.h" + +SPINE_OPAQUE_TYPE(spine_hash_map) + +SPINE_C_EXPORT spine_hash_map spine_hash_map_create(void); +SPINE_C_EXPORT void spine_hash_map_dispose(spine_hash_map obj); +SPINE_C_EXPORT void spine_hash_map_clear(spine_hash_map obj); +SPINE_C_EXPORT spine_size_t spine_hash_map_size(spine_hash_map obj); +SPINE_C_EXPORT void spine_hash_map_put(spine_hash_map obj, spine_k key, spine_v value); +SPINE_C_EXPORT spine_bool spine_hash_map_add_all(spine_hash_map obj, void * keys, spine_v value); +SPINE_C_EXPORT spine_bool spine_hash_map_contains_key(spine_hash_map obj, spine_k key); +SPINE_C_EXPORT spine_bool spine_hash_map_remove(spine_hash_map obj, spine_k key); +SPINE_C_EXPORT spine_entries spine_hash_map_get_entries(spine_hash_map obj); + +#ifdef __cplusplus +} +#endif + +#endif // SPINE_C_HASHMAP_H \ No newline at end of file diff --git a/spine-c-new/src/generated/ik_constraint.cpp b/spine-c-new/src/generated/ik_constraint.cpp new file mode 100644 index 000000000..21c879df5 --- /dev/null +++ b/spine-c-new/src/generated/ik_constraint.cpp @@ -0,0 +1,163 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#include "ik_constraint.h" +#include + +using namespace spine; + +spine_ik_constraint spine_ik_constraint_create(spine_ik_constraint_data data, spine_skeleton skeleton) { + IkConstraint *obj = new (__FILE__, __LINE__) IkConstraint(data, skeleton); + return (spine_ik_constraint) obj; +} + +void spine_ik_constraint_dispose(spine_ik_constraint obj) { + if (!obj) return; + delete (IkConstraint *) obj; +} + +spine_rtti spine_ik_constraint_get_rtti(spine_ik_constraint obj) { + if (!obj) return nullptr; + IkConstraint *_obj = (IkConstraint *) obj; + return (spine_rtti) &_obj->getRTTI(); +} + +spine_ik_constraint spine_ik_constraint_copy(spine_ik_constraint obj, spine_skeleton skeleton) { + if (!obj) return 0; + IkConstraint *_obj = (IkConstraint *) obj; + return (spine_ik_constraint) _obj->copy(skeleton); +} + +void spine_ik_constraint_update(spine_ik_constraint obj, spine_skeleton skeleton, spine_physics physics) { + if (!obj) return ; + IkConstraint *_obj = (IkConstraint *) obj; + _obj->update(skeleton, physics); +} + +void spine_ik_constraint_sort(spine_ik_constraint obj, spine_skeleton skeleton) { + if (!obj) return ; + IkConstraint *_obj = (IkConstraint *) obj; + _obj->sort(skeleton); +} + +spine_bool spine_ik_constraint_is_source_active(spine_ik_constraint obj) { + if (!obj) return 0; + IkConstraint *_obj = (IkConstraint *) obj; + return _obj->isSourceActive(); +} + +spine_ik_constraint_data spine_ik_constraint_get_data(spine_ik_constraint obj) { + if (!obj) return 0; + IkConstraint *_obj = (IkConstraint *) obj; + return _obj->getData(); +} + +void * spine_ik_constraint_get_bones(spine_ik_constraint obj) { + if (!obj) return nullptr; + IkConstraint *_obj = (IkConstraint *) obj; + return (void *) _obj->getBones(); +} + +int32_t spine_ik_constraint_get_num_bones(spine_ik_constraint obj) { + if (!obj) return 0; + IkConstraint *_obj = (IkConstraint *) obj; + return (int32_t) _obj->getBones().size(); +} + +spine_bone_pose *spine_ik_constraint_get_bones(spine_ik_constraint obj) { + if (!obj) return nullptr; + IkConstraint *_obj = (IkConstraint *) obj; + return (spine_bone_pose *) _obj->getBones().buffer(); +} + +spine_bone spine_ik_constraint_get_target(spine_ik_constraint obj) { + if (!obj) return nullptr; + IkConstraint *_obj = (IkConstraint *) obj; + return (spine_bone) _obj->getTarget(); +} + +void spine_ik_constraint_set_target(spine_ik_constraint obj, spine_bone value) { + if (!obj) return; + IkConstraint *_obj = (IkConstraint *) obj; + _obj->setTarget((Bone *) value); +} + +void spine_ik_constraint_pose(spine_ik_constraint obj) { + if (!obj) return ; + IkConstraint *_obj = (IkConstraint *) obj; + _obj->pose(); +} + +void spine_ik_constraint_setup_pose(spine_ik_constraint obj) { + if (!obj) return ; + IkConstraint *_obj = (IkConstraint *) obj; + _obj->setupPose(); +} + +spine_ik_constraint_pose spine_ik_constraint_get_pose(spine_ik_constraint obj) { + if (!obj) return 0; + IkConstraint *_obj = (IkConstraint *) obj; + return _obj->getPose(); +} + +spine_ik_constraint_pose spine_ik_constraint_get_applied_pose(spine_ik_constraint obj) { + if (!obj) return 0; + IkConstraint *_obj = (IkConstraint *) obj; + return _obj->getAppliedPose(); +} + +void spine_ik_constraint_reset_constrained(spine_ik_constraint obj) { + if (!obj) return ; + IkConstraint *_obj = (IkConstraint *) obj; + _obj->resetConstrained(); +} + +void spine_ik_constraint_constrained(spine_ik_constraint obj) { + if (!obj) return ; + IkConstraint *_obj = (IkConstraint *) obj; + _obj->constrained(); +} + +spine_bool spine_ik_constraint_is_pose_equal_to_applied(spine_ik_constraint obj) { + if (!obj) return 0; + IkConstraint *_obj = (IkConstraint *) obj; + return _obj->isPoseEqualToApplied(); +} + +spine_bool spine_ik_constraint_is_active(spine_ik_constraint obj) { + if (!obj) return 0; + IkConstraint *_obj = (IkConstraint *) obj; + return _obj->isActive(); +} + +void spine_ik_constraint_set_active(spine_ik_constraint obj, spine_bool value) { + if (!obj) return; + IkConstraint *_obj = (IkConstraint *) obj; + _obj->setActive(value); +} diff --git a/spine-c-new/src/generated/ik_constraint.h b/spine-c-new/src/generated/ik_constraint.h new file mode 100644 index 000000000..db4af13a8 --- /dev/null +++ b/spine-c-new/src/generated/ik_constraint.h @@ -0,0 +1,68 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#ifndef SPINE_C_IKCONSTRAINT_H +#define SPINE_C_IKCONSTRAINT_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include "../custom.h" + +SPINE_OPAQUE_TYPE(spine_ik_constraint) + +SPINE_C_EXPORT spine_ik_constraint spine_ik_constraint_create(spine_ik_constraint_data data, spine_skeleton skeleton); +SPINE_C_EXPORT void spine_ik_constraint_dispose(spine_ik_constraint obj); +SPINE_C_EXPORT spine_rtti spine_ik_constraint_get_rtti(spine_ik_constraint obj); +SPINE_C_EXPORT spine_ik_constraint spine_ik_constraint_copy(spine_ik_constraint obj, spine_skeleton skeleton); +SPINE_C_EXPORT void spine_ik_constraint_update(spine_ik_constraint obj, spine_skeleton skeleton, spine_physics physics); +SPINE_C_EXPORT void spine_ik_constraint_sort(spine_ik_constraint obj, spine_skeleton skeleton); +SPINE_C_EXPORT spine_bool spine_ik_constraint_is_source_active(spine_ik_constraint obj); +SPINE_C_EXPORT spine_ik_constraint_data spine_ik_constraint_get_data(spine_ik_constraint obj); +SPINE_C_EXPORT void * spine_ik_constraint_get_bones(spine_ik_constraint obj); +SPINE_C_EXPORT int32_t spine_ik_constraint_get_num_bones(spine_ik_constraint obj); +SPINE_C_EXPORT spine_bone_pose *spine_ik_constraint_get_bones(spine_ik_constraint obj); +SPINE_C_EXPORT spine_bone spine_ik_constraint_get_target(spine_ik_constraint obj); +SPINE_C_EXPORT void spine_ik_constraint_set_target(spine_ik_constraint obj, spine_bone value); +SPINE_C_EXPORT void spine_ik_constraint_pose(spine_ik_constraint obj); +SPINE_C_EXPORT void spine_ik_constraint_setup_pose(spine_ik_constraint obj); +SPINE_C_EXPORT spine_ik_constraint_pose spine_ik_constraint_get_pose(spine_ik_constraint obj); +SPINE_C_EXPORT spine_ik_constraint_pose spine_ik_constraint_get_applied_pose(spine_ik_constraint obj); +SPINE_C_EXPORT void spine_ik_constraint_reset_constrained(spine_ik_constraint obj); +SPINE_C_EXPORT void spine_ik_constraint_constrained(spine_ik_constraint obj); +SPINE_C_EXPORT spine_bool spine_ik_constraint_is_pose_equal_to_applied(spine_ik_constraint obj); +SPINE_C_EXPORT spine_bool spine_ik_constraint_is_active(spine_ik_constraint obj); +SPINE_C_EXPORT void spine_ik_constraint_set_active(spine_ik_constraint obj, spine_bool value); + +#ifdef __cplusplus +} +#endif + +#endif // SPINE_C_IKCONSTRAINT_H \ No newline at end of file diff --git a/spine-c-new/src/generated/ik_constraint_data.cpp b/spine-c-new/src/generated/ik_constraint_data.cpp new file mode 100644 index 000000000..ef1901a85 --- /dev/null +++ b/spine-c-new/src/generated/ik_constraint_data.cpp @@ -0,0 +1,121 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#include "ik_constraint_data.h" +#include + +using namespace spine; + +spine_ik_constraint_data spine_ik_constraint_data_create(const utf8 * name) { + IkConstraintData *obj = new (__FILE__, __LINE__) IkConstraintData(String(name)); + return (spine_ik_constraint_data) obj; +} + +void spine_ik_constraint_data_dispose(spine_ik_constraint_data obj) { + if (!obj) return; + delete (IkConstraintData *) obj; +} + +spine_rtti spine_ik_constraint_data_get_rtti(spine_ik_constraint_data obj) { + if (!obj) return nullptr; + IkConstraintData *_obj = (IkConstraintData *) obj; + return (spine_rtti) &_obj->getRTTI(); +} + +spine_constraint spine_ik_constraint_data_create(spine_ik_constraint_data obj, spine_skeleton skeleton) { + if (!obj) return 0; + IkConstraintData *_obj = (IkConstraintData *) obj; + return (spine_constraint) _obj->create(skeleton); +} + +void * spine_ik_constraint_data_get_bones(spine_ik_constraint_data obj) { + if (!obj) return nullptr; + IkConstraintData *_obj = (IkConstraintData *) obj; + return (void *) _obj->getBones(); +} + +int32_t spine_ik_constraint_data_get_num_bones(spine_ik_constraint_data obj) { + if (!obj) return 0; + IkConstraintData *_obj = (IkConstraintData *) obj; + return (int32_t) _obj->getBones().size(); +} + +spine_bone_data *spine_ik_constraint_data_get_bones(spine_ik_constraint_data obj) { + if (!obj) return nullptr; + IkConstraintData *_obj = (IkConstraintData *) obj; + return (spine_bone_data *) _obj->getBones().buffer(); +} + +spine_bone_data spine_ik_constraint_data_get_target(spine_ik_constraint_data obj) { + if (!obj) return nullptr; + IkConstraintData *_obj = (IkConstraintData *) obj; + return (spine_bone_data) _obj->getTarget(); +} + +void spine_ik_constraint_data_set_target(spine_ik_constraint_data obj, spine_bone_data value) { + if (!obj) return; + IkConstraintData *_obj = (IkConstraintData *) obj; + _obj->setTarget((BoneData *) value); +} + +spine_bool spine_ik_constraint_data_get_uniform(spine_ik_constraint_data obj) { + if (!obj) return 0; + IkConstraintData *_obj = (IkConstraintData *) obj; + return _obj->getUniform(); +} + +void spine_ik_constraint_data_set_uniform(spine_ik_constraint_data obj, spine_bool value) { + if (!obj) return; + IkConstraintData *_obj = (IkConstraintData *) obj; + _obj->setUniform(value); +} + +const utf8 * spine_ik_constraint_data_get_name(spine_ik_constraint_data obj) { + if (!obj) return nullptr; + IkConstraintData *_obj = (IkConstraintData *) obj; + return (const utf8 *) _obj->getName().buffer(); +} + +spine_bool spine_ik_constraint_data_is_skin_required(spine_ik_constraint_data obj) { + if (!obj) return 0; + IkConstraintData *_obj = (IkConstraintData *) obj; + return _obj->isSkinRequired(); +} + +spine_ik_constraint_pose spine_ik_constraint_data_get_setup_pose(spine_ik_constraint_data obj) { + if (!obj) return 0; + IkConstraintData *_obj = (IkConstraintData *) obj; + return _obj->getSetupPose(); +} + +spine_ik_constraint_pose spine_ik_constraint_data_get_setup_pose(spine_ik_constraint_data obj) { + if (!obj) return 0; + IkConstraintData *_obj = (IkConstraintData *) obj; + return _obj->getSetupPose(); +} diff --git a/spine-c-new/src/generated/ik_constraint_data.h b/spine-c-new/src/generated/ik_constraint_data.h new file mode 100644 index 000000000..418d1d384 --- /dev/null +++ b/spine-c-new/src/generated/ik_constraint_data.h @@ -0,0 +1,61 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#ifndef SPINE_C_IKCONSTRAINTDATA_H +#define SPINE_C_IKCONSTRAINTDATA_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include "../custom.h" + +SPINE_OPAQUE_TYPE(spine_ik_constraint_data) + +SPINE_C_EXPORT spine_ik_constraint_data spine_ik_constraint_data_create(const utf8 * name); +SPINE_C_EXPORT void spine_ik_constraint_data_dispose(spine_ik_constraint_data obj); +SPINE_C_EXPORT spine_rtti spine_ik_constraint_data_get_rtti(spine_ik_constraint_data obj); +SPINE_C_EXPORT spine_constraint spine_ik_constraint_data_create(spine_ik_constraint_data obj, spine_skeleton skeleton); +SPINE_C_EXPORT void * spine_ik_constraint_data_get_bones(spine_ik_constraint_data obj); +SPINE_C_EXPORT int32_t spine_ik_constraint_data_get_num_bones(spine_ik_constraint_data obj); +SPINE_C_EXPORT spine_bone_data *spine_ik_constraint_data_get_bones(spine_ik_constraint_data obj); +SPINE_C_EXPORT spine_bone_data spine_ik_constraint_data_get_target(spine_ik_constraint_data obj); +SPINE_C_EXPORT void spine_ik_constraint_data_set_target(spine_ik_constraint_data obj, spine_bone_data value); +SPINE_C_EXPORT spine_bool spine_ik_constraint_data_get_uniform(spine_ik_constraint_data obj); +SPINE_C_EXPORT void spine_ik_constraint_data_set_uniform(spine_ik_constraint_data obj, spine_bool value); +SPINE_C_EXPORT const utf8 * spine_ik_constraint_data_get_name(spine_ik_constraint_data obj); +SPINE_C_EXPORT spine_bool spine_ik_constraint_data_is_skin_required(spine_ik_constraint_data obj); +SPINE_C_EXPORT spine_ik_constraint_pose spine_ik_constraint_data_get_setup_pose(spine_ik_constraint_data obj); +SPINE_C_EXPORT spine_ik_constraint_pose spine_ik_constraint_data_get_setup_pose(spine_ik_constraint_data obj); + +#ifdef __cplusplus +} +#endif + +#endif // SPINE_C_IKCONSTRAINTDATA_H \ No newline at end of file diff --git a/spine-c-new/src/generated/ik_constraint_pose.cpp b/spine-c-new/src/generated/ik_constraint_pose.cpp new file mode 100644 index 000000000..72607651d --- /dev/null +++ b/spine-c-new/src/generated/ik_constraint_pose.cpp @@ -0,0 +1,109 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#include "ik_constraint_pose.h" +#include + +using namespace spine; + +spine_ik_constraint_pose spine_ik_constraint_pose_create(void) { + IkConstraintPose *obj = new (__FILE__, __LINE__) IkConstraintPose(); + return (spine_ik_constraint_pose) obj; +} + +void spine_ik_constraint_pose_dispose(spine_ik_constraint_pose obj) { + if (!obj) return; + delete (IkConstraintPose *) obj; +} + +void spine_ik_constraint_pose_set(spine_ik_constraint_pose obj, spine_ik_constraint_pose value) { + if (!obj) return; + IkConstraintPose *_obj = (IkConstraintPose *) obj; + _obj->set(value); +} + +float spine_ik_constraint_pose_get_mix(spine_ik_constraint_pose obj) { + if (!obj) return 0; + IkConstraintPose *_obj = (IkConstraintPose *) obj; + return _obj->getMix(); +} + +void spine_ik_constraint_pose_set_mix(spine_ik_constraint_pose obj, float value) { + if (!obj) return; + IkConstraintPose *_obj = (IkConstraintPose *) obj; + _obj->setMix(value); +} + +float spine_ik_constraint_pose_get_softness(spine_ik_constraint_pose obj) { + if (!obj) return 0; + IkConstraintPose *_obj = (IkConstraintPose *) obj; + return _obj->getSoftness(); +} + +void spine_ik_constraint_pose_set_softness(spine_ik_constraint_pose obj, float value) { + if (!obj) return; + IkConstraintPose *_obj = (IkConstraintPose *) obj; + _obj->setSoftness(value); +} + +int32_t spine_ik_constraint_pose_get_bend_direction(spine_ik_constraint_pose obj) { + if (!obj) return 0; + IkConstraintPose *_obj = (IkConstraintPose *) obj; + return _obj->getBendDirection(); +} + +void spine_ik_constraint_pose_set_bend_direction(spine_ik_constraint_pose obj, int32_t value) { + if (!obj) return; + IkConstraintPose *_obj = (IkConstraintPose *) obj; + _obj->setBendDirection(value); +} + +spine_bool spine_ik_constraint_pose_get_compress(spine_ik_constraint_pose obj) { + if (!obj) return 0; + IkConstraintPose *_obj = (IkConstraintPose *) obj; + return _obj->getCompress(); +} + +void spine_ik_constraint_pose_set_compress(spine_ik_constraint_pose obj, spine_bool value) { + if (!obj) return; + IkConstraintPose *_obj = (IkConstraintPose *) obj; + _obj->setCompress(value); +} + +spine_bool spine_ik_constraint_pose_get_stretch(spine_ik_constraint_pose obj) { + if (!obj) return 0; + IkConstraintPose *_obj = (IkConstraintPose *) obj; + return _obj->getStretch(); +} + +void spine_ik_constraint_pose_set_stretch(spine_ik_constraint_pose obj, spine_bool value) { + if (!obj) return; + IkConstraintPose *_obj = (IkConstraintPose *) obj; + _obj->setStretch(value); +} diff --git a/spine-c-new/src/generated/ik_constraint_pose.h b/spine-c-new/src/generated/ik_constraint_pose.h new file mode 100644 index 000000000..c80828564 --- /dev/null +++ b/spine-c-new/src/generated/ik_constraint_pose.h @@ -0,0 +1,59 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#ifndef SPINE_C_IKCONSTRAINTPOSE_H +#define SPINE_C_IKCONSTRAINTPOSE_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include "../custom.h" + +SPINE_OPAQUE_TYPE(spine_ik_constraint_pose) + +SPINE_C_EXPORT spine_ik_constraint_pose spine_ik_constraint_pose_create(void); +SPINE_C_EXPORT void spine_ik_constraint_pose_dispose(spine_ik_constraint_pose obj); +SPINE_C_EXPORT void spine_ik_constraint_pose_set(spine_ik_constraint_pose obj, spine_ik_constraint_pose value); +SPINE_C_EXPORT float spine_ik_constraint_pose_get_mix(spine_ik_constraint_pose obj); +SPINE_C_EXPORT void spine_ik_constraint_pose_set_mix(spine_ik_constraint_pose obj, float value); +SPINE_C_EXPORT float spine_ik_constraint_pose_get_softness(spine_ik_constraint_pose obj); +SPINE_C_EXPORT void spine_ik_constraint_pose_set_softness(spine_ik_constraint_pose obj, float value); +SPINE_C_EXPORT int32_t spine_ik_constraint_pose_get_bend_direction(spine_ik_constraint_pose obj); +SPINE_C_EXPORT void spine_ik_constraint_pose_set_bend_direction(spine_ik_constraint_pose obj, int32_t value); +SPINE_C_EXPORT spine_bool spine_ik_constraint_pose_get_compress(spine_ik_constraint_pose obj); +SPINE_C_EXPORT void spine_ik_constraint_pose_set_compress(spine_ik_constraint_pose obj, spine_bool value); +SPINE_C_EXPORT spine_bool spine_ik_constraint_pose_get_stretch(spine_ik_constraint_pose obj); +SPINE_C_EXPORT void spine_ik_constraint_pose_set_stretch(spine_ik_constraint_pose obj, spine_bool value); + +#ifdef __cplusplus +} +#endif + +#endif // SPINE_C_IKCONSTRAINTPOSE_H \ No newline at end of file diff --git a/spine-c-new/src/generated/ik_constraint_timeline.cpp b/spine-c-new/src/generated/ik_constraint_timeline.cpp new file mode 100644 index 000000000..38a241711 --- /dev/null +++ b/spine-c-new/src/generated/ik_constraint_timeline.cpp @@ -0,0 +1,169 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#include "ik_constraint_timeline.h" +#include + +using namespace spine; + +spine_ik_constraint_timeline spine_ik_constraint_timeline_create(spine_size_t frameCount, spine_size_t bezierCount, int32_t constraintIndex) { + IkConstraintTimeline *obj = new (__FILE__, __LINE__) IkConstraintTimeline(frameCount, bezierCount, constraintIndex); + return (spine_ik_constraint_timeline) obj; +} + +void spine_ik_constraint_timeline_dispose(spine_ik_constraint_timeline obj) { + if (!obj) return; + delete (IkConstraintTimeline *) obj; +} + +spine_rtti spine_ik_constraint_timeline_get_rtti(spine_ik_constraint_timeline obj) { + if (!obj) return nullptr; + IkConstraintTimeline *_obj = (IkConstraintTimeline *) obj; + return (spine_rtti) &_obj->getRTTI(); +} + +void spine_ik_constraint_timeline_apply(spine_ik_constraint_timeline obj, spine_skeleton skeleton, float lastTime, float time, void * pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction, spine_bool appliedPose) { + if (!obj) return ; + IkConstraintTimeline *_obj = (IkConstraintTimeline *) obj; + _obj->apply(skeleton, lastTime, time, (Vector *) pEvents, alpha, blend, direction, appliedPose); +} + +void spine_ik_constraint_timeline_set_frame(spine_ik_constraint_timeline obj, int32_t frame, float time, float mix, float softness, int32_t bendDirection, spine_bool compress, spine_bool stretch) { + if (!obj) return ; + IkConstraintTimeline *_obj = (IkConstraintTimeline *) obj; + _obj->setFrame(frame, time, mix, softness, bendDirection, compress, stretch); +} + +void spine_ik_constraint_timeline_set_linear(spine_ik_constraint_timeline obj, spine_size_t value) { + if (!obj) return; + IkConstraintTimeline *_obj = (IkConstraintTimeline *) obj; + _obj->setLinear(value); +} + +void spine_ik_constraint_timeline_set_stepped(spine_ik_constraint_timeline obj, spine_size_t value) { + if (!obj) return; + IkConstraintTimeline *_obj = (IkConstraintTimeline *) obj; + _obj->setStepped(value); +} + +void spine_ik_constraint_timeline_set_bezier(spine_ik_constraint_timeline obj, spine_size_t bezier, spine_size_t frame, float value, float time1, float value1, float cx1, float cy1, float cx2, float cy2, float time2, float value2) { + if (!obj) return ; + IkConstraintTimeline *_obj = (IkConstraintTimeline *) obj; + _obj->setBezier(bezier, frame, value, time1, value1, cx1, cy1, cx2, cy2, time2, value2); +} + +float spine_ik_constraint_timeline_get_bezier_value(spine_ik_constraint_timeline obj, float time, spine_size_t frame, spine_size_t valueOffset, spine_size_t i) { + if (!obj) return 0; + IkConstraintTimeline *_obj = (IkConstraintTimeline *) obj; + return _obj->getBezierValue(time, frame, valueOffset, i); +} + +void * spine_ik_constraint_timeline_get_curves(spine_ik_constraint_timeline obj) { + if (!obj) return nullptr; + IkConstraintTimeline *_obj = (IkConstraintTimeline *) obj; + return _obj->getCurves(); +} + +int32_t spine_ik_constraint_timeline_get_num_curves(spine_ik_constraint_timeline obj) { + if (!obj) return 0; + IkConstraintTimeline *_obj = (IkConstraintTimeline *) obj; + return (int32_t) _obj->getCurves().size(); +} + +spine_float *spine_ik_constraint_timeline_get_curves(spine_ik_constraint_timeline obj) { + if (!obj) return nullptr; + IkConstraintTimeline *_obj = (IkConstraintTimeline *) obj; + return (spine_float *) _obj->getCurves().buffer(); +} + +spine_size_t spine_ik_constraint_timeline_get_frame_entries(spine_ik_constraint_timeline obj) { + if (!obj) return nullptr; + IkConstraintTimeline *_obj = (IkConstraintTimeline *) obj; + return _obj->getFrameEntries(); +} + +spine_size_t spine_ik_constraint_timeline_get_frame_count(spine_ik_constraint_timeline obj) { + if (!obj) return nullptr; + IkConstraintTimeline *_obj = (IkConstraintTimeline *) obj; + return _obj->getFrameCount(); +} + +void * spine_ik_constraint_timeline_get_frames(spine_ik_constraint_timeline obj) { + if (!obj) return nullptr; + IkConstraintTimeline *_obj = (IkConstraintTimeline *) obj; + return _obj->getFrames(); +} + +int32_t spine_ik_constraint_timeline_get_num_frames(spine_ik_constraint_timeline obj) { + if (!obj) return 0; + IkConstraintTimeline *_obj = (IkConstraintTimeline *) obj; + return (int32_t) _obj->getFrames().size(); +} + +spine_float *spine_ik_constraint_timeline_get_frames(spine_ik_constraint_timeline obj) { + if (!obj) return nullptr; + IkConstraintTimeline *_obj = (IkConstraintTimeline *) obj; + return (spine_float *) _obj->getFrames().buffer(); +} + +float spine_ik_constraint_timeline_get_duration(spine_ik_constraint_timeline obj) { + if (!obj) return 0; + IkConstraintTimeline *_obj = (IkConstraintTimeline *) obj; + return _obj->getDuration(); +} + +void * spine_ik_constraint_timeline_get_property_ids(spine_ik_constraint_timeline obj) { + if (!obj) return nullptr; + IkConstraintTimeline *_obj = (IkConstraintTimeline *) obj; + return _obj->getPropertyIds(); +} + +int32_t spine_ik_constraint_timeline_get_num_property_ids(spine_ik_constraint_timeline obj) { + if (!obj) return 0; + IkConstraintTimeline *_obj = (IkConstraintTimeline *) obj; + return (int32_t) _obj->getPropertyIds().size(); +} + +spine_property_id *spine_ik_constraint_timeline_get_property_ids(spine_ik_constraint_timeline obj) { + if (!obj) return nullptr; + IkConstraintTimeline *_obj = (IkConstraintTimeline *) obj; + return (spine_property_id *) _obj->getPropertyIds().buffer(); +} + +int32_t spine_ik_constraint_timeline_get_constraint_index(spine_ik_constraint_timeline obj) { + if (!obj) return 0; + IkConstraintTimeline *_obj = (IkConstraintTimeline *) obj; + return _obj->getConstraintIndex(); +} + +void spine_ik_constraint_timeline_set_constraint_index(spine_ik_constraint_timeline obj, int32_t value) { + if (!obj) return; + IkConstraintTimeline *_obj = (IkConstraintTimeline *) obj; + _obj->setConstraintIndex(value); +} diff --git a/spine-c-new/src/generated/ik_constraint_timeline.h b/spine-c-new/src/generated/ik_constraint_timeline.h new file mode 100644 index 000000000..f862c088c --- /dev/null +++ b/spine-c-new/src/generated/ik_constraint_timeline.h @@ -0,0 +1,69 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#ifndef SPINE_C_IKCONSTRAINTTIMELINE_H +#define SPINE_C_IKCONSTRAINTTIMELINE_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include "../custom.h" + +SPINE_OPAQUE_TYPE(spine_ik_constraint_timeline) + +SPINE_C_EXPORT spine_ik_constraint_timeline spine_ik_constraint_timeline_create(spine_size_t frameCount, spine_size_t bezierCount, int32_t constraintIndex); +SPINE_C_EXPORT void spine_ik_constraint_timeline_dispose(spine_ik_constraint_timeline obj); +SPINE_C_EXPORT spine_rtti spine_ik_constraint_timeline_get_rtti(spine_ik_constraint_timeline obj); +SPINE_C_EXPORT void spine_ik_constraint_timeline_apply(spine_ik_constraint_timeline obj, spine_skeleton skeleton, float lastTime, float time, void * pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction, spine_bool appliedPose); +SPINE_C_EXPORT void spine_ik_constraint_timeline_set_frame(spine_ik_constraint_timeline obj, int32_t frame, float time, float mix, float softness, int32_t bendDirection, spine_bool compress, spine_bool stretch); +SPINE_C_EXPORT void spine_ik_constraint_timeline_set_linear(spine_ik_constraint_timeline obj, spine_size_t value); +SPINE_C_EXPORT void spine_ik_constraint_timeline_set_stepped(spine_ik_constraint_timeline obj, spine_size_t value); +SPINE_C_EXPORT void spine_ik_constraint_timeline_set_bezier(spine_ik_constraint_timeline obj, spine_size_t bezier, spine_size_t frame, float value, float time1, float value1, float cx1, float cy1, float cx2, float cy2, float time2, float value2); +SPINE_C_EXPORT float spine_ik_constraint_timeline_get_bezier_value(spine_ik_constraint_timeline obj, float time, spine_size_t frame, spine_size_t valueOffset, spine_size_t i); +SPINE_C_EXPORT void * spine_ik_constraint_timeline_get_curves(spine_ik_constraint_timeline obj); +SPINE_C_EXPORT int32_t spine_ik_constraint_timeline_get_num_curves(spine_ik_constraint_timeline obj); +SPINE_C_EXPORT spine_float *spine_ik_constraint_timeline_get_curves(spine_ik_constraint_timeline obj); +SPINE_C_EXPORT spine_size_t spine_ik_constraint_timeline_get_frame_entries(spine_ik_constraint_timeline obj); +SPINE_C_EXPORT spine_size_t spine_ik_constraint_timeline_get_frame_count(spine_ik_constraint_timeline obj); +SPINE_C_EXPORT void * spine_ik_constraint_timeline_get_frames(spine_ik_constraint_timeline obj); +SPINE_C_EXPORT int32_t spine_ik_constraint_timeline_get_num_frames(spine_ik_constraint_timeline obj); +SPINE_C_EXPORT spine_float *spine_ik_constraint_timeline_get_frames(spine_ik_constraint_timeline obj); +SPINE_C_EXPORT float spine_ik_constraint_timeline_get_duration(spine_ik_constraint_timeline obj); +SPINE_C_EXPORT void * spine_ik_constraint_timeline_get_property_ids(spine_ik_constraint_timeline obj); +SPINE_C_EXPORT int32_t spine_ik_constraint_timeline_get_num_property_ids(spine_ik_constraint_timeline obj); +SPINE_C_EXPORT spine_property_id *spine_ik_constraint_timeline_get_property_ids(spine_ik_constraint_timeline obj); +SPINE_C_EXPORT int32_t spine_ik_constraint_timeline_get_constraint_index(spine_ik_constraint_timeline obj); +SPINE_C_EXPORT void spine_ik_constraint_timeline_set_constraint_index(spine_ik_constraint_timeline obj, int32_t value); + +#ifdef __cplusplus +} +#endif + +#endif // SPINE_C_IKCONSTRAINTTIMELINE_H \ No newline at end of file diff --git a/spine-c-new/src/generated/inherit.h b/spine-c-new/src/generated/inherit.h new file mode 100644 index 000000000..c5f8a48c6 --- /dev/null +++ b/spine-c-new/src/generated/inherit.h @@ -0,0 +1,51 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#ifndef SPINE_C_INHERIT_H +#define SPINE_C_INHERIT_H + +#include "../../custom.h" + +#ifdef __cplusplus +extern "C" { +#endif + +typedef enum spine_inherit { + SPINE_INHERIT_INHERIT_NORMAL = 0, + SPINE_INHERIT_INHERIT_ONLY_TRANSLATION, + SPINE_INHERIT_INHERIT_NO_ROTATION_OR_REFLECTION, + SPINE_INHERIT_INHERIT_NO_SCALE, + SPINE_INHERIT_INHERIT_NO_SCALE_OR_REFLECTION +} spine_inherit; + +#ifdef __cplusplus +} +#endif + +#endif // SPINE_C_INHERIT_H \ No newline at end of file diff --git a/spine-c-new/src/generated/inherit_timeline.cpp b/spine-c-new/src/generated/inherit_timeline.cpp new file mode 100644 index 000000000..79c460e46 --- /dev/null +++ b/spine-c-new/src/generated/inherit_timeline.cpp @@ -0,0 +1,127 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#include "inherit_timeline.h" +#include + +using namespace spine; + +spine_inherit_timeline spine_inherit_timeline_create(spine_size_t frameCount, int32_t boneIndex) { + InheritTimeline *obj = new (__FILE__, __LINE__) InheritTimeline(frameCount, boneIndex); + return (spine_inherit_timeline) obj; +} + +void spine_inherit_timeline_dispose(spine_inherit_timeline obj) { + if (!obj) return; + delete (InheritTimeline *) obj; +} + +spine_rtti spine_inherit_timeline_get_rtti(spine_inherit_timeline obj) { + if (!obj) return nullptr; + InheritTimeline *_obj = (InheritTimeline *) obj; + return (spine_rtti) &_obj->getRTTI(); +} + +void spine_inherit_timeline_set_frame(spine_inherit_timeline obj, int32_t frame, float time, spine_inherit inherit) { + if (!obj) return ; + InheritTimeline *_obj = (InheritTimeline *) obj; + _obj->setFrame(frame, time, inherit); +} + +void spine_inherit_timeline_apply(spine_inherit_timeline obj, spine_skeleton skeleton, float lastTime, float time, void * pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction, spine_bool appliedPose) { + if (!obj) return ; + InheritTimeline *_obj = (InheritTimeline *) obj; + _obj->apply(skeleton, lastTime, time, (Vector *) pEvents, alpha, blend, direction, appliedPose); +} + +spine_size_t spine_inherit_timeline_get_frame_entries(spine_inherit_timeline obj) { + if (!obj) return nullptr; + InheritTimeline *_obj = (InheritTimeline *) obj; + return _obj->getFrameEntries(); +} + +spine_size_t spine_inherit_timeline_get_frame_count(spine_inherit_timeline obj) { + if (!obj) return nullptr; + InheritTimeline *_obj = (InheritTimeline *) obj; + return _obj->getFrameCount(); +} + +void * spine_inherit_timeline_get_frames(spine_inherit_timeline obj) { + if (!obj) return nullptr; + InheritTimeline *_obj = (InheritTimeline *) obj; + return _obj->getFrames(); +} + +int32_t spine_inherit_timeline_get_num_frames(spine_inherit_timeline obj) { + if (!obj) return 0; + InheritTimeline *_obj = (InheritTimeline *) obj; + return (int32_t) _obj->getFrames().size(); +} + +spine_float *spine_inherit_timeline_get_frames(spine_inherit_timeline obj) { + if (!obj) return nullptr; + InheritTimeline *_obj = (InheritTimeline *) obj; + return (spine_float *) _obj->getFrames().buffer(); +} + +float spine_inherit_timeline_get_duration(spine_inherit_timeline obj) { + if (!obj) return 0; + InheritTimeline *_obj = (InheritTimeline *) obj; + return _obj->getDuration(); +} + +void * spine_inherit_timeline_get_property_ids(spine_inherit_timeline obj) { + if (!obj) return nullptr; + InheritTimeline *_obj = (InheritTimeline *) obj; + return _obj->getPropertyIds(); +} + +int32_t spine_inherit_timeline_get_num_property_ids(spine_inherit_timeline obj) { + if (!obj) return 0; + InheritTimeline *_obj = (InheritTimeline *) obj; + return (int32_t) _obj->getPropertyIds().size(); +} + +spine_property_id *spine_inherit_timeline_get_property_ids(spine_inherit_timeline obj) { + if (!obj) return nullptr; + InheritTimeline *_obj = (InheritTimeline *) obj; + return (spine_property_id *) _obj->getPropertyIds().buffer(); +} + +int32_t spine_inherit_timeline_get_bone_index(spine_inherit_timeline obj) { + if (!obj) return 0; + InheritTimeline *_obj = (InheritTimeline *) obj; + return _obj->getBoneIndex(); +} + +void spine_inherit_timeline_set_bone_index(spine_inherit_timeline obj, int32_t value) { + if (!obj) return; + InheritTimeline *_obj = (InheritTimeline *) obj; + _obj->setBoneIndex(value); +} diff --git a/spine-c-new/src/generated/inherit_timeline.h b/spine-c-new/src/generated/inherit_timeline.h new file mode 100644 index 000000000..0d52c4cf6 --- /dev/null +++ b/spine-c-new/src/generated/inherit_timeline.h @@ -0,0 +1,62 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#ifndef SPINE_C_INHERITTIMELINE_H +#define SPINE_C_INHERITTIMELINE_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include "../custom.h" + +SPINE_OPAQUE_TYPE(spine_inherit_timeline) + +SPINE_C_EXPORT spine_inherit_timeline spine_inherit_timeline_create(spine_size_t frameCount, int32_t boneIndex); +SPINE_C_EXPORT void spine_inherit_timeline_dispose(spine_inherit_timeline obj); +SPINE_C_EXPORT spine_rtti spine_inherit_timeline_get_rtti(spine_inherit_timeline obj); +SPINE_C_EXPORT void spine_inherit_timeline_set_frame(spine_inherit_timeline obj, int32_t frame, float time, spine_inherit inherit); +SPINE_C_EXPORT void spine_inherit_timeline_apply(spine_inherit_timeline obj, spine_skeleton skeleton, float lastTime, float time, void * pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction, spine_bool appliedPose); +SPINE_C_EXPORT spine_size_t spine_inherit_timeline_get_frame_entries(spine_inherit_timeline obj); +SPINE_C_EXPORT spine_size_t spine_inherit_timeline_get_frame_count(spine_inherit_timeline obj); +SPINE_C_EXPORT void * spine_inherit_timeline_get_frames(spine_inherit_timeline obj); +SPINE_C_EXPORT int32_t spine_inherit_timeline_get_num_frames(spine_inherit_timeline obj); +SPINE_C_EXPORT spine_float *spine_inherit_timeline_get_frames(spine_inherit_timeline obj); +SPINE_C_EXPORT float spine_inherit_timeline_get_duration(spine_inherit_timeline obj); +SPINE_C_EXPORT void * spine_inherit_timeline_get_property_ids(spine_inherit_timeline obj); +SPINE_C_EXPORT int32_t spine_inherit_timeline_get_num_property_ids(spine_inherit_timeline obj); +SPINE_C_EXPORT spine_property_id *spine_inherit_timeline_get_property_ids(spine_inherit_timeline obj); +SPINE_C_EXPORT int32_t spine_inherit_timeline_get_bone_index(spine_inherit_timeline obj); +SPINE_C_EXPORT void spine_inherit_timeline_set_bone_index(spine_inherit_timeline obj, int32_t value); + +#ifdef __cplusplus +} +#endif + +#endif // SPINE_C_INHERITTIMELINE_H \ No newline at end of file diff --git a/spine-c-new/src/generated/interpolation.cpp b/spine-c-new/src/generated/interpolation.cpp new file mode 100644 index 000000000..bb60863b5 --- /dev/null +++ b/spine-c-new/src/generated/interpolation.cpp @@ -0,0 +1,50 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#include "interpolation.h" +#include + +using namespace spine; + +void spine_interpolation_dispose(spine_interpolation obj) { + if (!obj) return; + delete (Interpolation *) obj; +} + +float spine_interpolation_apply(spine_interpolation obj, float a) { + if (!obj) return 0; + Interpolation *_obj = (Interpolation *) obj; + return _obj->apply(a); +} + +float spine_interpolation_interpolate(spine_interpolation obj, float start, float end, float a) { + if (!obj) return 0; + Interpolation *_obj = (Interpolation *) obj; + return _obj->interpolate(start, end, a); +} diff --git a/spine-c-new/src/generated/interpolation.h b/spine-c-new/src/generated/interpolation.h new file mode 100644 index 000000000..e4394ce24 --- /dev/null +++ b/spine-c-new/src/generated/interpolation.h @@ -0,0 +1,49 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#ifndef SPINE_C_INTERPOLATION_H +#define SPINE_C_INTERPOLATION_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include "../custom.h" + +SPINE_OPAQUE_TYPE(spine_interpolation) + +SPINE_C_EXPORT void spine_interpolation_dispose(spine_interpolation obj); +SPINE_C_EXPORT float spine_interpolation_apply(spine_interpolation obj, float a); +SPINE_C_EXPORT float spine_interpolation_interpolate(spine_interpolation obj, float start, float end, float a); + +#ifdef __cplusplus +} +#endif + +#endif // SPINE_C_INTERPOLATION_H \ No newline at end of file diff --git a/spine-c-new/src/generated/linked_mesh.cpp b/spine-c-new/src/generated/linked_mesh.cpp new file mode 100644 index 000000000..eeda5f715 --- /dev/null +++ b/spine-c-new/src/generated/linked_mesh.cpp @@ -0,0 +1,48 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#include "linked_mesh.h" +#include + +using namespace spine; + +spine_linked_mesh spine_linked_mesh_create(spine_mesh_attachment mesh, spine_const int skinIndex, spine_size_t slotIndex, const utf8 * parent, spine_bool inheritTimelines) { + LinkedMesh *obj = new (__FILE__, __LINE__) LinkedMesh((MeshAttachment *) mesh, skinIndex, slotIndex, String(parent), inheritTimelines); + return (spine_linked_mesh) obj; +} + +spine_linked_mesh spine_linked_mesh_create_with_mesh_attachment_string_size_t_string_bool(spine_mesh_attachment mesh, const utf8 * skin, spine_size_t slotIndex, const utf8 * parent, spine_bool inheritTimelines) { + LinkedMesh *obj = new (__FILE__, __LINE__) LinkedMesh((MeshAttachment *) mesh, String(skin), slotIndex, String(parent), inheritTimelines); + return (spine_linked_mesh) obj; +} + +void spine_linked_mesh_dispose(spine_linked_mesh obj) { + if (!obj) return; + delete (LinkedMesh *) obj; +} diff --git a/spine-c-new/src/generated/linked_mesh.h b/spine-c-new/src/generated/linked_mesh.h new file mode 100644 index 000000000..fe8509c5b --- /dev/null +++ b/spine-c-new/src/generated/linked_mesh.h @@ -0,0 +1,49 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#ifndef SPINE_C_LINKEDMESH_H +#define SPINE_C_LINKEDMESH_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include "../custom.h" + +SPINE_OPAQUE_TYPE(spine_linked_mesh) + +SPINE_C_EXPORT spine_linked_mesh spine_linked_mesh_create(spine_mesh_attachment mesh, spine_const int skinIndex, spine_size_t slotIndex, const utf8 * parent, spine_bool inheritTimelines); +SPINE_C_EXPORT spine_linked_mesh spine_linked_mesh_create_with_mesh_attachment_string_size_t_string_bool(spine_mesh_attachment mesh, const utf8 * skin, spine_size_t slotIndex, const utf8 * parent, spine_bool inheritTimelines); +SPINE_C_EXPORT void spine_linked_mesh_dispose(spine_linked_mesh obj); + +#ifdef __cplusplus +} +#endif + +#endif // SPINE_C_LINKEDMESH_H \ No newline at end of file diff --git a/spine-c-new/src/generated/mesh_attachment.cpp b/spine-c-new/src/generated/mesh_attachment.cpp new file mode 100644 index 000000000..758b9ca90 --- /dev/null +++ b/spine-c-new/src/generated/mesh_attachment.cpp @@ -0,0 +1,343 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#include "mesh_attachment.h" +#include + +using namespace spine; + +spine_mesh_attachment spine_mesh_attachment_create(const utf8 * name) { + MeshAttachment *obj = new (__FILE__, __LINE__) MeshAttachment(String(name)); + return (spine_mesh_attachment) obj; +} + +void spine_mesh_attachment_dispose(spine_mesh_attachment obj) { + if (!obj) return; + delete (MeshAttachment *) obj; +} + +spine_rtti spine_mesh_attachment_get_rtti(spine_mesh_attachment obj) { + if (!obj) return nullptr; + MeshAttachment *_obj = (MeshAttachment *) obj; + return (spine_rtti) &_obj->getRTTI(); +} + +void spine_mesh_attachment_compute_world_vertices(spine_mesh_attachment obj, spine_skeleton skeleton, spine_slot slot, spine_size_t start, spine_size_t count, spine_float worldVertices, spine_size_t offset, spine_size_t stride) { + if (!obj) return ; + MeshAttachment *_obj = (MeshAttachment *) obj; + _obj->computeWorldVertices(skeleton, slot, start, count, (float *) worldVertices, offset, stride); +} + +void spine_mesh_attachment_update_region(spine_mesh_attachment obj) { + if (!obj) return ; + MeshAttachment *_obj = (MeshAttachment *) obj; + _obj->updateRegion(); +} + +int32_t spine_mesh_attachment_get_hull_length(spine_mesh_attachment obj) { + if (!obj) return 0; + MeshAttachment *_obj = (MeshAttachment *) obj; + return _obj->getHullLength(); +} + +void spine_mesh_attachment_set_hull_length(spine_mesh_attachment obj, int32_t value) { + if (!obj) return; + MeshAttachment *_obj = (MeshAttachment *) obj; + _obj->setHullLength(value); +} + +void * spine_mesh_attachment_get_region_u_vs(spine_mesh_attachment obj) { + if (!obj) return nullptr; + MeshAttachment *_obj = (MeshAttachment *) obj; + return _obj->getRegionUVs(); +} + +int32_t spine_mesh_attachment_get_num_region_u_vs(spine_mesh_attachment obj) { + if (!obj) return 0; + MeshAttachment *_obj = (MeshAttachment *) obj; + return (int32_t) _obj->getRegionUVs().size(); +} + +spine_float *spine_mesh_attachment_get_region_u_vs(spine_mesh_attachment obj) { + if (!obj) return nullptr; + MeshAttachment *_obj = (MeshAttachment *) obj; + return (spine_float *) _obj->getRegionUVs().buffer(); +} + +void spine_mesh_attachment_set_region_u_vs(spine_mesh_attachment obj, void * value) { + if (!obj) return; + MeshAttachment *_obj = (MeshAttachment *) obj; + _obj->setRegionUVs((Vector &) value); +} + +void * spine_mesh_attachment_get_u_vs(spine_mesh_attachment obj) { + if (!obj) return nullptr; + MeshAttachment *_obj = (MeshAttachment *) obj; + return _obj->getUVs(); +} + +int32_t spine_mesh_attachment_get_num_u_vs(spine_mesh_attachment obj) { + if (!obj) return 0; + MeshAttachment *_obj = (MeshAttachment *) obj; + return (int32_t) _obj->getUVs().size(); +} + +spine_float *spine_mesh_attachment_get_u_vs(spine_mesh_attachment obj) { + if (!obj) return nullptr; + MeshAttachment *_obj = (MeshAttachment *) obj; + return (spine_float *) _obj->getUVs().buffer(); +} + +void * spine_mesh_attachment_get_triangles(spine_mesh_attachment obj) { + if (!obj) return nullptr; + MeshAttachment *_obj = (MeshAttachment *) obj; + return _obj->getTriangles(); +} + +int32_t spine_mesh_attachment_get_num_triangles(spine_mesh_attachment obj) { + if (!obj) return 0; + MeshAttachment *_obj = (MeshAttachment *) obj; + return (int32_t) _obj->getTriangles().size(); +} + +spine_unsigned short *spine_mesh_attachment_get_triangles(spine_mesh_attachment obj) { + if (!obj) return nullptr; + MeshAttachment *_obj = (MeshAttachment *) obj; + return (spine_unsigned short *) _obj->getTriangles().buffer(); +} + +void spine_mesh_attachment_set_triangles(spine_mesh_attachment obj, void * value) { + if (!obj) return; + MeshAttachment *_obj = (MeshAttachment *) obj; + _obj->setTriangles((Vector &) value); +} + +spine_color spine_mesh_attachment_get_color(spine_mesh_attachment obj) { + if (!obj) return nullptr; + MeshAttachment *_obj = (MeshAttachment *) obj; + return (spine_color) &_obj->getColor(); +} + +const utf8 * spine_mesh_attachment_get_path(spine_mesh_attachment obj) { + if (!obj) return nullptr; + MeshAttachment *_obj = (MeshAttachment *) obj; + return (const utf8 *) _obj->getPath().buffer(); +} + +void spine_mesh_attachment_set_path(spine_mesh_attachment obj, const utf8 * value) { + if (!obj) return; + MeshAttachment *_obj = (MeshAttachment *) obj; + _obj->setPath(String(value)); +} + +spine_texture_region spine_mesh_attachment_get_region(spine_mesh_attachment obj) { + if (!obj) return nullptr; + MeshAttachment *_obj = (MeshAttachment *) obj; + return (spine_texture_region) _obj->getRegion(); +} + +void spine_mesh_attachment_set_region(spine_mesh_attachment obj, spine_texture_region value) { + if (!obj) return; + MeshAttachment *_obj = (MeshAttachment *) obj; + _obj->setRegion((TextureRegion *) value); +} + +spine_sequence spine_mesh_attachment_get_sequence(spine_mesh_attachment obj) { + if (!obj) return nullptr; + MeshAttachment *_obj = (MeshAttachment *) obj; + return (spine_sequence) _obj->getSequence(); +} + +void spine_mesh_attachment_set_sequence(spine_mesh_attachment obj, spine_sequence value) { + if (!obj) return; + MeshAttachment *_obj = (MeshAttachment *) obj; + _obj->setSequence((Sequence *) value); +} + +spine_mesh_attachment spine_mesh_attachment_get_parent_mesh(spine_mesh_attachment obj) { + if (!obj) return nullptr; + MeshAttachment *_obj = (MeshAttachment *) obj; + return (spine_mesh_attachment) _obj->getParentMesh(); +} + +void spine_mesh_attachment_set_parent_mesh(spine_mesh_attachment obj, spine_mesh_attachment value) { + if (!obj) return; + MeshAttachment *_obj = (MeshAttachment *) obj; + _obj->setParentMesh((MeshAttachment *) value); +} + +void * spine_mesh_attachment_get_edges(spine_mesh_attachment obj) { + if (!obj) return nullptr; + MeshAttachment *_obj = (MeshAttachment *) obj; + return _obj->getEdges(); +} + +int32_t spine_mesh_attachment_get_num_edges(spine_mesh_attachment obj) { + if (!obj) return 0; + MeshAttachment *_obj = (MeshAttachment *) obj; + return (int32_t) _obj->getEdges().size(); +} + +spine_unsigned short *spine_mesh_attachment_get_edges(spine_mesh_attachment obj) { + if (!obj) return nullptr; + MeshAttachment *_obj = (MeshAttachment *) obj; + return (spine_unsigned short *) _obj->getEdges().buffer(); +} + +void spine_mesh_attachment_set_edges(spine_mesh_attachment obj, void * value) { + if (!obj) return; + MeshAttachment *_obj = (MeshAttachment *) obj; + _obj->setEdges((Vector &) value); +} + +float spine_mesh_attachment_get_width(spine_mesh_attachment obj) { + if (!obj) return 0; + MeshAttachment *_obj = (MeshAttachment *) obj; + return _obj->getWidth(); +} + +void spine_mesh_attachment_set_width(spine_mesh_attachment obj, float value) { + if (!obj) return; + MeshAttachment *_obj = (MeshAttachment *) obj; + _obj->setWidth(value); +} + +float spine_mesh_attachment_get_height(spine_mesh_attachment obj) { + if (!obj) return 0; + MeshAttachment *_obj = (MeshAttachment *) obj; + return _obj->getHeight(); +} + +void spine_mesh_attachment_set_height(spine_mesh_attachment obj, float value) { + if (!obj) return; + MeshAttachment *_obj = (MeshAttachment *) obj; + _obj->setHeight(value); +} + +spine_attachment spine_mesh_attachment_copy(spine_mesh_attachment obj) { + if (!obj) return nullptr; + MeshAttachment *_obj = (MeshAttachment *) obj; + return (spine_attachment) _obj->copy(); +} + +spine_mesh_attachment spine_mesh_attachment_new_linked_mesh(spine_mesh_attachment obj) { + if (!obj) return nullptr; + MeshAttachment *_obj = (MeshAttachment *) obj; + return (spine_mesh_attachment) _obj->newLinkedMesh(); +} + +void spine_mesh_attachment_compute_world_vertices(spine_mesh_attachment obj, spine_skeleton skeleton, spine_slot slot, spine_size_t start, spine_size_t count, void * worldVertices, spine_size_t offset, spine_size_t stride) { + if (!obj) return ; + MeshAttachment *_obj = (MeshAttachment *) obj; + _obj->computeWorldVertices(skeleton, slot, start, count, (Vector &) worldVertices, offset, stride); +} + +int32_t spine_mesh_attachment_get_id(spine_mesh_attachment obj) { + if (!obj) return 0; + MeshAttachment *_obj = (MeshAttachment *) obj; + return _obj->getId(); +} + +int32_t * spine_mesh_attachment_get_bones(spine_mesh_attachment obj) { + if (!obj) return 0; + MeshAttachment *_obj = (MeshAttachment *) obj; + return _obj->getBones(); +} + +int32_t spine_mesh_attachment_get_num_bones(spine_mesh_attachment obj) { + if (!obj) return 0; + MeshAttachment *_obj = (MeshAttachment *) obj; + return (int32_t) _obj->getBones().size(); +} + +int32_t *spine_mesh_attachment_get_bones(spine_mesh_attachment obj) { + if (!obj) return nullptr; + MeshAttachment *_obj = (MeshAttachment *) obj; + return (int32_t *) _obj->getBones().buffer(); +} + +void spine_mesh_attachment_set_bones(spine_mesh_attachment obj, int32_t * value) { + if (!obj) return; + MeshAttachment *_obj = (MeshAttachment *) obj; + _obj->setBones((Vector &) value); +} + +void * spine_mesh_attachment_get_vertices(spine_mesh_attachment obj) { + if (!obj) return nullptr; + MeshAttachment *_obj = (MeshAttachment *) obj; + return _obj->getVertices(); +} + +int32_t spine_mesh_attachment_get_num_vertices(spine_mesh_attachment obj) { + if (!obj) return 0; + MeshAttachment *_obj = (MeshAttachment *) obj; + return (int32_t) _obj->getVertices().size(); +} + +spine_float *spine_mesh_attachment_get_vertices(spine_mesh_attachment obj) { + if (!obj) return nullptr; + MeshAttachment *_obj = (MeshAttachment *) obj; + return (spine_float *) _obj->getVertices().buffer(); +} + +void spine_mesh_attachment_set_vertices(spine_mesh_attachment obj, void * value) { + if (!obj) return; + MeshAttachment *_obj = (MeshAttachment *) obj; + _obj->setVertices((Vector &) value); +} + +spine_size_t spine_mesh_attachment_get_world_vertices_length(spine_mesh_attachment obj) { + if (!obj) return nullptr; + MeshAttachment *_obj = (MeshAttachment *) obj; + return _obj->getWorldVerticesLength(); +} + +void spine_mesh_attachment_set_world_vertices_length(spine_mesh_attachment obj, spine_size_t value) { + if (!obj) return; + MeshAttachment *_obj = (MeshAttachment *) obj; + _obj->setWorldVerticesLength(value); +} + +spine_attachment spine_mesh_attachment_get_timeline_attachment(spine_mesh_attachment obj) { + if (!obj) return nullptr; + MeshAttachment *_obj = (MeshAttachment *) obj; + return (spine_attachment) _obj->getTimelineAttachment(); +} + +void spine_mesh_attachment_set_timeline_attachment(spine_mesh_attachment obj, spine_attachment value) { + if (!obj) return; + MeshAttachment *_obj = (MeshAttachment *) obj; + _obj->setTimelineAttachment((Attachment *) value); +} + +void spine_mesh_attachment_copy_to(spine_mesh_attachment obj, spine_vertex_attachment other) { + if (!obj) return ; + MeshAttachment *_obj = (MeshAttachment *) obj; + _obj->copyTo((VertexAttachment *) other); +} diff --git a/spine-c-new/src/generated/mesh_attachment.h b/spine-c-new/src/generated/mesh_attachment.h new file mode 100644 index 000000000..6931b36d4 --- /dev/null +++ b/spine-c-new/src/generated/mesh_attachment.h @@ -0,0 +1,98 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#ifndef SPINE_C_MESHATTACHMENT_H +#define SPINE_C_MESHATTACHMENT_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include "../custom.h" + +SPINE_OPAQUE_TYPE(spine_mesh_attachment) + +SPINE_C_EXPORT spine_mesh_attachment spine_mesh_attachment_create(const utf8 * name); +SPINE_C_EXPORT void spine_mesh_attachment_dispose(spine_mesh_attachment obj); +SPINE_C_EXPORT spine_rtti spine_mesh_attachment_get_rtti(spine_mesh_attachment obj); +SPINE_C_EXPORT void spine_mesh_attachment_compute_world_vertices(spine_mesh_attachment obj, spine_skeleton skeleton, spine_slot slot, spine_size_t start, spine_size_t count, spine_float worldVertices, spine_size_t offset, spine_size_t stride); +SPINE_C_EXPORT void spine_mesh_attachment_update_region(spine_mesh_attachment obj); +SPINE_C_EXPORT int32_t spine_mesh_attachment_get_hull_length(spine_mesh_attachment obj); +SPINE_C_EXPORT void spine_mesh_attachment_set_hull_length(spine_mesh_attachment obj, int32_t value); +SPINE_C_EXPORT void * spine_mesh_attachment_get_region_u_vs(spine_mesh_attachment obj); +SPINE_C_EXPORT int32_t spine_mesh_attachment_get_num_region_u_vs(spine_mesh_attachment obj); +SPINE_C_EXPORT spine_float *spine_mesh_attachment_get_region_u_vs(spine_mesh_attachment obj); +SPINE_C_EXPORT void spine_mesh_attachment_set_region_u_vs(spine_mesh_attachment obj, void * value); +SPINE_C_EXPORT void * spine_mesh_attachment_get_u_vs(spine_mesh_attachment obj); +SPINE_C_EXPORT int32_t spine_mesh_attachment_get_num_u_vs(spine_mesh_attachment obj); +SPINE_C_EXPORT spine_float *spine_mesh_attachment_get_u_vs(spine_mesh_attachment obj); +SPINE_C_EXPORT void * spine_mesh_attachment_get_triangles(spine_mesh_attachment obj); +SPINE_C_EXPORT int32_t spine_mesh_attachment_get_num_triangles(spine_mesh_attachment obj); +SPINE_C_EXPORT spine_unsigned short *spine_mesh_attachment_get_triangles(spine_mesh_attachment obj); +SPINE_C_EXPORT void spine_mesh_attachment_set_triangles(spine_mesh_attachment obj, void * value); +SPINE_C_EXPORT spine_color spine_mesh_attachment_get_color(spine_mesh_attachment obj); +SPINE_C_EXPORT const utf8 * spine_mesh_attachment_get_path(spine_mesh_attachment obj); +SPINE_C_EXPORT void spine_mesh_attachment_set_path(spine_mesh_attachment obj, const utf8 * value); +SPINE_C_EXPORT spine_texture_region spine_mesh_attachment_get_region(spine_mesh_attachment obj); +SPINE_C_EXPORT void spine_mesh_attachment_set_region(spine_mesh_attachment obj, spine_texture_region value); +SPINE_C_EXPORT spine_sequence spine_mesh_attachment_get_sequence(spine_mesh_attachment obj); +SPINE_C_EXPORT void spine_mesh_attachment_set_sequence(spine_mesh_attachment obj, spine_sequence value); +SPINE_C_EXPORT spine_mesh_attachment spine_mesh_attachment_get_parent_mesh(spine_mesh_attachment obj); +SPINE_C_EXPORT void spine_mesh_attachment_set_parent_mesh(spine_mesh_attachment obj, spine_mesh_attachment value); +SPINE_C_EXPORT void * spine_mesh_attachment_get_edges(spine_mesh_attachment obj); +SPINE_C_EXPORT int32_t spine_mesh_attachment_get_num_edges(spine_mesh_attachment obj); +SPINE_C_EXPORT spine_unsigned short *spine_mesh_attachment_get_edges(spine_mesh_attachment obj); +SPINE_C_EXPORT void spine_mesh_attachment_set_edges(spine_mesh_attachment obj, void * value); +SPINE_C_EXPORT float spine_mesh_attachment_get_width(spine_mesh_attachment obj); +SPINE_C_EXPORT void spine_mesh_attachment_set_width(spine_mesh_attachment obj, float value); +SPINE_C_EXPORT float spine_mesh_attachment_get_height(spine_mesh_attachment obj); +SPINE_C_EXPORT void spine_mesh_attachment_set_height(spine_mesh_attachment obj, float value); +SPINE_C_EXPORT spine_attachment spine_mesh_attachment_copy(spine_mesh_attachment obj); +SPINE_C_EXPORT spine_mesh_attachment spine_mesh_attachment_new_linked_mesh(spine_mesh_attachment obj); +SPINE_C_EXPORT void spine_mesh_attachment_compute_world_vertices(spine_mesh_attachment obj, spine_skeleton skeleton, spine_slot slot, spine_size_t start, spine_size_t count, void * worldVertices, spine_size_t offset, spine_size_t stride); +SPINE_C_EXPORT int32_t spine_mesh_attachment_get_id(spine_mesh_attachment obj); +SPINE_C_EXPORT int32_t * spine_mesh_attachment_get_bones(spine_mesh_attachment obj); +SPINE_C_EXPORT int32_t spine_mesh_attachment_get_num_bones(spine_mesh_attachment obj); +SPINE_C_EXPORT int32_t *spine_mesh_attachment_get_bones(spine_mesh_attachment obj); +SPINE_C_EXPORT void spine_mesh_attachment_set_bones(spine_mesh_attachment obj, int32_t * value); +SPINE_C_EXPORT void * spine_mesh_attachment_get_vertices(spine_mesh_attachment obj); +SPINE_C_EXPORT int32_t spine_mesh_attachment_get_num_vertices(spine_mesh_attachment obj); +SPINE_C_EXPORT spine_float *spine_mesh_attachment_get_vertices(spine_mesh_attachment obj); +SPINE_C_EXPORT void spine_mesh_attachment_set_vertices(spine_mesh_attachment obj, void * value); +SPINE_C_EXPORT spine_size_t spine_mesh_attachment_get_world_vertices_length(spine_mesh_attachment obj); +SPINE_C_EXPORT void spine_mesh_attachment_set_world_vertices_length(spine_mesh_attachment obj, spine_size_t value); +SPINE_C_EXPORT spine_attachment spine_mesh_attachment_get_timeline_attachment(spine_mesh_attachment obj); +SPINE_C_EXPORT void spine_mesh_attachment_set_timeline_attachment(spine_mesh_attachment obj, spine_attachment value); +SPINE_C_EXPORT void spine_mesh_attachment_copy_to(spine_mesh_attachment obj, spine_vertex_attachment other); + +#ifdef __cplusplus +} +#endif + +#endif // SPINE_C_MESHATTACHMENT_H \ No newline at end of file diff --git a/spine-c-new/src/generated/mix_blend.h b/spine-c-new/src/generated/mix_blend.h new file mode 100644 index 000000000..1ef76f175 --- /dev/null +++ b/spine-c-new/src/generated/mix_blend.h @@ -0,0 +1,50 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#ifndef SPINE_C_MIXBLEND_H +#define SPINE_C_MIXBLEND_H + +#include "../../custom.h" + +#ifdef __cplusplus +extern "C" { +#endif + +typedef enum spine_mix_blend { + SPINE_MIX_BLEND_MIX_BLEND_SETUP = 0, + SPINE_MIX_BLEND_MIX_BLEND_FIRST, + SPINE_MIX_BLEND_MIX_BLEND_REPLACE, + SPINE_MIX_BLEND_MIX_BLEND_ADD +} spine_mix_blend; + +#ifdef __cplusplus +} +#endif + +#endif // SPINE_C_MIXBLEND_H \ No newline at end of file diff --git a/spine-c-new/src/generated/mix_direction.h b/spine-c-new/src/generated/mix_direction.h new file mode 100644 index 000000000..f31dff3bd --- /dev/null +++ b/spine-c-new/src/generated/mix_direction.h @@ -0,0 +1,48 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#ifndef SPINE_C_MIXDIRECTION_H +#define SPINE_C_MIXDIRECTION_H + +#include "../../custom.h" + +#ifdef __cplusplus +extern "C" { +#endif + +typedef enum spine_mix_direction { + SPINE_MIX_DIRECTION_MIX_DIRECTION_IN = 0, + SPINE_MIX_DIRECTION_MIX_DIRECTION_OUT +} spine_mix_direction; + +#ifdef __cplusplus +} +#endif + +#endif // SPINE_C_MIXDIRECTION_H \ No newline at end of file diff --git a/spine-c-new/src/generated/path_attachment.cpp b/spine-c-new/src/generated/path_attachment.cpp new file mode 100644 index 000000000..c8abc989b --- /dev/null +++ b/spine-c-new/src/generated/path_attachment.cpp @@ -0,0 +1,205 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#include "path_attachment.h" +#include + +using namespace spine; + +spine_path_attachment spine_path_attachment_create(const utf8 * name) { + PathAttachment *obj = new (__FILE__, __LINE__) PathAttachment(String(name)); + return (spine_path_attachment) obj; +} + +void spine_path_attachment_dispose(spine_path_attachment obj) { + if (!obj) return; + delete (PathAttachment *) obj; +} + +spine_rtti spine_path_attachment_get_rtti(spine_path_attachment obj) { + if (!obj) return nullptr; + PathAttachment *_obj = (PathAttachment *) obj; + return (spine_rtti) &_obj->getRTTI(); +} + +void * spine_path_attachment_get_lengths(spine_path_attachment obj) { + if (!obj) return nullptr; + PathAttachment *_obj = (PathAttachment *) obj; + return _obj->getLengths(); +} + +int32_t spine_path_attachment_get_num_lengths(spine_path_attachment obj) { + if (!obj) return 0; + PathAttachment *_obj = (PathAttachment *) obj; + return (int32_t) _obj->getLengths().size(); +} + +spine_float *spine_path_attachment_get_lengths(spine_path_attachment obj) { + if (!obj) return nullptr; + PathAttachment *_obj = (PathAttachment *) obj; + return (spine_float *) _obj->getLengths().buffer(); +} + +void spine_path_attachment_set_lengths(spine_path_attachment obj, void * value) { + if (!obj) return; + PathAttachment *_obj = (PathAttachment *) obj; + _obj->setLengths((Vector &) value); +} + +spine_bool spine_path_attachment_is_closed(spine_path_attachment obj) { + if (!obj) return 0; + PathAttachment *_obj = (PathAttachment *) obj; + return _obj->isClosed(); +} + +void spine_path_attachment_set_closed(spine_path_attachment obj, spine_bool value) { + if (!obj) return; + PathAttachment *_obj = (PathAttachment *) obj; + _obj->setClosed(value); +} + +spine_bool spine_path_attachment_is_constant_speed(spine_path_attachment obj) { + if (!obj) return 0; + PathAttachment *_obj = (PathAttachment *) obj; + return _obj->isConstantSpeed(); +} + +void spine_path_attachment_set_constant_speed(spine_path_attachment obj, spine_bool value) { + if (!obj) return; + PathAttachment *_obj = (PathAttachment *) obj; + _obj->setConstantSpeed(value); +} + +spine_color spine_path_attachment_get_color(spine_path_attachment obj) { + if (!obj) return nullptr; + PathAttachment *_obj = (PathAttachment *) obj; + return (spine_color) &_obj->getColor(); +} + +spine_attachment spine_path_attachment_copy(spine_path_attachment obj) { + if (!obj) return nullptr; + PathAttachment *_obj = (PathAttachment *) obj; + return (spine_attachment) _obj->copy(); +} + +void spine_path_attachment_compute_world_vertices(spine_path_attachment obj, spine_skeleton skeleton, spine_slot slot, spine_size_t start, spine_size_t count, spine_float worldVertices, spine_size_t offset, spine_size_t stride) { + if (!obj) return ; + PathAttachment *_obj = (PathAttachment *) obj; + _obj->computeWorldVertices(skeleton, slot, start, count, (float *) worldVertices, offset, stride); +} + +void spine_path_attachment_compute_world_vertices(spine_path_attachment obj, spine_skeleton skeleton, spine_slot slot, spine_size_t start, spine_size_t count, void * worldVertices, spine_size_t offset, spine_size_t stride) { + if (!obj) return ; + PathAttachment *_obj = (PathAttachment *) obj; + _obj->computeWorldVertices(skeleton, slot, start, count, (Vector &) worldVertices, offset, stride); +} + +int32_t spine_path_attachment_get_id(spine_path_attachment obj) { + if (!obj) return 0; + PathAttachment *_obj = (PathAttachment *) obj; + return _obj->getId(); +} + +int32_t * spine_path_attachment_get_bones(spine_path_attachment obj) { + if (!obj) return 0; + PathAttachment *_obj = (PathAttachment *) obj; + return _obj->getBones(); +} + +int32_t spine_path_attachment_get_num_bones(spine_path_attachment obj) { + if (!obj) return 0; + PathAttachment *_obj = (PathAttachment *) obj; + return (int32_t) _obj->getBones().size(); +} + +int32_t *spine_path_attachment_get_bones(spine_path_attachment obj) { + if (!obj) return nullptr; + PathAttachment *_obj = (PathAttachment *) obj; + return (int32_t *) _obj->getBones().buffer(); +} + +void spine_path_attachment_set_bones(spine_path_attachment obj, int32_t * value) { + if (!obj) return; + PathAttachment *_obj = (PathAttachment *) obj; + _obj->setBones((Vector &) value); +} + +void * spine_path_attachment_get_vertices(spine_path_attachment obj) { + if (!obj) return nullptr; + PathAttachment *_obj = (PathAttachment *) obj; + return _obj->getVertices(); +} + +int32_t spine_path_attachment_get_num_vertices(spine_path_attachment obj) { + if (!obj) return 0; + PathAttachment *_obj = (PathAttachment *) obj; + return (int32_t) _obj->getVertices().size(); +} + +spine_float *spine_path_attachment_get_vertices(spine_path_attachment obj) { + if (!obj) return nullptr; + PathAttachment *_obj = (PathAttachment *) obj; + return (spine_float *) _obj->getVertices().buffer(); +} + +void spine_path_attachment_set_vertices(spine_path_attachment obj, void * value) { + if (!obj) return; + PathAttachment *_obj = (PathAttachment *) obj; + _obj->setVertices((Vector &) value); +} + +spine_size_t spine_path_attachment_get_world_vertices_length(spine_path_attachment obj) { + if (!obj) return nullptr; + PathAttachment *_obj = (PathAttachment *) obj; + return _obj->getWorldVerticesLength(); +} + +void spine_path_attachment_set_world_vertices_length(spine_path_attachment obj, spine_size_t value) { + if (!obj) return; + PathAttachment *_obj = (PathAttachment *) obj; + _obj->setWorldVerticesLength(value); +} + +spine_attachment spine_path_attachment_get_timeline_attachment(spine_path_attachment obj) { + if (!obj) return nullptr; + PathAttachment *_obj = (PathAttachment *) obj; + return (spine_attachment) _obj->getTimelineAttachment(); +} + +void spine_path_attachment_set_timeline_attachment(spine_path_attachment obj, spine_attachment value) { + if (!obj) return; + PathAttachment *_obj = (PathAttachment *) obj; + _obj->setTimelineAttachment((Attachment *) value); +} + +void spine_path_attachment_copy_to(spine_path_attachment obj, spine_vertex_attachment other) { + if (!obj) return ; + PathAttachment *_obj = (PathAttachment *) obj; + _obj->copyTo((VertexAttachment *) other); +} diff --git a/spine-c-new/src/generated/path_attachment.h b/spine-c-new/src/generated/path_attachment.h new file mode 100644 index 000000000..bc2d49b17 --- /dev/null +++ b/spine-c-new/src/generated/path_attachment.h @@ -0,0 +1,75 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#ifndef SPINE_C_PATHATTACHMENT_H +#define SPINE_C_PATHATTACHMENT_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include "../custom.h" + +SPINE_OPAQUE_TYPE(spine_path_attachment) + +SPINE_C_EXPORT spine_path_attachment spine_path_attachment_create(const utf8 * name); +SPINE_C_EXPORT void spine_path_attachment_dispose(spine_path_attachment obj); +SPINE_C_EXPORT spine_rtti spine_path_attachment_get_rtti(spine_path_attachment obj); +SPINE_C_EXPORT void * spine_path_attachment_get_lengths(spine_path_attachment obj); +SPINE_C_EXPORT int32_t spine_path_attachment_get_num_lengths(spine_path_attachment obj); +SPINE_C_EXPORT spine_float *spine_path_attachment_get_lengths(spine_path_attachment obj); +SPINE_C_EXPORT void spine_path_attachment_set_lengths(spine_path_attachment obj, void * value); +SPINE_C_EXPORT spine_bool spine_path_attachment_is_closed(spine_path_attachment obj); +SPINE_C_EXPORT void spine_path_attachment_set_closed(spine_path_attachment obj, spine_bool value); +SPINE_C_EXPORT spine_bool spine_path_attachment_is_constant_speed(spine_path_attachment obj); +SPINE_C_EXPORT void spine_path_attachment_set_constant_speed(spine_path_attachment obj, spine_bool value); +SPINE_C_EXPORT spine_color spine_path_attachment_get_color(spine_path_attachment obj); +SPINE_C_EXPORT spine_attachment spine_path_attachment_copy(spine_path_attachment obj); +SPINE_C_EXPORT void spine_path_attachment_compute_world_vertices(spine_path_attachment obj, spine_skeleton skeleton, spine_slot slot, spine_size_t start, spine_size_t count, spine_float worldVertices, spine_size_t offset, spine_size_t stride); +SPINE_C_EXPORT void spine_path_attachment_compute_world_vertices(spine_path_attachment obj, spine_skeleton skeleton, spine_slot slot, spine_size_t start, spine_size_t count, void * worldVertices, spine_size_t offset, spine_size_t stride); +SPINE_C_EXPORT int32_t spine_path_attachment_get_id(spine_path_attachment obj); +SPINE_C_EXPORT int32_t * spine_path_attachment_get_bones(spine_path_attachment obj); +SPINE_C_EXPORT int32_t spine_path_attachment_get_num_bones(spine_path_attachment obj); +SPINE_C_EXPORT int32_t *spine_path_attachment_get_bones(spine_path_attachment obj); +SPINE_C_EXPORT void spine_path_attachment_set_bones(spine_path_attachment obj, int32_t * value); +SPINE_C_EXPORT void * spine_path_attachment_get_vertices(spine_path_attachment obj); +SPINE_C_EXPORT int32_t spine_path_attachment_get_num_vertices(spine_path_attachment obj); +SPINE_C_EXPORT spine_float *spine_path_attachment_get_vertices(spine_path_attachment obj); +SPINE_C_EXPORT void spine_path_attachment_set_vertices(spine_path_attachment obj, void * value); +SPINE_C_EXPORT spine_size_t spine_path_attachment_get_world_vertices_length(spine_path_attachment obj); +SPINE_C_EXPORT void spine_path_attachment_set_world_vertices_length(spine_path_attachment obj, spine_size_t value); +SPINE_C_EXPORT spine_attachment spine_path_attachment_get_timeline_attachment(spine_path_attachment obj); +SPINE_C_EXPORT void spine_path_attachment_set_timeline_attachment(spine_path_attachment obj, spine_attachment value); +SPINE_C_EXPORT void spine_path_attachment_copy_to(spine_path_attachment obj, spine_vertex_attachment other); + +#ifdef __cplusplus +} +#endif + +#endif // SPINE_C_PATHATTACHMENT_H \ No newline at end of file diff --git a/spine-c-new/src/generated/path_constraint.cpp b/spine-c-new/src/generated/path_constraint.cpp new file mode 100644 index 000000000..53ca4df23 --- /dev/null +++ b/spine-c-new/src/generated/path_constraint.cpp @@ -0,0 +1,163 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#include "path_constraint.h" +#include + +using namespace spine; + +spine_path_constraint spine_path_constraint_create(spine_path_constraint_data data, spine_skeleton skeleton) { + PathConstraint *obj = new (__FILE__, __LINE__) PathConstraint(data, skeleton); + return (spine_path_constraint) obj; +} + +void spine_path_constraint_dispose(spine_path_constraint obj) { + if (!obj) return; + delete (PathConstraint *) obj; +} + +spine_rtti spine_path_constraint_get_rtti(spine_path_constraint obj) { + if (!obj) return nullptr; + PathConstraint *_obj = (PathConstraint *) obj; + return (spine_rtti) &_obj->getRTTI(); +} + +spine_path_constraint spine_path_constraint_copy(spine_path_constraint obj, spine_skeleton skeleton) { + if (!obj) return 0; + PathConstraint *_obj = (PathConstraint *) obj; + return (spine_path_constraint) _obj->copy(skeleton); +} + +void spine_path_constraint_update(spine_path_constraint obj, spine_skeleton skeleton, spine_physics physics) { + if (!obj) return ; + PathConstraint *_obj = (PathConstraint *) obj; + _obj->update(skeleton, physics); +} + +void spine_path_constraint_sort(spine_path_constraint obj, spine_skeleton skeleton) { + if (!obj) return ; + PathConstraint *_obj = (PathConstraint *) obj; + _obj->sort(skeleton); +} + +spine_bool spine_path_constraint_is_source_active(spine_path_constraint obj) { + if (!obj) return 0; + PathConstraint *_obj = (PathConstraint *) obj; + return _obj->isSourceActive(); +} + +void * spine_path_constraint_get_bones(spine_path_constraint obj) { + if (!obj) return nullptr; + PathConstraint *_obj = (PathConstraint *) obj; + return (void *) _obj->getBones(); +} + +int32_t spine_path_constraint_get_num_bones(spine_path_constraint obj) { + if (!obj) return 0; + PathConstraint *_obj = (PathConstraint *) obj; + return (int32_t) _obj->getBones().size(); +} + +spine_bone_pose *spine_path_constraint_get_bones(spine_path_constraint obj) { + if (!obj) return nullptr; + PathConstraint *_obj = (PathConstraint *) obj; + return (spine_bone_pose *) _obj->getBones().buffer(); +} + +spine_slot spine_path_constraint_get_slot(spine_path_constraint obj) { + if (!obj) return nullptr; + PathConstraint *_obj = (PathConstraint *) obj; + return (spine_slot) _obj->getSlot(); +} + +void spine_path_constraint_set_slot(spine_path_constraint obj, spine_slot value) { + if (!obj) return; + PathConstraint *_obj = (PathConstraint *) obj; + _obj->setSlot((Slot *) value); +} + +spine_path_constraint_data spine_path_constraint_get_data(spine_path_constraint obj) { + if (!obj) return 0; + PathConstraint *_obj = (PathConstraint *) obj; + return _obj->getData(); +} + +void spine_path_constraint_pose(spine_path_constraint obj) { + if (!obj) return ; + PathConstraint *_obj = (PathConstraint *) obj; + _obj->pose(); +} + +void spine_path_constraint_setup_pose(spine_path_constraint obj) { + if (!obj) return ; + PathConstraint *_obj = (PathConstraint *) obj; + _obj->setupPose(); +} + +spine_path_constraint_pose spine_path_constraint_get_pose(spine_path_constraint obj) { + if (!obj) return 0; + PathConstraint *_obj = (PathConstraint *) obj; + return _obj->getPose(); +} + +spine_path_constraint_pose spine_path_constraint_get_applied_pose(spine_path_constraint obj) { + if (!obj) return 0; + PathConstraint *_obj = (PathConstraint *) obj; + return _obj->getAppliedPose(); +} + +void spine_path_constraint_reset_constrained(spine_path_constraint obj) { + if (!obj) return ; + PathConstraint *_obj = (PathConstraint *) obj; + _obj->resetConstrained(); +} + +void spine_path_constraint_constrained(spine_path_constraint obj) { + if (!obj) return ; + PathConstraint *_obj = (PathConstraint *) obj; + _obj->constrained(); +} + +spine_bool spine_path_constraint_is_pose_equal_to_applied(spine_path_constraint obj) { + if (!obj) return 0; + PathConstraint *_obj = (PathConstraint *) obj; + return _obj->isPoseEqualToApplied(); +} + +spine_bool spine_path_constraint_is_active(spine_path_constraint obj) { + if (!obj) return 0; + PathConstraint *_obj = (PathConstraint *) obj; + return _obj->isActive(); +} + +void spine_path_constraint_set_active(spine_path_constraint obj, spine_bool value) { + if (!obj) return; + PathConstraint *_obj = (PathConstraint *) obj; + _obj->setActive(value); +} diff --git a/spine-c-new/src/generated/path_constraint.h b/spine-c-new/src/generated/path_constraint.h new file mode 100644 index 000000000..af0d98cd2 --- /dev/null +++ b/spine-c-new/src/generated/path_constraint.h @@ -0,0 +1,68 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#ifndef SPINE_C_PATHCONSTRAINT_H +#define SPINE_C_PATHCONSTRAINT_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include "../custom.h" + +SPINE_OPAQUE_TYPE(spine_path_constraint) + +SPINE_C_EXPORT spine_path_constraint spine_path_constraint_create(spine_path_constraint_data data, spine_skeleton skeleton); +SPINE_C_EXPORT void spine_path_constraint_dispose(spine_path_constraint obj); +SPINE_C_EXPORT spine_rtti spine_path_constraint_get_rtti(spine_path_constraint obj); +SPINE_C_EXPORT spine_path_constraint spine_path_constraint_copy(spine_path_constraint obj, spine_skeleton skeleton); +SPINE_C_EXPORT void spine_path_constraint_update(spine_path_constraint obj, spine_skeleton skeleton, spine_physics physics); +SPINE_C_EXPORT void spine_path_constraint_sort(spine_path_constraint obj, spine_skeleton skeleton); +SPINE_C_EXPORT spine_bool spine_path_constraint_is_source_active(spine_path_constraint obj); +SPINE_C_EXPORT void * spine_path_constraint_get_bones(spine_path_constraint obj); +SPINE_C_EXPORT int32_t spine_path_constraint_get_num_bones(spine_path_constraint obj); +SPINE_C_EXPORT spine_bone_pose *spine_path_constraint_get_bones(spine_path_constraint obj); +SPINE_C_EXPORT spine_slot spine_path_constraint_get_slot(spine_path_constraint obj); +SPINE_C_EXPORT void spine_path_constraint_set_slot(spine_path_constraint obj, spine_slot value); +SPINE_C_EXPORT spine_path_constraint_data spine_path_constraint_get_data(spine_path_constraint obj); +SPINE_C_EXPORT void spine_path_constraint_pose(spine_path_constraint obj); +SPINE_C_EXPORT void spine_path_constraint_setup_pose(spine_path_constraint obj); +SPINE_C_EXPORT spine_path_constraint_pose spine_path_constraint_get_pose(spine_path_constraint obj); +SPINE_C_EXPORT spine_path_constraint_pose spine_path_constraint_get_applied_pose(spine_path_constraint obj); +SPINE_C_EXPORT void spine_path_constraint_reset_constrained(spine_path_constraint obj); +SPINE_C_EXPORT void spine_path_constraint_constrained(spine_path_constraint obj); +SPINE_C_EXPORT spine_bool spine_path_constraint_is_pose_equal_to_applied(spine_path_constraint obj); +SPINE_C_EXPORT spine_bool spine_path_constraint_is_active(spine_path_constraint obj); +SPINE_C_EXPORT void spine_path_constraint_set_active(spine_path_constraint obj, spine_bool value); + +#ifdef __cplusplus +} +#endif + +#endif // SPINE_C_PATHCONSTRAINT_H \ No newline at end of file diff --git a/spine-c-new/src/generated/path_constraint_data.cpp b/spine-c-new/src/generated/path_constraint_data.cpp new file mode 100644 index 000000000..0dd145d47 --- /dev/null +++ b/spine-c-new/src/generated/path_constraint_data.cpp @@ -0,0 +1,157 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#include "path_constraint_data.h" +#include + +using namespace spine; + +spine_path_constraint_data spine_path_constraint_data_create(const utf8 * name) { + PathConstraintData *obj = new (__FILE__, __LINE__) PathConstraintData(String(name)); + return (spine_path_constraint_data) obj; +} + +void spine_path_constraint_data_dispose(spine_path_constraint_data obj) { + if (!obj) return; + delete (PathConstraintData *) obj; +} + +spine_rtti spine_path_constraint_data_get_rtti(spine_path_constraint_data obj) { + if (!obj) return nullptr; + PathConstraintData *_obj = (PathConstraintData *) obj; + return (spine_rtti) &_obj->getRTTI(); +} + +spine_constraint spine_path_constraint_data_create(spine_path_constraint_data obj, spine_skeleton skeleton) { + if (!obj) return 0; + PathConstraintData *_obj = (PathConstraintData *) obj; + return (spine_constraint) _obj->create(skeleton); +} + +void * spine_path_constraint_data_get_bones(spine_path_constraint_data obj) { + if (!obj) return nullptr; + PathConstraintData *_obj = (PathConstraintData *) obj; + return (void *) _obj->getBones(); +} + +int32_t spine_path_constraint_data_get_num_bones(spine_path_constraint_data obj) { + if (!obj) return 0; + PathConstraintData *_obj = (PathConstraintData *) obj; + return (int32_t) _obj->getBones().size(); +} + +spine_bone_data *spine_path_constraint_data_get_bones(spine_path_constraint_data obj) { + if (!obj) return nullptr; + PathConstraintData *_obj = (PathConstraintData *) obj; + return (spine_bone_data *) _obj->getBones().buffer(); +} + +spine_slot_data spine_path_constraint_data_get_slot(spine_path_constraint_data obj) { + if (!obj) return nullptr; + PathConstraintData *_obj = (PathConstraintData *) obj; + return (spine_slot_data) _obj->getSlot(); +} + +void spine_path_constraint_data_set_slot(spine_path_constraint_data obj, spine_slot_data value) { + if (!obj) return; + PathConstraintData *_obj = (PathConstraintData *) obj; + _obj->setSlot((SlotData *) value); +} + +spine_position_mode spine_path_constraint_data_get_position_mode(spine_path_constraint_data obj) { + if (!obj) return nullptr; + PathConstraintData *_obj = (PathConstraintData *) obj; + return _obj->getPositionMode(); +} + +void spine_path_constraint_data_set_position_mode(spine_path_constraint_data obj, spine_position_mode value) { + if (!obj) return; + PathConstraintData *_obj = (PathConstraintData *) obj; + _obj->setPositionMode(value); +} + +spine_spacing_mode spine_path_constraint_data_get_spacing_mode(spine_path_constraint_data obj) { + if (!obj) return nullptr; + PathConstraintData *_obj = (PathConstraintData *) obj; + return _obj->getSpacingMode(); +} + +void spine_path_constraint_data_set_spacing_mode(spine_path_constraint_data obj, spine_spacing_mode value) { + if (!obj) return; + PathConstraintData *_obj = (PathConstraintData *) obj; + _obj->setSpacingMode(value); +} + +spine_rotate_mode spine_path_constraint_data_get_rotate_mode(spine_path_constraint_data obj) { + if (!obj) return nullptr; + PathConstraintData *_obj = (PathConstraintData *) obj; + return _obj->getRotateMode(); +} + +void spine_path_constraint_data_set_rotate_mode(spine_path_constraint_data obj, spine_rotate_mode value) { + if (!obj) return; + PathConstraintData *_obj = (PathConstraintData *) obj; + _obj->setRotateMode(value); +} + +float spine_path_constraint_data_get_offset_rotation(spine_path_constraint_data obj) { + if (!obj) return 0; + PathConstraintData *_obj = (PathConstraintData *) obj; + return _obj->getOffsetRotation(); +} + +void spine_path_constraint_data_set_offset_rotation(spine_path_constraint_data obj, float value) { + if (!obj) return; + PathConstraintData *_obj = (PathConstraintData *) obj; + _obj->setOffsetRotation(value); +} + +const utf8 * spine_path_constraint_data_get_name(spine_path_constraint_data obj) { + if (!obj) return nullptr; + PathConstraintData *_obj = (PathConstraintData *) obj; + return (const utf8 *) _obj->getName().buffer(); +} + +spine_bool spine_path_constraint_data_is_skin_required(spine_path_constraint_data obj) { + if (!obj) return 0; + PathConstraintData *_obj = (PathConstraintData *) obj; + return _obj->isSkinRequired(); +} + +spine_path_constraint_pose spine_path_constraint_data_get_setup_pose(spine_path_constraint_data obj) { + if (!obj) return 0; + PathConstraintData *_obj = (PathConstraintData *) obj; + return _obj->getSetupPose(); +} + +spine_path_constraint_pose spine_path_constraint_data_get_setup_pose(spine_path_constraint_data obj) { + if (!obj) return 0; + PathConstraintData *_obj = (PathConstraintData *) obj; + return _obj->getSetupPose(); +} diff --git a/spine-c-new/src/generated/path_constraint_data.h b/spine-c-new/src/generated/path_constraint_data.h new file mode 100644 index 000000000..181f9727b --- /dev/null +++ b/spine-c-new/src/generated/path_constraint_data.h @@ -0,0 +1,67 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#ifndef SPINE_C_PATHCONSTRAINTDATA_H +#define SPINE_C_PATHCONSTRAINTDATA_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include "../custom.h" + +SPINE_OPAQUE_TYPE(spine_path_constraint_data) + +SPINE_C_EXPORT spine_path_constraint_data spine_path_constraint_data_create(const utf8 * name); +SPINE_C_EXPORT void spine_path_constraint_data_dispose(spine_path_constraint_data obj); +SPINE_C_EXPORT spine_rtti spine_path_constraint_data_get_rtti(spine_path_constraint_data obj); +SPINE_C_EXPORT spine_constraint spine_path_constraint_data_create(spine_path_constraint_data obj, spine_skeleton skeleton); +SPINE_C_EXPORT void * spine_path_constraint_data_get_bones(spine_path_constraint_data obj); +SPINE_C_EXPORT int32_t spine_path_constraint_data_get_num_bones(spine_path_constraint_data obj); +SPINE_C_EXPORT spine_bone_data *spine_path_constraint_data_get_bones(spine_path_constraint_data obj); +SPINE_C_EXPORT spine_slot_data spine_path_constraint_data_get_slot(spine_path_constraint_data obj); +SPINE_C_EXPORT void spine_path_constraint_data_set_slot(spine_path_constraint_data obj, spine_slot_data value); +SPINE_C_EXPORT spine_position_mode spine_path_constraint_data_get_position_mode(spine_path_constraint_data obj); +SPINE_C_EXPORT void spine_path_constraint_data_set_position_mode(spine_path_constraint_data obj, spine_position_mode value); +SPINE_C_EXPORT spine_spacing_mode spine_path_constraint_data_get_spacing_mode(spine_path_constraint_data obj); +SPINE_C_EXPORT void spine_path_constraint_data_set_spacing_mode(spine_path_constraint_data obj, spine_spacing_mode value); +SPINE_C_EXPORT spine_rotate_mode spine_path_constraint_data_get_rotate_mode(spine_path_constraint_data obj); +SPINE_C_EXPORT void spine_path_constraint_data_set_rotate_mode(spine_path_constraint_data obj, spine_rotate_mode value); +SPINE_C_EXPORT float spine_path_constraint_data_get_offset_rotation(spine_path_constraint_data obj); +SPINE_C_EXPORT void spine_path_constraint_data_set_offset_rotation(spine_path_constraint_data obj, float value); +SPINE_C_EXPORT const utf8 * spine_path_constraint_data_get_name(spine_path_constraint_data obj); +SPINE_C_EXPORT spine_bool spine_path_constraint_data_is_skin_required(spine_path_constraint_data obj); +SPINE_C_EXPORT spine_path_constraint_pose spine_path_constraint_data_get_setup_pose(spine_path_constraint_data obj); +SPINE_C_EXPORT spine_path_constraint_pose spine_path_constraint_data_get_setup_pose(spine_path_constraint_data obj); + +#ifdef __cplusplus +} +#endif + +#endif // SPINE_C_PATHCONSTRAINTDATA_H \ No newline at end of file diff --git a/spine-c-new/src/generated/path_constraint_mix_timeline.cpp b/spine-c-new/src/generated/path_constraint_mix_timeline.cpp new file mode 100644 index 000000000..274aef034 --- /dev/null +++ b/spine-c-new/src/generated/path_constraint_mix_timeline.cpp @@ -0,0 +1,169 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#include "path_constraint_mix_timeline.h" +#include + +using namespace spine; + +spine_path_constraint_mix_timeline spine_path_constraint_mix_timeline_create(spine_size_t frameCount, spine_size_t bezierCount, int32_t constraintIndex) { + PathConstraintMixTimeline *obj = new (__FILE__, __LINE__) PathConstraintMixTimeline(frameCount, bezierCount, constraintIndex); + return (spine_path_constraint_mix_timeline) obj; +} + +void spine_path_constraint_mix_timeline_dispose(spine_path_constraint_mix_timeline obj) { + if (!obj) return; + delete (PathConstraintMixTimeline *) obj; +} + +spine_rtti spine_path_constraint_mix_timeline_get_rtti(spine_path_constraint_mix_timeline obj) { + if (!obj) return nullptr; + PathConstraintMixTimeline *_obj = (PathConstraintMixTimeline *) obj; + return (spine_rtti) &_obj->getRTTI(); +} + +void spine_path_constraint_mix_timeline_apply(spine_path_constraint_mix_timeline obj, spine_skeleton skeleton, float lastTime, float time, void * pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction, spine_bool appliedPose) { + if (!obj) return ; + PathConstraintMixTimeline *_obj = (PathConstraintMixTimeline *) obj; + _obj->apply(skeleton, lastTime, time, (Vector *) pEvents, alpha, blend, direction, appliedPose); +} + +void spine_path_constraint_mix_timeline_set_frame(spine_path_constraint_mix_timeline obj, int32_t frame, float time, float mixRotate, float mixX, float mixY) { + if (!obj) return ; + PathConstraintMixTimeline *_obj = (PathConstraintMixTimeline *) obj; + _obj->setFrame(frame, time, mixRotate, mixX, mixY); +} + +void spine_path_constraint_mix_timeline_set_linear(spine_path_constraint_mix_timeline obj, spine_size_t value) { + if (!obj) return; + PathConstraintMixTimeline *_obj = (PathConstraintMixTimeline *) obj; + _obj->setLinear(value); +} + +void spine_path_constraint_mix_timeline_set_stepped(spine_path_constraint_mix_timeline obj, spine_size_t value) { + if (!obj) return; + PathConstraintMixTimeline *_obj = (PathConstraintMixTimeline *) obj; + _obj->setStepped(value); +} + +void spine_path_constraint_mix_timeline_set_bezier(spine_path_constraint_mix_timeline obj, spine_size_t bezier, spine_size_t frame, float value, float time1, float value1, float cx1, float cy1, float cx2, float cy2, float time2, float value2) { + if (!obj) return ; + PathConstraintMixTimeline *_obj = (PathConstraintMixTimeline *) obj; + _obj->setBezier(bezier, frame, value, time1, value1, cx1, cy1, cx2, cy2, time2, value2); +} + +float spine_path_constraint_mix_timeline_get_bezier_value(spine_path_constraint_mix_timeline obj, float time, spine_size_t frame, spine_size_t valueOffset, spine_size_t i) { + if (!obj) return 0; + PathConstraintMixTimeline *_obj = (PathConstraintMixTimeline *) obj; + return _obj->getBezierValue(time, frame, valueOffset, i); +} + +void * spine_path_constraint_mix_timeline_get_curves(spine_path_constraint_mix_timeline obj) { + if (!obj) return nullptr; + PathConstraintMixTimeline *_obj = (PathConstraintMixTimeline *) obj; + return _obj->getCurves(); +} + +int32_t spine_path_constraint_mix_timeline_get_num_curves(spine_path_constraint_mix_timeline obj) { + if (!obj) return 0; + PathConstraintMixTimeline *_obj = (PathConstraintMixTimeline *) obj; + return (int32_t) _obj->getCurves().size(); +} + +spine_float *spine_path_constraint_mix_timeline_get_curves(spine_path_constraint_mix_timeline obj) { + if (!obj) return nullptr; + PathConstraintMixTimeline *_obj = (PathConstraintMixTimeline *) obj; + return (spine_float *) _obj->getCurves().buffer(); +} + +spine_size_t spine_path_constraint_mix_timeline_get_frame_entries(spine_path_constraint_mix_timeline obj) { + if (!obj) return nullptr; + PathConstraintMixTimeline *_obj = (PathConstraintMixTimeline *) obj; + return _obj->getFrameEntries(); +} + +spine_size_t spine_path_constraint_mix_timeline_get_frame_count(spine_path_constraint_mix_timeline obj) { + if (!obj) return nullptr; + PathConstraintMixTimeline *_obj = (PathConstraintMixTimeline *) obj; + return _obj->getFrameCount(); +} + +void * spine_path_constraint_mix_timeline_get_frames(spine_path_constraint_mix_timeline obj) { + if (!obj) return nullptr; + PathConstraintMixTimeline *_obj = (PathConstraintMixTimeline *) obj; + return _obj->getFrames(); +} + +int32_t spine_path_constraint_mix_timeline_get_num_frames(spine_path_constraint_mix_timeline obj) { + if (!obj) return 0; + PathConstraintMixTimeline *_obj = (PathConstraintMixTimeline *) obj; + return (int32_t) _obj->getFrames().size(); +} + +spine_float *spine_path_constraint_mix_timeline_get_frames(spine_path_constraint_mix_timeline obj) { + if (!obj) return nullptr; + PathConstraintMixTimeline *_obj = (PathConstraintMixTimeline *) obj; + return (spine_float *) _obj->getFrames().buffer(); +} + +float spine_path_constraint_mix_timeline_get_duration(spine_path_constraint_mix_timeline obj) { + if (!obj) return 0; + PathConstraintMixTimeline *_obj = (PathConstraintMixTimeline *) obj; + return _obj->getDuration(); +} + +void * spine_path_constraint_mix_timeline_get_property_ids(spine_path_constraint_mix_timeline obj) { + if (!obj) return nullptr; + PathConstraintMixTimeline *_obj = (PathConstraintMixTimeline *) obj; + return _obj->getPropertyIds(); +} + +int32_t spine_path_constraint_mix_timeline_get_num_property_ids(spine_path_constraint_mix_timeline obj) { + if (!obj) return 0; + PathConstraintMixTimeline *_obj = (PathConstraintMixTimeline *) obj; + return (int32_t) _obj->getPropertyIds().size(); +} + +spine_property_id *spine_path_constraint_mix_timeline_get_property_ids(spine_path_constraint_mix_timeline obj) { + if (!obj) return nullptr; + PathConstraintMixTimeline *_obj = (PathConstraintMixTimeline *) obj; + return (spine_property_id *) _obj->getPropertyIds().buffer(); +} + +int32_t spine_path_constraint_mix_timeline_get_constraint_index(spine_path_constraint_mix_timeline obj) { + if (!obj) return 0; + PathConstraintMixTimeline *_obj = (PathConstraintMixTimeline *) obj; + return _obj->getConstraintIndex(); +} + +void spine_path_constraint_mix_timeline_set_constraint_index(spine_path_constraint_mix_timeline obj, int32_t value) { + if (!obj) return; + PathConstraintMixTimeline *_obj = (PathConstraintMixTimeline *) obj; + _obj->setConstraintIndex(value); +} diff --git a/spine-c-new/src/generated/path_constraint_mix_timeline.h b/spine-c-new/src/generated/path_constraint_mix_timeline.h new file mode 100644 index 000000000..ff7bbadd8 --- /dev/null +++ b/spine-c-new/src/generated/path_constraint_mix_timeline.h @@ -0,0 +1,69 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#ifndef SPINE_C_PATHCONSTRAINTMIXTIMELINE_H +#define SPINE_C_PATHCONSTRAINTMIXTIMELINE_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include "../custom.h" + +SPINE_OPAQUE_TYPE(spine_path_constraint_mix_timeline) + +SPINE_C_EXPORT spine_path_constraint_mix_timeline spine_path_constraint_mix_timeline_create(spine_size_t frameCount, spine_size_t bezierCount, int32_t constraintIndex); +SPINE_C_EXPORT void spine_path_constraint_mix_timeline_dispose(spine_path_constraint_mix_timeline obj); +SPINE_C_EXPORT spine_rtti spine_path_constraint_mix_timeline_get_rtti(spine_path_constraint_mix_timeline obj); +SPINE_C_EXPORT void spine_path_constraint_mix_timeline_apply(spine_path_constraint_mix_timeline obj, spine_skeleton skeleton, float lastTime, float time, void * pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction, spine_bool appliedPose); +SPINE_C_EXPORT void spine_path_constraint_mix_timeline_set_frame(spine_path_constraint_mix_timeline obj, int32_t frame, float time, float mixRotate, float mixX, float mixY); +SPINE_C_EXPORT void spine_path_constraint_mix_timeline_set_linear(spine_path_constraint_mix_timeline obj, spine_size_t value); +SPINE_C_EXPORT void spine_path_constraint_mix_timeline_set_stepped(spine_path_constraint_mix_timeline obj, spine_size_t value); +SPINE_C_EXPORT void spine_path_constraint_mix_timeline_set_bezier(spine_path_constraint_mix_timeline obj, spine_size_t bezier, spine_size_t frame, float value, float time1, float value1, float cx1, float cy1, float cx2, float cy2, float time2, float value2); +SPINE_C_EXPORT float spine_path_constraint_mix_timeline_get_bezier_value(spine_path_constraint_mix_timeline obj, float time, spine_size_t frame, spine_size_t valueOffset, spine_size_t i); +SPINE_C_EXPORT void * spine_path_constraint_mix_timeline_get_curves(spine_path_constraint_mix_timeline obj); +SPINE_C_EXPORT int32_t spine_path_constraint_mix_timeline_get_num_curves(spine_path_constraint_mix_timeline obj); +SPINE_C_EXPORT spine_float *spine_path_constraint_mix_timeline_get_curves(spine_path_constraint_mix_timeline obj); +SPINE_C_EXPORT spine_size_t spine_path_constraint_mix_timeline_get_frame_entries(spine_path_constraint_mix_timeline obj); +SPINE_C_EXPORT spine_size_t spine_path_constraint_mix_timeline_get_frame_count(spine_path_constraint_mix_timeline obj); +SPINE_C_EXPORT void * spine_path_constraint_mix_timeline_get_frames(spine_path_constraint_mix_timeline obj); +SPINE_C_EXPORT int32_t spine_path_constraint_mix_timeline_get_num_frames(spine_path_constraint_mix_timeline obj); +SPINE_C_EXPORT spine_float *spine_path_constraint_mix_timeline_get_frames(spine_path_constraint_mix_timeline obj); +SPINE_C_EXPORT float spine_path_constraint_mix_timeline_get_duration(spine_path_constraint_mix_timeline obj); +SPINE_C_EXPORT void * spine_path_constraint_mix_timeline_get_property_ids(spine_path_constraint_mix_timeline obj); +SPINE_C_EXPORT int32_t spine_path_constraint_mix_timeline_get_num_property_ids(spine_path_constraint_mix_timeline obj); +SPINE_C_EXPORT spine_property_id *spine_path_constraint_mix_timeline_get_property_ids(spine_path_constraint_mix_timeline obj); +SPINE_C_EXPORT int32_t spine_path_constraint_mix_timeline_get_constraint_index(spine_path_constraint_mix_timeline obj); +SPINE_C_EXPORT void spine_path_constraint_mix_timeline_set_constraint_index(spine_path_constraint_mix_timeline obj, int32_t value); + +#ifdef __cplusplus +} +#endif + +#endif // SPINE_C_PATHCONSTRAINTMIXTIMELINE_H \ No newline at end of file diff --git a/spine-c-new/src/generated/path_constraint_pose.cpp b/spine-c-new/src/generated/path_constraint_pose.cpp new file mode 100644 index 000000000..e961a9d0a --- /dev/null +++ b/spine-c-new/src/generated/path_constraint_pose.cpp @@ -0,0 +1,109 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#include "path_constraint_pose.h" +#include + +using namespace spine; + +spine_path_constraint_pose spine_path_constraint_pose_create(void) { + PathConstraintPose *obj = new (__FILE__, __LINE__) PathConstraintPose(); + return (spine_path_constraint_pose) obj; +} + +void spine_path_constraint_pose_dispose(spine_path_constraint_pose obj) { + if (!obj) return; + delete (PathConstraintPose *) obj; +} + +void spine_path_constraint_pose_set(spine_path_constraint_pose obj, spine_path_constraint_pose value) { + if (!obj) return; + PathConstraintPose *_obj = (PathConstraintPose *) obj; + _obj->set(value); +} + +float spine_path_constraint_pose_get_position(spine_path_constraint_pose obj) { + if (!obj) return 0; + PathConstraintPose *_obj = (PathConstraintPose *) obj; + return _obj->getPosition(); +} + +void spine_path_constraint_pose_set_position(spine_path_constraint_pose obj, float value) { + if (!obj) return; + PathConstraintPose *_obj = (PathConstraintPose *) obj; + _obj->setPosition(value); +} + +float spine_path_constraint_pose_get_spacing(spine_path_constraint_pose obj) { + if (!obj) return 0; + PathConstraintPose *_obj = (PathConstraintPose *) obj; + return _obj->getSpacing(); +} + +void spine_path_constraint_pose_set_spacing(spine_path_constraint_pose obj, float value) { + if (!obj) return; + PathConstraintPose *_obj = (PathConstraintPose *) obj; + _obj->setSpacing(value); +} + +float spine_path_constraint_pose_get_mix_rotate(spine_path_constraint_pose obj) { + if (!obj) return 0; + PathConstraintPose *_obj = (PathConstraintPose *) obj; + return _obj->getMixRotate(); +} + +void spine_path_constraint_pose_set_mix_rotate(spine_path_constraint_pose obj, float value) { + if (!obj) return; + PathConstraintPose *_obj = (PathConstraintPose *) obj; + _obj->setMixRotate(value); +} + +float spine_path_constraint_pose_get_mix_x(spine_path_constraint_pose obj) { + if (!obj) return 0; + PathConstraintPose *_obj = (PathConstraintPose *) obj; + return _obj->getMixX(); +} + +void spine_path_constraint_pose_set_mix_x(spine_path_constraint_pose obj, float value) { + if (!obj) return; + PathConstraintPose *_obj = (PathConstraintPose *) obj; + _obj->setMixX(value); +} + +float spine_path_constraint_pose_get_mix_y(spine_path_constraint_pose obj) { + if (!obj) return 0; + PathConstraintPose *_obj = (PathConstraintPose *) obj; + return _obj->getMixY(); +} + +void spine_path_constraint_pose_set_mix_y(spine_path_constraint_pose obj, float value) { + if (!obj) return; + PathConstraintPose *_obj = (PathConstraintPose *) obj; + _obj->setMixY(value); +} diff --git a/spine-c-new/src/generated/path_constraint_pose.h b/spine-c-new/src/generated/path_constraint_pose.h new file mode 100644 index 000000000..45d440a19 --- /dev/null +++ b/spine-c-new/src/generated/path_constraint_pose.h @@ -0,0 +1,59 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#ifndef SPINE_C_PATHCONSTRAINTPOSE_H +#define SPINE_C_PATHCONSTRAINTPOSE_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include "../custom.h" + +SPINE_OPAQUE_TYPE(spine_path_constraint_pose) + +SPINE_C_EXPORT spine_path_constraint_pose spine_path_constraint_pose_create(void); +SPINE_C_EXPORT void spine_path_constraint_pose_dispose(spine_path_constraint_pose obj); +SPINE_C_EXPORT void spine_path_constraint_pose_set(spine_path_constraint_pose obj, spine_path_constraint_pose value); +SPINE_C_EXPORT float spine_path_constraint_pose_get_position(spine_path_constraint_pose obj); +SPINE_C_EXPORT void spine_path_constraint_pose_set_position(spine_path_constraint_pose obj, float value); +SPINE_C_EXPORT float spine_path_constraint_pose_get_spacing(spine_path_constraint_pose obj); +SPINE_C_EXPORT void spine_path_constraint_pose_set_spacing(spine_path_constraint_pose obj, float value); +SPINE_C_EXPORT float spine_path_constraint_pose_get_mix_rotate(spine_path_constraint_pose obj); +SPINE_C_EXPORT void spine_path_constraint_pose_set_mix_rotate(spine_path_constraint_pose obj, float value); +SPINE_C_EXPORT float spine_path_constraint_pose_get_mix_x(spine_path_constraint_pose obj); +SPINE_C_EXPORT void spine_path_constraint_pose_set_mix_x(spine_path_constraint_pose obj, float value); +SPINE_C_EXPORT float spine_path_constraint_pose_get_mix_y(spine_path_constraint_pose obj); +SPINE_C_EXPORT void spine_path_constraint_pose_set_mix_y(spine_path_constraint_pose obj, float value); + +#ifdef __cplusplus +} +#endif + +#endif // SPINE_C_PATHCONSTRAINTPOSE_H \ No newline at end of file diff --git a/spine-c-new/src/generated/path_constraint_position_timeline.cpp b/spine-c-new/src/generated/path_constraint_position_timeline.cpp new file mode 100644 index 000000000..e6256b2d4 --- /dev/null +++ b/spine-c-new/src/generated/path_constraint_position_timeline.cpp @@ -0,0 +1,103 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#include "path_constraint_position_timeline.h" +#include + +using namespace spine; + +spine_path_constraint_position_timeline spine_path_constraint_position_timeline_create(spine_size_t frameCount, spine_size_t bezierCount, int32_t constraintIndex) { + PathConstraintPositionTimeline *obj = new (__FILE__, __LINE__) PathConstraintPositionTimeline(frameCount, bezierCount, constraintIndex); + return (spine_path_constraint_position_timeline) obj; +} + +void spine_path_constraint_position_timeline_dispose(spine_path_constraint_position_timeline obj) { + if (!obj) return; + delete (PathConstraintPositionTimeline *) obj; +} + +spine_rtti spine_path_constraint_position_timeline_get_rtti(spine_path_constraint_position_timeline obj) { + if (!obj) return nullptr; + PathConstraintPositionTimeline *_obj = (PathConstraintPositionTimeline *) obj; + return (spine_rtti) &_obj->getRTTI(); +} + +void spine_path_constraint_position_timeline_apply(spine_path_constraint_position_timeline obj, spine_skeleton skeleton, float lastTime, float time, void * pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction, spine_bool appliedPose) { + if (!obj) return ; + PathConstraintPositionTimeline *_obj = (PathConstraintPositionTimeline *) obj; + _obj->apply(skeleton, lastTime, time, (Vector *) pEvents, alpha, blend, direction, appliedPose); +} + +void spine_path_constraint_position_timeline_set_frame(spine_path_constraint_position_timeline obj, spine_size_t frame, float time, float value) { + if (!obj) return ; + PathConstraintPositionTimeline *_obj = (PathConstraintPositionTimeline *) obj; + _obj->setFrame(frame, time, value); +} + +float spine_path_constraint_position_timeline_get_curve_value(spine_path_constraint_position_timeline obj, float time) { + if (!obj) return 0; + PathConstraintPositionTimeline *_obj = (PathConstraintPositionTimeline *) obj; + return _obj->getCurveValue(time); +} + +float spine_path_constraint_position_timeline_get_relative_value(spine_path_constraint_position_timeline obj, float time, float alpha, spine_mix_blend blend, float current, float setup) { + if (!obj) return 0; + PathConstraintPositionTimeline *_obj = (PathConstraintPositionTimeline *) obj; + return _obj->getRelativeValue(time, alpha, blend, current, setup); +} + +float spine_path_constraint_position_timeline_get_absolute_value(spine_path_constraint_position_timeline obj, float time, float alpha, spine_mix_blend blend, float current, float setup) { + if (!obj) return 0; + PathConstraintPositionTimeline *_obj = (PathConstraintPositionTimeline *) obj; + return _obj->getAbsoluteValue(time, alpha, blend, current, setup); +} + +float spine_path_constraint_position_timeline_get_absolute_value(spine_path_constraint_position_timeline obj, float time, float alpha, spine_mix_blend blend, float current, float setup, float value) { + if (!obj) return 0; + PathConstraintPositionTimeline *_obj = (PathConstraintPositionTimeline *) obj; + return _obj->getAbsoluteValue(time, alpha, blend, current, setup, value); +} + +float spine_path_constraint_position_timeline_get_scale_value(spine_path_constraint_position_timeline obj, float time, float alpha, spine_mix_blend blend, spine_mix_direction direction, float current, float setup) { + if (!obj) return 0; + PathConstraintPositionTimeline *_obj = (PathConstraintPositionTimeline *) obj; + return _obj->getScaleValue(time, alpha, blend, direction, current, setup); +} + +int32_t spine_path_constraint_position_timeline_get_constraint_index(spine_path_constraint_position_timeline obj) { + if (!obj) return 0; + PathConstraintPositionTimeline *_obj = (PathConstraintPositionTimeline *) obj; + return _obj->getConstraintIndex(); +} + +void spine_path_constraint_position_timeline_set_constraint_index(spine_path_constraint_position_timeline obj, int32_t value) { + if (!obj) return; + PathConstraintPositionTimeline *_obj = (PathConstraintPositionTimeline *) obj; + _obj->setConstraintIndex(value); +} diff --git a/spine-c-new/src/generated/path_constraint_position_timeline.h b/spine-c-new/src/generated/path_constraint_position_timeline.h new file mode 100644 index 000000000..13e9e4e17 --- /dev/null +++ b/spine-c-new/src/generated/path_constraint_position_timeline.h @@ -0,0 +1,58 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#ifndef SPINE_C_PATHCONSTRAINTPOSITIONTIMELINE_H +#define SPINE_C_PATHCONSTRAINTPOSITIONTIMELINE_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include "../custom.h" + +SPINE_OPAQUE_TYPE(spine_path_constraint_position_timeline) + +SPINE_C_EXPORT spine_path_constraint_position_timeline spine_path_constraint_position_timeline_create(spine_size_t frameCount, spine_size_t bezierCount, int32_t constraintIndex); +SPINE_C_EXPORT void spine_path_constraint_position_timeline_dispose(spine_path_constraint_position_timeline obj); +SPINE_C_EXPORT spine_rtti spine_path_constraint_position_timeline_get_rtti(spine_path_constraint_position_timeline obj); +SPINE_C_EXPORT void spine_path_constraint_position_timeline_apply(spine_path_constraint_position_timeline obj, spine_skeleton skeleton, float lastTime, float time, void * pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction, spine_bool appliedPose); +SPINE_C_EXPORT void spine_path_constraint_position_timeline_set_frame(spine_path_constraint_position_timeline obj, spine_size_t frame, float time, float value); +SPINE_C_EXPORT float spine_path_constraint_position_timeline_get_curve_value(spine_path_constraint_position_timeline obj, float time); +SPINE_C_EXPORT float spine_path_constraint_position_timeline_get_relative_value(spine_path_constraint_position_timeline obj, float time, float alpha, spine_mix_blend blend, float current, float setup); +SPINE_C_EXPORT float spine_path_constraint_position_timeline_get_absolute_value(spine_path_constraint_position_timeline obj, float time, float alpha, spine_mix_blend blend, float current, float setup); +SPINE_C_EXPORT float spine_path_constraint_position_timeline_get_absolute_value(spine_path_constraint_position_timeline obj, float time, float alpha, spine_mix_blend blend, float current, float setup, float value); +SPINE_C_EXPORT float spine_path_constraint_position_timeline_get_scale_value(spine_path_constraint_position_timeline obj, float time, float alpha, spine_mix_blend blend, spine_mix_direction direction, float current, float setup); +SPINE_C_EXPORT int32_t spine_path_constraint_position_timeline_get_constraint_index(spine_path_constraint_position_timeline obj); +SPINE_C_EXPORT void spine_path_constraint_position_timeline_set_constraint_index(spine_path_constraint_position_timeline obj, int32_t value); + +#ifdef __cplusplus +} +#endif + +#endif // SPINE_C_PATHCONSTRAINTPOSITIONTIMELINE_H \ No newline at end of file diff --git a/spine-c-new/src/generated/path_constraint_spacing_timeline.cpp b/spine-c-new/src/generated/path_constraint_spacing_timeline.cpp new file mode 100644 index 000000000..f8a4f8339 --- /dev/null +++ b/spine-c-new/src/generated/path_constraint_spacing_timeline.cpp @@ -0,0 +1,103 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#include "path_constraint_spacing_timeline.h" +#include + +using namespace spine; + +spine_path_constraint_spacing_timeline spine_path_constraint_spacing_timeline_create(spine_size_t frameCount, spine_size_t bezierCount, int32_t constraintIndex) { + PathConstraintSpacingTimeline *obj = new (__FILE__, __LINE__) PathConstraintSpacingTimeline(frameCount, bezierCount, constraintIndex); + return (spine_path_constraint_spacing_timeline) obj; +} + +void spine_path_constraint_spacing_timeline_dispose(spine_path_constraint_spacing_timeline obj) { + if (!obj) return; + delete (PathConstraintSpacingTimeline *) obj; +} + +spine_rtti spine_path_constraint_spacing_timeline_get_rtti(spine_path_constraint_spacing_timeline obj) { + if (!obj) return nullptr; + PathConstraintSpacingTimeline *_obj = (PathConstraintSpacingTimeline *) obj; + return (spine_rtti) &_obj->getRTTI(); +} + +void spine_path_constraint_spacing_timeline_apply(spine_path_constraint_spacing_timeline obj, spine_skeleton skeleton, float lastTime, float time, void * pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction, spine_bool appliedPose) { + if (!obj) return ; + PathConstraintSpacingTimeline *_obj = (PathConstraintSpacingTimeline *) obj; + _obj->apply(skeleton, lastTime, time, (Vector *) pEvents, alpha, blend, direction, appliedPose); +} + +void spine_path_constraint_spacing_timeline_set_frame(spine_path_constraint_spacing_timeline obj, spine_size_t frame, float time, float value) { + if (!obj) return ; + PathConstraintSpacingTimeline *_obj = (PathConstraintSpacingTimeline *) obj; + _obj->setFrame(frame, time, value); +} + +float spine_path_constraint_spacing_timeline_get_curve_value(spine_path_constraint_spacing_timeline obj, float time) { + if (!obj) return 0; + PathConstraintSpacingTimeline *_obj = (PathConstraintSpacingTimeline *) obj; + return _obj->getCurveValue(time); +} + +float spine_path_constraint_spacing_timeline_get_relative_value(spine_path_constraint_spacing_timeline obj, float time, float alpha, spine_mix_blend blend, float current, float setup) { + if (!obj) return 0; + PathConstraintSpacingTimeline *_obj = (PathConstraintSpacingTimeline *) obj; + return _obj->getRelativeValue(time, alpha, blend, current, setup); +} + +float spine_path_constraint_spacing_timeline_get_absolute_value(spine_path_constraint_spacing_timeline obj, float time, float alpha, spine_mix_blend blend, float current, float setup) { + if (!obj) return 0; + PathConstraintSpacingTimeline *_obj = (PathConstraintSpacingTimeline *) obj; + return _obj->getAbsoluteValue(time, alpha, blend, current, setup); +} + +float spine_path_constraint_spacing_timeline_get_absolute_value(spine_path_constraint_spacing_timeline obj, float time, float alpha, spine_mix_blend blend, float current, float setup, float value) { + if (!obj) return 0; + PathConstraintSpacingTimeline *_obj = (PathConstraintSpacingTimeline *) obj; + return _obj->getAbsoluteValue(time, alpha, blend, current, setup, value); +} + +float spine_path_constraint_spacing_timeline_get_scale_value(spine_path_constraint_spacing_timeline obj, float time, float alpha, spine_mix_blend blend, spine_mix_direction direction, float current, float setup) { + if (!obj) return 0; + PathConstraintSpacingTimeline *_obj = (PathConstraintSpacingTimeline *) obj; + return _obj->getScaleValue(time, alpha, blend, direction, current, setup); +} + +int32_t spine_path_constraint_spacing_timeline_get_constraint_index(spine_path_constraint_spacing_timeline obj) { + if (!obj) return 0; + PathConstraintSpacingTimeline *_obj = (PathConstraintSpacingTimeline *) obj; + return _obj->getConstraintIndex(); +} + +void spine_path_constraint_spacing_timeline_set_constraint_index(spine_path_constraint_spacing_timeline obj, int32_t value) { + if (!obj) return; + PathConstraintSpacingTimeline *_obj = (PathConstraintSpacingTimeline *) obj; + _obj->setConstraintIndex(value); +} diff --git a/spine-c-new/src/generated/path_constraint_spacing_timeline.h b/spine-c-new/src/generated/path_constraint_spacing_timeline.h new file mode 100644 index 000000000..3b2302948 --- /dev/null +++ b/spine-c-new/src/generated/path_constraint_spacing_timeline.h @@ -0,0 +1,58 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#ifndef SPINE_C_PATHCONSTRAINTSPACINGTIMELINE_H +#define SPINE_C_PATHCONSTRAINTSPACINGTIMELINE_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include "../custom.h" + +SPINE_OPAQUE_TYPE(spine_path_constraint_spacing_timeline) + +SPINE_C_EXPORT spine_path_constraint_spacing_timeline spine_path_constraint_spacing_timeline_create(spine_size_t frameCount, spine_size_t bezierCount, int32_t constraintIndex); +SPINE_C_EXPORT void spine_path_constraint_spacing_timeline_dispose(spine_path_constraint_spacing_timeline obj); +SPINE_C_EXPORT spine_rtti spine_path_constraint_spacing_timeline_get_rtti(spine_path_constraint_spacing_timeline obj); +SPINE_C_EXPORT void spine_path_constraint_spacing_timeline_apply(spine_path_constraint_spacing_timeline obj, spine_skeleton skeleton, float lastTime, float time, void * pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction, spine_bool appliedPose); +SPINE_C_EXPORT void spine_path_constraint_spacing_timeline_set_frame(spine_path_constraint_spacing_timeline obj, spine_size_t frame, float time, float value); +SPINE_C_EXPORT float spine_path_constraint_spacing_timeline_get_curve_value(spine_path_constraint_spacing_timeline obj, float time); +SPINE_C_EXPORT float spine_path_constraint_spacing_timeline_get_relative_value(spine_path_constraint_spacing_timeline obj, float time, float alpha, spine_mix_blend blend, float current, float setup); +SPINE_C_EXPORT float spine_path_constraint_spacing_timeline_get_absolute_value(spine_path_constraint_spacing_timeline obj, float time, float alpha, spine_mix_blend blend, float current, float setup); +SPINE_C_EXPORT float spine_path_constraint_spacing_timeline_get_absolute_value(spine_path_constraint_spacing_timeline obj, float time, float alpha, spine_mix_blend blend, float current, float setup, float value); +SPINE_C_EXPORT float spine_path_constraint_spacing_timeline_get_scale_value(spine_path_constraint_spacing_timeline obj, float time, float alpha, spine_mix_blend blend, spine_mix_direction direction, float current, float setup); +SPINE_C_EXPORT int32_t spine_path_constraint_spacing_timeline_get_constraint_index(spine_path_constraint_spacing_timeline obj); +SPINE_C_EXPORT void spine_path_constraint_spacing_timeline_set_constraint_index(spine_path_constraint_spacing_timeline obj, int32_t value); + +#ifdef __cplusplus +} +#endif + +#endif // SPINE_C_PATHCONSTRAINTSPACINGTIMELINE_H \ No newline at end of file diff --git a/spine-c-new/src/generated/physics.h b/spine-c-new/src/generated/physics.h new file mode 100644 index 000000000..d92047be6 --- /dev/null +++ b/spine-c-new/src/generated/physics.h @@ -0,0 +1,50 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#ifndef SPINE_C_PHYSICS_H +#define SPINE_C_PHYSICS_H + +#include "../../custom.h" + +#ifdef __cplusplus +extern "C" { +#endif + +typedef enum spine_physics { + SPINE_PHYSICS_PHYSICS_NONE, + SPINE_PHYSICS_PHYSICS_RESET, + SPINE_PHYSICS_PHYSICS_UPDATE, + SPINE_PHYSICS_PHYSICS_POSE +} spine_physics; + +#ifdef __cplusplus +} +#endif + +#endif // SPINE_C_PHYSICS_H \ No newline at end of file diff --git a/spine-c-new/src/generated/physics_constraint.cpp b/spine-c-new/src/generated/physics_constraint.cpp new file mode 100644 index 000000000..55f66731e --- /dev/null +++ b/spine-c-new/src/generated/physics_constraint.cpp @@ -0,0 +1,163 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#include "physics_constraint.h" +#include + +using namespace spine; + +spine_physics_constraint spine_physics_constraint_create(spine_physics_constraint_data data, spine_skeleton skeleton) { + PhysicsConstraint *obj = new (__FILE__, __LINE__) PhysicsConstraint(data, skeleton); + return (spine_physics_constraint) obj; +} + +void spine_physics_constraint_dispose(spine_physics_constraint obj) { + if (!obj) return; + delete (PhysicsConstraint *) obj; +} + +spine_rtti spine_physics_constraint_get_rtti(spine_physics_constraint obj) { + if (!obj) return nullptr; + PhysicsConstraint *_obj = (PhysicsConstraint *) obj; + return (spine_rtti) &_obj->getRTTI(); +} + +void spine_physics_constraint_update(spine_physics_constraint obj, spine_skeleton skeleton, spine_physics physics) { + if (!obj) return ; + PhysicsConstraint *_obj = (PhysicsConstraint *) obj; + _obj->update(skeleton, physics); +} + +void spine_physics_constraint_sort(spine_physics_constraint obj, spine_skeleton skeleton) { + if (!obj) return ; + PhysicsConstraint *_obj = (PhysicsConstraint *) obj; + _obj->sort(skeleton); +} + +spine_bool spine_physics_constraint_is_source_active(spine_physics_constraint obj) { + if (!obj) return 0; + PhysicsConstraint *_obj = (PhysicsConstraint *) obj; + return _obj->isSourceActive(); +} + +spine_physics_constraint spine_physics_constraint_copy(spine_physics_constraint obj, spine_skeleton skeleton) { + if (!obj) return 0; + PhysicsConstraint *_obj = (PhysicsConstraint *) obj; + return (spine_physics_constraint) _obj->copy(skeleton); +} + +void spine_physics_constraint_reset(spine_physics_constraint obj, spine_skeleton skeleton) { + if (!obj) return ; + PhysicsConstraint *_obj = (PhysicsConstraint *) obj; + _obj->reset(skeleton); +} + +void spine_physics_constraint_translate(spine_physics_constraint obj, float x, float y) { + if (!obj) return ; + PhysicsConstraint *_obj = (PhysicsConstraint *) obj; + _obj->translate(x, y); +} + +void spine_physics_constraint_rotate(spine_physics_constraint obj, float x, float y, float degrees) { + if (!obj) return ; + PhysicsConstraint *_obj = (PhysicsConstraint *) obj; + _obj->rotate(x, y, degrees); +} + +spine_bone_pose spine_physics_constraint_get_bone(spine_physics_constraint obj) { + if (!obj) return nullptr; + PhysicsConstraint *_obj = (PhysicsConstraint *) obj; + return _obj->getBone(); +} + +void spine_physics_constraint_set_bone(spine_physics_constraint obj, spine_bone_pose value) { + if (!obj) return; + PhysicsConstraint *_obj = (PhysicsConstraint *) obj; + _obj->setBone(value); +} + +spine_constraint_data spine_physics_constraint_get_data(spine_physics_constraint obj) { + if (!obj) return 0; + PhysicsConstraint *_obj = (PhysicsConstraint *) obj; + return _obj->getData(); +} + +void spine_physics_constraint_pose(spine_physics_constraint obj) { + if (!obj) return ; + PhysicsConstraint *_obj = (PhysicsConstraint *) obj; + _obj->pose(); +} + +void spine_physics_constraint_setup_pose(spine_physics_constraint obj) { + if (!obj) return ; + PhysicsConstraint *_obj = (PhysicsConstraint *) obj; + _obj->setupPose(); +} + +spine_physics_constraint_pose spine_physics_constraint_get_pose(spine_physics_constraint obj) { + if (!obj) return 0; + PhysicsConstraint *_obj = (PhysicsConstraint *) obj; + return _obj->getPose(); +} + +spine_physics_constraint_pose spine_physics_constraint_get_applied_pose(spine_physics_constraint obj) { + if (!obj) return 0; + PhysicsConstraint *_obj = (PhysicsConstraint *) obj; + return _obj->getAppliedPose(); +} + +void spine_physics_constraint_reset_constrained(spine_physics_constraint obj) { + if (!obj) return ; + PhysicsConstraint *_obj = (PhysicsConstraint *) obj; + _obj->resetConstrained(); +} + +void spine_physics_constraint_constrained(spine_physics_constraint obj) { + if (!obj) return ; + PhysicsConstraint *_obj = (PhysicsConstraint *) obj; + _obj->constrained(); +} + +spine_bool spine_physics_constraint_is_pose_equal_to_applied(spine_physics_constraint obj) { + if (!obj) return 0; + PhysicsConstraint *_obj = (PhysicsConstraint *) obj; + return _obj->isPoseEqualToApplied(); +} + +spine_bool spine_physics_constraint_is_active(spine_physics_constraint obj) { + if (!obj) return 0; + PhysicsConstraint *_obj = (PhysicsConstraint *) obj; + return _obj->isActive(); +} + +void spine_physics_constraint_set_active(spine_physics_constraint obj, spine_bool value) { + if (!obj) return; + PhysicsConstraint *_obj = (PhysicsConstraint *) obj; + _obj->setActive(value); +} diff --git a/spine-c-new/src/generated/physics_constraint.h b/spine-c-new/src/generated/physics_constraint.h new file mode 100644 index 000000000..0ab88da05 --- /dev/null +++ b/spine-c-new/src/generated/physics_constraint.h @@ -0,0 +1,68 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#ifndef SPINE_C_PHYSICSCONSTRAINT_H +#define SPINE_C_PHYSICSCONSTRAINT_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include "../custom.h" + +SPINE_OPAQUE_TYPE(spine_physics_constraint) + +SPINE_C_EXPORT spine_physics_constraint spine_physics_constraint_create(spine_physics_constraint_data data, spine_skeleton skeleton); +SPINE_C_EXPORT void spine_physics_constraint_dispose(spine_physics_constraint obj); +SPINE_C_EXPORT spine_rtti spine_physics_constraint_get_rtti(spine_physics_constraint obj); +SPINE_C_EXPORT void spine_physics_constraint_update(spine_physics_constraint obj, spine_skeleton skeleton, spine_physics physics); +SPINE_C_EXPORT void spine_physics_constraint_sort(spine_physics_constraint obj, spine_skeleton skeleton); +SPINE_C_EXPORT spine_bool spine_physics_constraint_is_source_active(spine_physics_constraint obj); +SPINE_C_EXPORT spine_physics_constraint spine_physics_constraint_copy(spine_physics_constraint obj, spine_skeleton skeleton); +SPINE_C_EXPORT void spine_physics_constraint_reset(spine_physics_constraint obj, spine_skeleton skeleton); +SPINE_C_EXPORT void spine_physics_constraint_translate(spine_physics_constraint obj, float x, float y); +SPINE_C_EXPORT void spine_physics_constraint_rotate(spine_physics_constraint obj, float x, float y, float degrees); +SPINE_C_EXPORT spine_bone_pose spine_physics_constraint_get_bone(spine_physics_constraint obj); +SPINE_C_EXPORT void spine_physics_constraint_set_bone(spine_physics_constraint obj, spine_bone_pose value); +SPINE_C_EXPORT spine_constraint_data spine_physics_constraint_get_data(spine_physics_constraint obj); +SPINE_C_EXPORT void spine_physics_constraint_pose(spine_physics_constraint obj); +SPINE_C_EXPORT void spine_physics_constraint_setup_pose(spine_physics_constraint obj); +SPINE_C_EXPORT spine_physics_constraint_pose spine_physics_constraint_get_pose(spine_physics_constraint obj); +SPINE_C_EXPORT spine_physics_constraint_pose spine_physics_constraint_get_applied_pose(spine_physics_constraint obj); +SPINE_C_EXPORT void spine_physics_constraint_reset_constrained(spine_physics_constraint obj); +SPINE_C_EXPORT void spine_physics_constraint_constrained(spine_physics_constraint obj); +SPINE_C_EXPORT spine_bool spine_physics_constraint_is_pose_equal_to_applied(spine_physics_constraint obj); +SPINE_C_EXPORT spine_bool spine_physics_constraint_is_active(spine_physics_constraint obj); +SPINE_C_EXPORT void spine_physics_constraint_set_active(spine_physics_constraint obj, spine_bool value); + +#ifdef __cplusplus +} +#endif + +#endif // SPINE_C_PHYSICSCONSTRAINT_H \ No newline at end of file diff --git a/spine-c-new/src/generated/physics_constraint_damping_timeline.cpp b/spine-c-new/src/generated/physics_constraint_damping_timeline.cpp new file mode 100644 index 000000000..4bac3df42 --- /dev/null +++ b/spine-c-new/src/generated/physics_constraint_damping_timeline.cpp @@ -0,0 +1,199 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#include "physics_constraint_damping_timeline.h" +#include + +using namespace spine; + +spine_physics_constraint_damping_timeline spine_physics_constraint_damping_timeline_create(spine_size_t frameCount, spine_size_t bezierCount, int32_t physicsConstraintIndex) { + PhysicsConstraintDampingTimeline *obj = new (__FILE__, __LINE__) PhysicsConstraintDampingTimeline(frameCount, bezierCount, physicsConstraintIndex); + return (spine_physics_constraint_damping_timeline) obj; +} + +void spine_physics_constraint_damping_timeline_dispose(spine_physics_constraint_damping_timeline obj) { + if (!obj) return; + delete (PhysicsConstraintDampingTimeline *) obj; +} + +spine_rtti spine_physics_constraint_damping_timeline_get_rtti(spine_physics_constraint_damping_timeline obj) { + if (!obj) return nullptr; + PhysicsConstraintDampingTimeline *_obj = (PhysicsConstraintDampingTimeline *) obj; + return (spine_rtti) &_obj->getRTTI(); +} + +void spine_physics_constraint_damping_timeline_apply(spine_physics_constraint_damping_timeline obj, spine_skeleton skeleton, float lastTime, float time, void * pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction, spine_bool appliedPose) { + if (!obj) return ; + PhysicsConstraintDampingTimeline *_obj = (PhysicsConstraintDampingTimeline *) obj; + _obj->apply(skeleton, lastTime, time, (Vector *) pEvents, alpha, blend, direction, appliedPose); +} + +void spine_physics_constraint_damping_timeline_set_frame(spine_physics_constraint_damping_timeline obj, spine_size_t frame, float time, float value) { + if (!obj) return ; + PhysicsConstraintDampingTimeline *_obj = (PhysicsConstraintDampingTimeline *) obj; + _obj->setFrame(frame, time, value); +} + +float spine_physics_constraint_damping_timeline_get_curve_value(spine_physics_constraint_damping_timeline obj, float time) { + if (!obj) return 0; + PhysicsConstraintDampingTimeline *_obj = (PhysicsConstraintDampingTimeline *) obj; + return _obj->getCurveValue(time); +} + +float spine_physics_constraint_damping_timeline_get_relative_value(spine_physics_constraint_damping_timeline obj, float time, float alpha, spine_mix_blend blend, float current, float setup) { + if (!obj) return 0; + PhysicsConstraintDampingTimeline *_obj = (PhysicsConstraintDampingTimeline *) obj; + return _obj->getRelativeValue(time, alpha, blend, current, setup); +} + +float spine_physics_constraint_damping_timeline_get_absolute_value(spine_physics_constraint_damping_timeline obj, float time, float alpha, spine_mix_blend blend, float current, float setup) { + if (!obj) return 0; + PhysicsConstraintDampingTimeline *_obj = (PhysicsConstraintDampingTimeline *) obj; + return _obj->getAbsoluteValue(time, alpha, blend, current, setup); +} + +float spine_physics_constraint_damping_timeline_get_absolute_value(spine_physics_constraint_damping_timeline obj, float time, float alpha, spine_mix_blend blend, float current, float setup, float value) { + if (!obj) return 0; + PhysicsConstraintDampingTimeline *_obj = (PhysicsConstraintDampingTimeline *) obj; + return _obj->getAbsoluteValue(time, alpha, blend, current, setup, value); +} + +float spine_physics_constraint_damping_timeline_get_scale_value(spine_physics_constraint_damping_timeline obj, float time, float alpha, spine_mix_blend blend, spine_mix_direction direction, float current, float setup) { + if (!obj) return 0; + PhysicsConstraintDampingTimeline *_obj = (PhysicsConstraintDampingTimeline *) obj; + return _obj->getScaleValue(time, alpha, blend, direction, current, setup); +} + +void spine_physics_constraint_damping_timeline_set_linear(spine_physics_constraint_damping_timeline obj, spine_size_t value) { + if (!obj) return; + PhysicsConstraintDampingTimeline *_obj = (PhysicsConstraintDampingTimeline *) obj; + _obj->setLinear(value); +} + +void spine_physics_constraint_damping_timeline_set_stepped(spine_physics_constraint_damping_timeline obj, spine_size_t value) { + if (!obj) return; + PhysicsConstraintDampingTimeline *_obj = (PhysicsConstraintDampingTimeline *) obj; + _obj->setStepped(value); +} + +void spine_physics_constraint_damping_timeline_set_bezier(spine_physics_constraint_damping_timeline obj, spine_size_t bezier, spine_size_t frame, float value, float time1, float value1, float cx1, float cy1, float cx2, float cy2, float time2, float value2) { + if (!obj) return ; + PhysicsConstraintDampingTimeline *_obj = (PhysicsConstraintDampingTimeline *) obj; + _obj->setBezier(bezier, frame, value, time1, value1, cx1, cy1, cx2, cy2, time2, value2); +} + +float spine_physics_constraint_damping_timeline_get_bezier_value(spine_physics_constraint_damping_timeline obj, float time, spine_size_t frame, spine_size_t valueOffset, spine_size_t i) { + if (!obj) return 0; + PhysicsConstraintDampingTimeline *_obj = (PhysicsConstraintDampingTimeline *) obj; + return _obj->getBezierValue(time, frame, valueOffset, i); +} + +void * spine_physics_constraint_damping_timeline_get_curves(spine_physics_constraint_damping_timeline obj) { + if (!obj) return nullptr; + PhysicsConstraintDampingTimeline *_obj = (PhysicsConstraintDampingTimeline *) obj; + return _obj->getCurves(); +} + +int32_t spine_physics_constraint_damping_timeline_get_num_curves(spine_physics_constraint_damping_timeline obj) { + if (!obj) return 0; + PhysicsConstraintDampingTimeline *_obj = (PhysicsConstraintDampingTimeline *) obj; + return (int32_t) _obj->getCurves().size(); +} + +spine_float *spine_physics_constraint_damping_timeline_get_curves(spine_physics_constraint_damping_timeline obj) { + if (!obj) return nullptr; + PhysicsConstraintDampingTimeline *_obj = (PhysicsConstraintDampingTimeline *) obj; + return (spine_float *) _obj->getCurves().buffer(); +} + +spine_size_t spine_physics_constraint_damping_timeline_get_frame_entries(spine_physics_constraint_damping_timeline obj) { + if (!obj) return nullptr; + PhysicsConstraintDampingTimeline *_obj = (PhysicsConstraintDampingTimeline *) obj; + return _obj->getFrameEntries(); +} + +spine_size_t spine_physics_constraint_damping_timeline_get_frame_count(spine_physics_constraint_damping_timeline obj) { + if (!obj) return nullptr; + PhysicsConstraintDampingTimeline *_obj = (PhysicsConstraintDampingTimeline *) obj; + return _obj->getFrameCount(); +} + +void * spine_physics_constraint_damping_timeline_get_frames(spine_physics_constraint_damping_timeline obj) { + if (!obj) return nullptr; + PhysicsConstraintDampingTimeline *_obj = (PhysicsConstraintDampingTimeline *) obj; + return _obj->getFrames(); +} + +int32_t spine_physics_constraint_damping_timeline_get_num_frames(spine_physics_constraint_damping_timeline obj) { + if (!obj) return 0; + PhysicsConstraintDampingTimeline *_obj = (PhysicsConstraintDampingTimeline *) obj; + return (int32_t) _obj->getFrames().size(); +} + +spine_float *spine_physics_constraint_damping_timeline_get_frames(spine_physics_constraint_damping_timeline obj) { + if (!obj) return nullptr; + PhysicsConstraintDampingTimeline *_obj = (PhysicsConstraintDampingTimeline *) obj; + return (spine_float *) _obj->getFrames().buffer(); +} + +float spine_physics_constraint_damping_timeline_get_duration(spine_physics_constraint_damping_timeline obj) { + if (!obj) return 0; + PhysicsConstraintDampingTimeline *_obj = (PhysicsConstraintDampingTimeline *) obj; + return _obj->getDuration(); +} + +void * spine_physics_constraint_damping_timeline_get_property_ids(spine_physics_constraint_damping_timeline obj) { + if (!obj) return nullptr; + PhysicsConstraintDampingTimeline *_obj = (PhysicsConstraintDampingTimeline *) obj; + return _obj->getPropertyIds(); +} + +int32_t spine_physics_constraint_damping_timeline_get_num_property_ids(spine_physics_constraint_damping_timeline obj) { + if (!obj) return 0; + PhysicsConstraintDampingTimeline *_obj = (PhysicsConstraintDampingTimeline *) obj; + return (int32_t) _obj->getPropertyIds().size(); +} + +spine_property_id *spine_physics_constraint_damping_timeline_get_property_ids(spine_physics_constraint_damping_timeline obj) { + if (!obj) return nullptr; + PhysicsConstraintDampingTimeline *_obj = (PhysicsConstraintDampingTimeline *) obj; + return (spine_property_id *) _obj->getPropertyIds().buffer(); +} + +int32_t spine_physics_constraint_damping_timeline_get_constraint_index(spine_physics_constraint_damping_timeline obj) { + if (!obj) return 0; + PhysicsConstraintDampingTimeline *_obj = (PhysicsConstraintDampingTimeline *) obj; + return _obj->getConstraintIndex(); +} + +void spine_physics_constraint_damping_timeline_set_constraint_index(spine_physics_constraint_damping_timeline obj, int32_t value) { + if (!obj) return; + PhysicsConstraintDampingTimeline *_obj = (PhysicsConstraintDampingTimeline *) obj; + _obj->setConstraintIndex(value); +} diff --git a/spine-c-new/src/generated/physics_constraint_damping_timeline.h b/spine-c-new/src/generated/physics_constraint_damping_timeline.h new file mode 100644 index 000000000..c1f9f4840 --- /dev/null +++ b/spine-c-new/src/generated/physics_constraint_damping_timeline.h @@ -0,0 +1,74 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#ifndef SPINE_C_PHYSICSCONSTRAINTDAMPINGTIMELINE_H +#define SPINE_C_PHYSICSCONSTRAINTDAMPINGTIMELINE_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include "../custom.h" + +SPINE_OPAQUE_TYPE(spine_physics_constraint_damping_timeline) + +SPINE_C_EXPORT spine_physics_constraint_damping_timeline spine_physics_constraint_damping_timeline_create(spine_size_t frameCount, spine_size_t bezierCount, int32_t physicsConstraintIndex); +SPINE_C_EXPORT void spine_physics_constraint_damping_timeline_dispose(spine_physics_constraint_damping_timeline obj); +SPINE_C_EXPORT spine_rtti spine_physics_constraint_damping_timeline_get_rtti(spine_physics_constraint_damping_timeline obj); +SPINE_C_EXPORT void spine_physics_constraint_damping_timeline_apply(spine_physics_constraint_damping_timeline obj, spine_skeleton skeleton, float lastTime, float time, void * pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction, spine_bool appliedPose); +SPINE_C_EXPORT void spine_physics_constraint_damping_timeline_set_frame(spine_physics_constraint_damping_timeline obj, spine_size_t frame, float time, float value); +SPINE_C_EXPORT float spine_physics_constraint_damping_timeline_get_curve_value(spine_physics_constraint_damping_timeline obj, float time); +SPINE_C_EXPORT float spine_physics_constraint_damping_timeline_get_relative_value(spine_physics_constraint_damping_timeline obj, float time, float alpha, spine_mix_blend blend, float current, float setup); +SPINE_C_EXPORT float spine_physics_constraint_damping_timeline_get_absolute_value(spine_physics_constraint_damping_timeline obj, float time, float alpha, spine_mix_blend blend, float current, float setup); +SPINE_C_EXPORT float spine_physics_constraint_damping_timeline_get_absolute_value(spine_physics_constraint_damping_timeline obj, float time, float alpha, spine_mix_blend blend, float current, float setup, float value); +SPINE_C_EXPORT float spine_physics_constraint_damping_timeline_get_scale_value(spine_physics_constraint_damping_timeline obj, float time, float alpha, spine_mix_blend blend, spine_mix_direction direction, float current, float setup); +SPINE_C_EXPORT void spine_physics_constraint_damping_timeline_set_linear(spine_physics_constraint_damping_timeline obj, spine_size_t value); +SPINE_C_EXPORT void spine_physics_constraint_damping_timeline_set_stepped(spine_physics_constraint_damping_timeline obj, spine_size_t value); +SPINE_C_EXPORT void spine_physics_constraint_damping_timeline_set_bezier(spine_physics_constraint_damping_timeline obj, spine_size_t bezier, spine_size_t frame, float value, float time1, float value1, float cx1, float cy1, float cx2, float cy2, float time2, float value2); +SPINE_C_EXPORT float spine_physics_constraint_damping_timeline_get_bezier_value(spine_physics_constraint_damping_timeline obj, float time, spine_size_t frame, spine_size_t valueOffset, spine_size_t i); +SPINE_C_EXPORT void * spine_physics_constraint_damping_timeline_get_curves(spine_physics_constraint_damping_timeline obj); +SPINE_C_EXPORT int32_t spine_physics_constraint_damping_timeline_get_num_curves(spine_physics_constraint_damping_timeline obj); +SPINE_C_EXPORT spine_float *spine_physics_constraint_damping_timeline_get_curves(spine_physics_constraint_damping_timeline obj); +SPINE_C_EXPORT spine_size_t spine_physics_constraint_damping_timeline_get_frame_entries(spine_physics_constraint_damping_timeline obj); +SPINE_C_EXPORT spine_size_t spine_physics_constraint_damping_timeline_get_frame_count(spine_physics_constraint_damping_timeline obj); +SPINE_C_EXPORT void * spine_physics_constraint_damping_timeline_get_frames(spine_physics_constraint_damping_timeline obj); +SPINE_C_EXPORT int32_t spine_physics_constraint_damping_timeline_get_num_frames(spine_physics_constraint_damping_timeline obj); +SPINE_C_EXPORT spine_float *spine_physics_constraint_damping_timeline_get_frames(spine_physics_constraint_damping_timeline obj); +SPINE_C_EXPORT float spine_physics_constraint_damping_timeline_get_duration(spine_physics_constraint_damping_timeline obj); +SPINE_C_EXPORT void * spine_physics_constraint_damping_timeline_get_property_ids(spine_physics_constraint_damping_timeline obj); +SPINE_C_EXPORT int32_t spine_physics_constraint_damping_timeline_get_num_property_ids(spine_physics_constraint_damping_timeline obj); +SPINE_C_EXPORT spine_property_id *spine_physics_constraint_damping_timeline_get_property_ids(spine_physics_constraint_damping_timeline obj); +SPINE_C_EXPORT int32_t spine_physics_constraint_damping_timeline_get_constraint_index(spine_physics_constraint_damping_timeline obj); +SPINE_C_EXPORT void spine_physics_constraint_damping_timeline_set_constraint_index(spine_physics_constraint_damping_timeline obj, int32_t value); + +#ifdef __cplusplus +} +#endif + +#endif // SPINE_C_PHYSICSCONSTRAINTDAMPINGTIMELINE_H \ No newline at end of file diff --git a/spine-c-new/src/generated/physics_constraint_data.cpp b/spine-c-new/src/generated/physics_constraint_data.cpp new file mode 100644 index 000000000..27b7052ec --- /dev/null +++ b/spine-c-new/src/generated/physics_constraint_data.cpp @@ -0,0 +1,259 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#include "physics_constraint_data.h" +#include + +using namespace spine; + +spine_physics_constraint_data spine_physics_constraint_data_create(const utf8 * name) { + PhysicsConstraintData *obj = new (__FILE__, __LINE__) PhysicsConstraintData(String(name)); + return (spine_physics_constraint_data) obj; +} + +void spine_physics_constraint_data_dispose(spine_physics_constraint_data obj) { + if (!obj) return; + delete (PhysicsConstraintData *) obj; +} + +spine_rtti spine_physics_constraint_data_get_rtti(spine_physics_constraint_data obj) { + if (!obj) return nullptr; + PhysicsConstraintData *_obj = (PhysicsConstraintData *) obj; + return (spine_rtti) &_obj->getRTTI(); +} + +spine_constraint spine_physics_constraint_data_create(spine_physics_constraint_data obj, spine_skeleton skeleton) { + if (!obj) return 0; + PhysicsConstraintData *_obj = (PhysicsConstraintData *) obj; + return (spine_constraint) _obj->create(skeleton); +} + +spine_bone_data spine_physics_constraint_data_get_bone(spine_physics_constraint_data obj) { + if (!obj) return nullptr; + PhysicsConstraintData *_obj = (PhysicsConstraintData *) obj; + return (spine_bone_data) _obj->getBone(); +} + +void spine_physics_constraint_data_set_bone(spine_physics_constraint_data obj, spine_bone_data value) { + if (!obj) return; + PhysicsConstraintData *_obj = (PhysicsConstraintData *) obj; + _obj->setBone((BoneData *) value); +} + +float spine_physics_constraint_data_get_step(spine_physics_constraint_data obj) { + if (!obj) return 0; + PhysicsConstraintData *_obj = (PhysicsConstraintData *) obj; + return _obj->getStep(); +} + +void spine_physics_constraint_data_set_step(spine_physics_constraint_data obj, float value) { + if (!obj) return; + PhysicsConstraintData *_obj = (PhysicsConstraintData *) obj; + _obj->setStep(value); +} + +float spine_physics_constraint_data_get_x(spine_physics_constraint_data obj) { + if (!obj) return 0; + PhysicsConstraintData *_obj = (PhysicsConstraintData *) obj; + return _obj->getX(); +} + +void spine_physics_constraint_data_set_x(spine_physics_constraint_data obj, float value) { + if (!obj) return; + PhysicsConstraintData *_obj = (PhysicsConstraintData *) obj; + _obj->setX(value); +} + +float spine_physics_constraint_data_get_y(spine_physics_constraint_data obj) { + if (!obj) return 0; + PhysicsConstraintData *_obj = (PhysicsConstraintData *) obj; + return _obj->getY(); +} + +void spine_physics_constraint_data_set_y(spine_physics_constraint_data obj, float value) { + if (!obj) return; + PhysicsConstraintData *_obj = (PhysicsConstraintData *) obj; + _obj->setY(value); +} + +float spine_physics_constraint_data_get_rotate(spine_physics_constraint_data obj) { + if (!obj) return 0; + PhysicsConstraintData *_obj = (PhysicsConstraintData *) obj; + return _obj->getRotate(); +} + +void spine_physics_constraint_data_set_rotate(spine_physics_constraint_data obj, float value) { + if (!obj) return; + PhysicsConstraintData *_obj = (PhysicsConstraintData *) obj; + _obj->setRotate(value); +} + +float spine_physics_constraint_data_get_scale_x(spine_physics_constraint_data obj) { + if (!obj) return 0; + PhysicsConstraintData *_obj = (PhysicsConstraintData *) obj; + return _obj->getScaleX(); +} + +void spine_physics_constraint_data_set_scale_x(spine_physics_constraint_data obj, float value) { + if (!obj) return; + PhysicsConstraintData *_obj = (PhysicsConstraintData *) obj; + _obj->setScaleX(value); +} + +float spine_physics_constraint_data_get_shear_x(spine_physics_constraint_data obj) { + if (!obj) return 0; + PhysicsConstraintData *_obj = (PhysicsConstraintData *) obj; + return _obj->getShearX(); +} + +void spine_physics_constraint_data_set_shear_x(spine_physics_constraint_data obj, float value) { + if (!obj) return; + PhysicsConstraintData *_obj = (PhysicsConstraintData *) obj; + _obj->setShearX(value); +} + +float spine_physics_constraint_data_get_limit(spine_physics_constraint_data obj) { + if (!obj) return 0; + PhysicsConstraintData *_obj = (PhysicsConstraintData *) obj; + return _obj->getLimit(); +} + +void spine_physics_constraint_data_set_limit(spine_physics_constraint_data obj, float value) { + if (!obj) return; + PhysicsConstraintData *_obj = (PhysicsConstraintData *) obj; + _obj->setLimit(value); +} + +spine_bool spine_physics_constraint_data_get_inertia_global(spine_physics_constraint_data obj) { + if (!obj) return 0; + PhysicsConstraintData *_obj = (PhysicsConstraintData *) obj; + return _obj->getInertiaGlobal(); +} + +void spine_physics_constraint_data_set_inertia_global(spine_physics_constraint_data obj, spine_bool value) { + if (!obj) return; + PhysicsConstraintData *_obj = (PhysicsConstraintData *) obj; + _obj->setInertiaGlobal(value); +} + +spine_bool spine_physics_constraint_data_get_strength_global(spine_physics_constraint_data obj) { + if (!obj) return 0; + PhysicsConstraintData *_obj = (PhysicsConstraintData *) obj; + return _obj->getStrengthGlobal(); +} + +void spine_physics_constraint_data_set_strength_global(spine_physics_constraint_data obj, spine_bool value) { + if (!obj) return; + PhysicsConstraintData *_obj = (PhysicsConstraintData *) obj; + _obj->setStrengthGlobal(value); +} + +spine_bool spine_physics_constraint_data_get_damping_global(spine_physics_constraint_data obj) { + if (!obj) return 0; + PhysicsConstraintData *_obj = (PhysicsConstraintData *) obj; + return _obj->getDampingGlobal(); +} + +void spine_physics_constraint_data_set_damping_global(spine_physics_constraint_data obj, spine_bool value) { + if (!obj) return; + PhysicsConstraintData *_obj = (PhysicsConstraintData *) obj; + _obj->setDampingGlobal(value); +} + +spine_bool spine_physics_constraint_data_get_mass_global(spine_physics_constraint_data obj) { + if (!obj) return 0; + PhysicsConstraintData *_obj = (PhysicsConstraintData *) obj; + return _obj->getMassGlobal(); +} + +void spine_physics_constraint_data_set_mass_global(spine_physics_constraint_data obj, spine_bool value) { + if (!obj) return; + PhysicsConstraintData *_obj = (PhysicsConstraintData *) obj; + _obj->setMassGlobal(value); +} + +spine_bool spine_physics_constraint_data_get_wind_global(spine_physics_constraint_data obj) { + if (!obj) return 0; + PhysicsConstraintData *_obj = (PhysicsConstraintData *) obj; + return _obj->getWindGlobal(); +} + +void spine_physics_constraint_data_set_wind_global(spine_physics_constraint_data obj, spine_bool value) { + if (!obj) return; + PhysicsConstraintData *_obj = (PhysicsConstraintData *) obj; + _obj->setWindGlobal(value); +} + +spine_bool spine_physics_constraint_data_get_gravity_global(spine_physics_constraint_data obj) { + if (!obj) return 0; + PhysicsConstraintData *_obj = (PhysicsConstraintData *) obj; + return _obj->getGravityGlobal(); +} + +void spine_physics_constraint_data_set_gravity_global(spine_physics_constraint_data obj, spine_bool value) { + if (!obj) return; + PhysicsConstraintData *_obj = (PhysicsConstraintData *) obj; + _obj->setGravityGlobal(value); +} + +spine_bool spine_physics_constraint_data_get_mix_global(spine_physics_constraint_data obj) { + if (!obj) return 0; + PhysicsConstraintData *_obj = (PhysicsConstraintData *) obj; + return _obj->getMixGlobal(); +} + +void spine_physics_constraint_data_set_mix_global(spine_physics_constraint_data obj, spine_bool value) { + if (!obj) return; + PhysicsConstraintData *_obj = (PhysicsConstraintData *) obj; + _obj->setMixGlobal(value); +} + +const utf8 * spine_physics_constraint_data_get_name(spine_physics_constraint_data obj) { + if (!obj) return nullptr; + PhysicsConstraintData *_obj = (PhysicsConstraintData *) obj; + return (const utf8 *) _obj->getName().buffer(); +} + +spine_bool spine_physics_constraint_data_is_skin_required(spine_physics_constraint_data obj) { + if (!obj) return 0; + PhysicsConstraintData *_obj = (PhysicsConstraintData *) obj; + return _obj->isSkinRequired(); +} + +spine_physics_constraint_pose spine_physics_constraint_data_get_setup_pose(spine_physics_constraint_data obj) { + if (!obj) return 0; + PhysicsConstraintData *_obj = (PhysicsConstraintData *) obj; + return _obj->getSetupPose(); +} + +spine_physics_constraint_pose spine_physics_constraint_data_get_setup_pose(spine_physics_constraint_data obj) { + if (!obj) return 0; + PhysicsConstraintData *_obj = (PhysicsConstraintData *) obj; + return _obj->getSetupPose(); +} diff --git a/spine-c-new/src/generated/physics_constraint_data.h b/spine-c-new/src/generated/physics_constraint_data.h new file mode 100644 index 000000000..5cb852711 --- /dev/null +++ b/spine-c-new/src/generated/physics_constraint_data.h @@ -0,0 +1,84 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#ifndef SPINE_C_PHYSICSCONSTRAINTDATA_H +#define SPINE_C_PHYSICSCONSTRAINTDATA_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include "../custom.h" + +SPINE_OPAQUE_TYPE(spine_physics_constraint_data) + +SPINE_C_EXPORT spine_physics_constraint_data spine_physics_constraint_data_create(const utf8 * name); +SPINE_C_EXPORT void spine_physics_constraint_data_dispose(spine_physics_constraint_data obj); +SPINE_C_EXPORT spine_rtti spine_physics_constraint_data_get_rtti(spine_physics_constraint_data obj); +SPINE_C_EXPORT spine_constraint spine_physics_constraint_data_create(spine_physics_constraint_data obj, spine_skeleton skeleton); +SPINE_C_EXPORT spine_bone_data spine_physics_constraint_data_get_bone(spine_physics_constraint_data obj); +SPINE_C_EXPORT void spine_physics_constraint_data_set_bone(spine_physics_constraint_data obj, spine_bone_data value); +SPINE_C_EXPORT float spine_physics_constraint_data_get_step(spine_physics_constraint_data obj); +SPINE_C_EXPORT void spine_physics_constraint_data_set_step(spine_physics_constraint_data obj, float value); +SPINE_C_EXPORT float spine_physics_constraint_data_get_x(spine_physics_constraint_data obj); +SPINE_C_EXPORT void spine_physics_constraint_data_set_x(spine_physics_constraint_data obj, float value); +SPINE_C_EXPORT float spine_physics_constraint_data_get_y(spine_physics_constraint_data obj); +SPINE_C_EXPORT void spine_physics_constraint_data_set_y(spine_physics_constraint_data obj, float value); +SPINE_C_EXPORT float spine_physics_constraint_data_get_rotate(spine_physics_constraint_data obj); +SPINE_C_EXPORT void spine_physics_constraint_data_set_rotate(spine_physics_constraint_data obj, float value); +SPINE_C_EXPORT float spine_physics_constraint_data_get_scale_x(spine_physics_constraint_data obj); +SPINE_C_EXPORT void spine_physics_constraint_data_set_scale_x(spine_physics_constraint_data obj, float value); +SPINE_C_EXPORT float spine_physics_constraint_data_get_shear_x(spine_physics_constraint_data obj); +SPINE_C_EXPORT void spine_physics_constraint_data_set_shear_x(spine_physics_constraint_data obj, float value); +SPINE_C_EXPORT float spine_physics_constraint_data_get_limit(spine_physics_constraint_data obj); +SPINE_C_EXPORT void spine_physics_constraint_data_set_limit(spine_physics_constraint_data obj, float value); +SPINE_C_EXPORT spine_bool spine_physics_constraint_data_get_inertia_global(spine_physics_constraint_data obj); +SPINE_C_EXPORT void spine_physics_constraint_data_set_inertia_global(spine_physics_constraint_data obj, spine_bool value); +SPINE_C_EXPORT spine_bool spine_physics_constraint_data_get_strength_global(spine_physics_constraint_data obj); +SPINE_C_EXPORT void spine_physics_constraint_data_set_strength_global(spine_physics_constraint_data obj, spine_bool value); +SPINE_C_EXPORT spine_bool spine_physics_constraint_data_get_damping_global(spine_physics_constraint_data obj); +SPINE_C_EXPORT void spine_physics_constraint_data_set_damping_global(spine_physics_constraint_data obj, spine_bool value); +SPINE_C_EXPORT spine_bool spine_physics_constraint_data_get_mass_global(spine_physics_constraint_data obj); +SPINE_C_EXPORT void spine_physics_constraint_data_set_mass_global(spine_physics_constraint_data obj, spine_bool value); +SPINE_C_EXPORT spine_bool spine_physics_constraint_data_get_wind_global(spine_physics_constraint_data obj); +SPINE_C_EXPORT void spine_physics_constraint_data_set_wind_global(spine_physics_constraint_data obj, spine_bool value); +SPINE_C_EXPORT spine_bool spine_physics_constraint_data_get_gravity_global(spine_physics_constraint_data obj); +SPINE_C_EXPORT void spine_physics_constraint_data_set_gravity_global(spine_physics_constraint_data obj, spine_bool value); +SPINE_C_EXPORT spine_bool spine_physics_constraint_data_get_mix_global(spine_physics_constraint_data obj); +SPINE_C_EXPORT void spine_physics_constraint_data_set_mix_global(spine_physics_constraint_data obj, spine_bool value); +SPINE_C_EXPORT const utf8 * spine_physics_constraint_data_get_name(spine_physics_constraint_data obj); +SPINE_C_EXPORT spine_bool spine_physics_constraint_data_is_skin_required(spine_physics_constraint_data obj); +SPINE_C_EXPORT spine_physics_constraint_pose spine_physics_constraint_data_get_setup_pose(spine_physics_constraint_data obj); +SPINE_C_EXPORT spine_physics_constraint_pose spine_physics_constraint_data_get_setup_pose(spine_physics_constraint_data obj); + +#ifdef __cplusplus +} +#endif + +#endif // SPINE_C_PHYSICSCONSTRAINTDATA_H \ No newline at end of file diff --git a/spine-c-new/src/generated/physics_constraint_gravity_timeline.cpp b/spine-c-new/src/generated/physics_constraint_gravity_timeline.cpp new file mode 100644 index 000000000..f138f63af --- /dev/null +++ b/spine-c-new/src/generated/physics_constraint_gravity_timeline.cpp @@ -0,0 +1,199 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#include "physics_constraint_gravity_timeline.h" +#include + +using namespace spine; + +spine_physics_constraint_gravity_timeline spine_physics_constraint_gravity_timeline_create(spine_size_t frameCount, spine_size_t bezierCount, int32_t physicsConstraintIndex) { + PhysicsConstraintGravityTimeline *obj = new (__FILE__, __LINE__) PhysicsConstraintGravityTimeline(frameCount, bezierCount, physicsConstraintIndex); + return (spine_physics_constraint_gravity_timeline) obj; +} + +void spine_physics_constraint_gravity_timeline_dispose(spine_physics_constraint_gravity_timeline obj) { + if (!obj) return; + delete (PhysicsConstraintGravityTimeline *) obj; +} + +spine_rtti spine_physics_constraint_gravity_timeline_get_rtti(spine_physics_constraint_gravity_timeline obj) { + if (!obj) return nullptr; + PhysicsConstraintGravityTimeline *_obj = (PhysicsConstraintGravityTimeline *) obj; + return (spine_rtti) &_obj->getRTTI(); +} + +void spine_physics_constraint_gravity_timeline_apply(spine_physics_constraint_gravity_timeline obj, spine_skeleton skeleton, float lastTime, float time, void * pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction, spine_bool appliedPose) { + if (!obj) return ; + PhysicsConstraintGravityTimeline *_obj = (PhysicsConstraintGravityTimeline *) obj; + _obj->apply(skeleton, lastTime, time, (Vector *) pEvents, alpha, blend, direction, appliedPose); +} + +void spine_physics_constraint_gravity_timeline_set_frame(spine_physics_constraint_gravity_timeline obj, spine_size_t frame, float time, float value) { + if (!obj) return ; + PhysicsConstraintGravityTimeline *_obj = (PhysicsConstraintGravityTimeline *) obj; + _obj->setFrame(frame, time, value); +} + +float spine_physics_constraint_gravity_timeline_get_curve_value(spine_physics_constraint_gravity_timeline obj, float time) { + if (!obj) return 0; + PhysicsConstraintGravityTimeline *_obj = (PhysicsConstraintGravityTimeline *) obj; + return _obj->getCurveValue(time); +} + +float spine_physics_constraint_gravity_timeline_get_relative_value(spine_physics_constraint_gravity_timeline obj, float time, float alpha, spine_mix_blend blend, float current, float setup) { + if (!obj) return 0; + PhysicsConstraintGravityTimeline *_obj = (PhysicsConstraintGravityTimeline *) obj; + return _obj->getRelativeValue(time, alpha, blend, current, setup); +} + +float spine_physics_constraint_gravity_timeline_get_absolute_value(spine_physics_constraint_gravity_timeline obj, float time, float alpha, spine_mix_blend blend, float current, float setup) { + if (!obj) return 0; + PhysicsConstraintGravityTimeline *_obj = (PhysicsConstraintGravityTimeline *) obj; + return _obj->getAbsoluteValue(time, alpha, blend, current, setup); +} + +float spine_physics_constraint_gravity_timeline_get_absolute_value(spine_physics_constraint_gravity_timeline obj, float time, float alpha, spine_mix_blend blend, float current, float setup, float value) { + if (!obj) return 0; + PhysicsConstraintGravityTimeline *_obj = (PhysicsConstraintGravityTimeline *) obj; + return _obj->getAbsoluteValue(time, alpha, blend, current, setup, value); +} + +float spine_physics_constraint_gravity_timeline_get_scale_value(spine_physics_constraint_gravity_timeline obj, float time, float alpha, spine_mix_blend blend, spine_mix_direction direction, float current, float setup) { + if (!obj) return 0; + PhysicsConstraintGravityTimeline *_obj = (PhysicsConstraintGravityTimeline *) obj; + return _obj->getScaleValue(time, alpha, blend, direction, current, setup); +} + +void spine_physics_constraint_gravity_timeline_set_linear(spine_physics_constraint_gravity_timeline obj, spine_size_t value) { + if (!obj) return; + PhysicsConstraintGravityTimeline *_obj = (PhysicsConstraintGravityTimeline *) obj; + _obj->setLinear(value); +} + +void spine_physics_constraint_gravity_timeline_set_stepped(spine_physics_constraint_gravity_timeline obj, spine_size_t value) { + if (!obj) return; + PhysicsConstraintGravityTimeline *_obj = (PhysicsConstraintGravityTimeline *) obj; + _obj->setStepped(value); +} + +void spine_physics_constraint_gravity_timeline_set_bezier(spine_physics_constraint_gravity_timeline obj, spine_size_t bezier, spine_size_t frame, float value, float time1, float value1, float cx1, float cy1, float cx2, float cy2, float time2, float value2) { + if (!obj) return ; + PhysicsConstraintGravityTimeline *_obj = (PhysicsConstraintGravityTimeline *) obj; + _obj->setBezier(bezier, frame, value, time1, value1, cx1, cy1, cx2, cy2, time2, value2); +} + +float spine_physics_constraint_gravity_timeline_get_bezier_value(spine_physics_constraint_gravity_timeline obj, float time, spine_size_t frame, spine_size_t valueOffset, spine_size_t i) { + if (!obj) return 0; + PhysicsConstraintGravityTimeline *_obj = (PhysicsConstraintGravityTimeline *) obj; + return _obj->getBezierValue(time, frame, valueOffset, i); +} + +void * spine_physics_constraint_gravity_timeline_get_curves(spine_physics_constraint_gravity_timeline obj) { + if (!obj) return nullptr; + PhysicsConstraintGravityTimeline *_obj = (PhysicsConstraintGravityTimeline *) obj; + return _obj->getCurves(); +} + +int32_t spine_physics_constraint_gravity_timeline_get_num_curves(spine_physics_constraint_gravity_timeline obj) { + if (!obj) return 0; + PhysicsConstraintGravityTimeline *_obj = (PhysicsConstraintGravityTimeline *) obj; + return (int32_t) _obj->getCurves().size(); +} + +spine_float *spine_physics_constraint_gravity_timeline_get_curves(spine_physics_constraint_gravity_timeline obj) { + if (!obj) return nullptr; + PhysicsConstraintGravityTimeline *_obj = (PhysicsConstraintGravityTimeline *) obj; + return (spine_float *) _obj->getCurves().buffer(); +} + +spine_size_t spine_physics_constraint_gravity_timeline_get_frame_entries(spine_physics_constraint_gravity_timeline obj) { + if (!obj) return nullptr; + PhysicsConstraintGravityTimeline *_obj = (PhysicsConstraintGravityTimeline *) obj; + return _obj->getFrameEntries(); +} + +spine_size_t spine_physics_constraint_gravity_timeline_get_frame_count(spine_physics_constraint_gravity_timeline obj) { + if (!obj) return nullptr; + PhysicsConstraintGravityTimeline *_obj = (PhysicsConstraintGravityTimeline *) obj; + return _obj->getFrameCount(); +} + +void * spine_physics_constraint_gravity_timeline_get_frames(spine_physics_constraint_gravity_timeline obj) { + if (!obj) return nullptr; + PhysicsConstraintGravityTimeline *_obj = (PhysicsConstraintGravityTimeline *) obj; + return _obj->getFrames(); +} + +int32_t spine_physics_constraint_gravity_timeline_get_num_frames(spine_physics_constraint_gravity_timeline obj) { + if (!obj) return 0; + PhysicsConstraintGravityTimeline *_obj = (PhysicsConstraintGravityTimeline *) obj; + return (int32_t) _obj->getFrames().size(); +} + +spine_float *spine_physics_constraint_gravity_timeline_get_frames(spine_physics_constraint_gravity_timeline obj) { + if (!obj) return nullptr; + PhysicsConstraintGravityTimeline *_obj = (PhysicsConstraintGravityTimeline *) obj; + return (spine_float *) _obj->getFrames().buffer(); +} + +float spine_physics_constraint_gravity_timeline_get_duration(spine_physics_constraint_gravity_timeline obj) { + if (!obj) return 0; + PhysicsConstraintGravityTimeline *_obj = (PhysicsConstraintGravityTimeline *) obj; + return _obj->getDuration(); +} + +void * spine_physics_constraint_gravity_timeline_get_property_ids(spine_physics_constraint_gravity_timeline obj) { + if (!obj) return nullptr; + PhysicsConstraintGravityTimeline *_obj = (PhysicsConstraintGravityTimeline *) obj; + return _obj->getPropertyIds(); +} + +int32_t spine_physics_constraint_gravity_timeline_get_num_property_ids(spine_physics_constraint_gravity_timeline obj) { + if (!obj) return 0; + PhysicsConstraintGravityTimeline *_obj = (PhysicsConstraintGravityTimeline *) obj; + return (int32_t) _obj->getPropertyIds().size(); +} + +spine_property_id *spine_physics_constraint_gravity_timeline_get_property_ids(spine_physics_constraint_gravity_timeline obj) { + if (!obj) return nullptr; + PhysicsConstraintGravityTimeline *_obj = (PhysicsConstraintGravityTimeline *) obj; + return (spine_property_id *) _obj->getPropertyIds().buffer(); +} + +int32_t spine_physics_constraint_gravity_timeline_get_constraint_index(spine_physics_constraint_gravity_timeline obj) { + if (!obj) return 0; + PhysicsConstraintGravityTimeline *_obj = (PhysicsConstraintGravityTimeline *) obj; + return _obj->getConstraintIndex(); +} + +void spine_physics_constraint_gravity_timeline_set_constraint_index(spine_physics_constraint_gravity_timeline obj, int32_t value) { + if (!obj) return; + PhysicsConstraintGravityTimeline *_obj = (PhysicsConstraintGravityTimeline *) obj; + _obj->setConstraintIndex(value); +} diff --git a/spine-c-new/src/generated/physics_constraint_gravity_timeline.h b/spine-c-new/src/generated/physics_constraint_gravity_timeline.h new file mode 100644 index 000000000..d3787cbeb --- /dev/null +++ b/spine-c-new/src/generated/physics_constraint_gravity_timeline.h @@ -0,0 +1,74 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#ifndef SPINE_C_PHYSICSCONSTRAINTGRAVITYTIMELINE_H +#define SPINE_C_PHYSICSCONSTRAINTGRAVITYTIMELINE_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include "../custom.h" + +SPINE_OPAQUE_TYPE(spine_physics_constraint_gravity_timeline) + +SPINE_C_EXPORT spine_physics_constraint_gravity_timeline spine_physics_constraint_gravity_timeline_create(spine_size_t frameCount, spine_size_t bezierCount, int32_t physicsConstraintIndex); +SPINE_C_EXPORT void spine_physics_constraint_gravity_timeline_dispose(spine_physics_constraint_gravity_timeline obj); +SPINE_C_EXPORT spine_rtti spine_physics_constraint_gravity_timeline_get_rtti(spine_physics_constraint_gravity_timeline obj); +SPINE_C_EXPORT void spine_physics_constraint_gravity_timeline_apply(spine_physics_constraint_gravity_timeline obj, spine_skeleton skeleton, float lastTime, float time, void * pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction, spine_bool appliedPose); +SPINE_C_EXPORT void spine_physics_constraint_gravity_timeline_set_frame(spine_physics_constraint_gravity_timeline obj, spine_size_t frame, float time, float value); +SPINE_C_EXPORT float spine_physics_constraint_gravity_timeline_get_curve_value(spine_physics_constraint_gravity_timeline obj, float time); +SPINE_C_EXPORT float spine_physics_constraint_gravity_timeline_get_relative_value(spine_physics_constraint_gravity_timeline obj, float time, float alpha, spine_mix_blend blend, float current, float setup); +SPINE_C_EXPORT float spine_physics_constraint_gravity_timeline_get_absolute_value(spine_physics_constraint_gravity_timeline obj, float time, float alpha, spine_mix_blend blend, float current, float setup); +SPINE_C_EXPORT float spine_physics_constraint_gravity_timeline_get_absolute_value(spine_physics_constraint_gravity_timeline obj, float time, float alpha, spine_mix_blend blend, float current, float setup, float value); +SPINE_C_EXPORT float spine_physics_constraint_gravity_timeline_get_scale_value(spine_physics_constraint_gravity_timeline obj, float time, float alpha, spine_mix_blend blend, spine_mix_direction direction, float current, float setup); +SPINE_C_EXPORT void spine_physics_constraint_gravity_timeline_set_linear(spine_physics_constraint_gravity_timeline obj, spine_size_t value); +SPINE_C_EXPORT void spine_physics_constraint_gravity_timeline_set_stepped(spine_physics_constraint_gravity_timeline obj, spine_size_t value); +SPINE_C_EXPORT void spine_physics_constraint_gravity_timeline_set_bezier(spine_physics_constraint_gravity_timeline obj, spine_size_t bezier, spine_size_t frame, float value, float time1, float value1, float cx1, float cy1, float cx2, float cy2, float time2, float value2); +SPINE_C_EXPORT float spine_physics_constraint_gravity_timeline_get_bezier_value(spine_physics_constraint_gravity_timeline obj, float time, spine_size_t frame, spine_size_t valueOffset, spine_size_t i); +SPINE_C_EXPORT void * spine_physics_constraint_gravity_timeline_get_curves(spine_physics_constraint_gravity_timeline obj); +SPINE_C_EXPORT int32_t spine_physics_constraint_gravity_timeline_get_num_curves(spine_physics_constraint_gravity_timeline obj); +SPINE_C_EXPORT spine_float *spine_physics_constraint_gravity_timeline_get_curves(spine_physics_constraint_gravity_timeline obj); +SPINE_C_EXPORT spine_size_t spine_physics_constraint_gravity_timeline_get_frame_entries(spine_physics_constraint_gravity_timeline obj); +SPINE_C_EXPORT spine_size_t spine_physics_constraint_gravity_timeline_get_frame_count(spine_physics_constraint_gravity_timeline obj); +SPINE_C_EXPORT void * spine_physics_constraint_gravity_timeline_get_frames(spine_physics_constraint_gravity_timeline obj); +SPINE_C_EXPORT int32_t spine_physics_constraint_gravity_timeline_get_num_frames(spine_physics_constraint_gravity_timeline obj); +SPINE_C_EXPORT spine_float *spine_physics_constraint_gravity_timeline_get_frames(spine_physics_constraint_gravity_timeline obj); +SPINE_C_EXPORT float spine_physics_constraint_gravity_timeline_get_duration(spine_physics_constraint_gravity_timeline obj); +SPINE_C_EXPORT void * spine_physics_constraint_gravity_timeline_get_property_ids(spine_physics_constraint_gravity_timeline obj); +SPINE_C_EXPORT int32_t spine_physics_constraint_gravity_timeline_get_num_property_ids(spine_physics_constraint_gravity_timeline obj); +SPINE_C_EXPORT spine_property_id *spine_physics_constraint_gravity_timeline_get_property_ids(spine_physics_constraint_gravity_timeline obj); +SPINE_C_EXPORT int32_t spine_physics_constraint_gravity_timeline_get_constraint_index(spine_physics_constraint_gravity_timeline obj); +SPINE_C_EXPORT void spine_physics_constraint_gravity_timeline_set_constraint_index(spine_physics_constraint_gravity_timeline obj, int32_t value); + +#ifdef __cplusplus +} +#endif + +#endif // SPINE_C_PHYSICSCONSTRAINTGRAVITYTIMELINE_H \ No newline at end of file diff --git a/spine-c-new/src/generated/physics_constraint_inertia_timeline.cpp b/spine-c-new/src/generated/physics_constraint_inertia_timeline.cpp new file mode 100644 index 000000000..b4c6208c7 --- /dev/null +++ b/spine-c-new/src/generated/physics_constraint_inertia_timeline.cpp @@ -0,0 +1,199 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#include "physics_constraint_inertia_timeline.h" +#include + +using namespace spine; + +spine_physics_constraint_inertia_timeline spine_physics_constraint_inertia_timeline_create(spine_size_t frameCount, spine_size_t bezierCount, int32_t physicsConstraintIndex) { + PhysicsConstraintInertiaTimeline *obj = new (__FILE__, __LINE__) PhysicsConstraintInertiaTimeline(frameCount, bezierCount, physicsConstraintIndex); + return (spine_physics_constraint_inertia_timeline) obj; +} + +void spine_physics_constraint_inertia_timeline_dispose(spine_physics_constraint_inertia_timeline obj) { + if (!obj) return; + delete (PhysicsConstraintInertiaTimeline *) obj; +} + +spine_rtti spine_physics_constraint_inertia_timeline_get_rtti(spine_physics_constraint_inertia_timeline obj) { + if (!obj) return nullptr; + PhysicsConstraintInertiaTimeline *_obj = (PhysicsConstraintInertiaTimeline *) obj; + return (spine_rtti) &_obj->getRTTI(); +} + +void spine_physics_constraint_inertia_timeline_apply(spine_physics_constraint_inertia_timeline obj, spine_skeleton skeleton, float lastTime, float time, void * pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction, spine_bool appliedPose) { + if (!obj) return ; + PhysicsConstraintInertiaTimeline *_obj = (PhysicsConstraintInertiaTimeline *) obj; + _obj->apply(skeleton, lastTime, time, (Vector *) pEvents, alpha, blend, direction, appliedPose); +} + +void spine_physics_constraint_inertia_timeline_set_frame(spine_physics_constraint_inertia_timeline obj, spine_size_t frame, float time, float value) { + if (!obj) return ; + PhysicsConstraintInertiaTimeline *_obj = (PhysicsConstraintInertiaTimeline *) obj; + _obj->setFrame(frame, time, value); +} + +float spine_physics_constraint_inertia_timeline_get_curve_value(spine_physics_constraint_inertia_timeline obj, float time) { + if (!obj) return 0; + PhysicsConstraintInertiaTimeline *_obj = (PhysicsConstraintInertiaTimeline *) obj; + return _obj->getCurveValue(time); +} + +float spine_physics_constraint_inertia_timeline_get_relative_value(spine_physics_constraint_inertia_timeline obj, float time, float alpha, spine_mix_blend blend, float current, float setup) { + if (!obj) return 0; + PhysicsConstraintInertiaTimeline *_obj = (PhysicsConstraintInertiaTimeline *) obj; + return _obj->getRelativeValue(time, alpha, blend, current, setup); +} + +float spine_physics_constraint_inertia_timeline_get_absolute_value(spine_physics_constraint_inertia_timeline obj, float time, float alpha, spine_mix_blend blend, float current, float setup) { + if (!obj) return 0; + PhysicsConstraintInertiaTimeline *_obj = (PhysicsConstraintInertiaTimeline *) obj; + return _obj->getAbsoluteValue(time, alpha, blend, current, setup); +} + +float spine_physics_constraint_inertia_timeline_get_absolute_value(spine_physics_constraint_inertia_timeline obj, float time, float alpha, spine_mix_blend blend, float current, float setup, float value) { + if (!obj) return 0; + PhysicsConstraintInertiaTimeline *_obj = (PhysicsConstraintInertiaTimeline *) obj; + return _obj->getAbsoluteValue(time, alpha, blend, current, setup, value); +} + +float spine_physics_constraint_inertia_timeline_get_scale_value(spine_physics_constraint_inertia_timeline obj, float time, float alpha, spine_mix_blend blend, spine_mix_direction direction, float current, float setup) { + if (!obj) return 0; + PhysicsConstraintInertiaTimeline *_obj = (PhysicsConstraintInertiaTimeline *) obj; + return _obj->getScaleValue(time, alpha, blend, direction, current, setup); +} + +void spine_physics_constraint_inertia_timeline_set_linear(spine_physics_constraint_inertia_timeline obj, spine_size_t value) { + if (!obj) return; + PhysicsConstraintInertiaTimeline *_obj = (PhysicsConstraintInertiaTimeline *) obj; + _obj->setLinear(value); +} + +void spine_physics_constraint_inertia_timeline_set_stepped(spine_physics_constraint_inertia_timeline obj, spine_size_t value) { + if (!obj) return; + PhysicsConstraintInertiaTimeline *_obj = (PhysicsConstraintInertiaTimeline *) obj; + _obj->setStepped(value); +} + +void spine_physics_constraint_inertia_timeline_set_bezier(spine_physics_constraint_inertia_timeline obj, spine_size_t bezier, spine_size_t frame, float value, float time1, float value1, float cx1, float cy1, float cx2, float cy2, float time2, float value2) { + if (!obj) return ; + PhysicsConstraintInertiaTimeline *_obj = (PhysicsConstraintInertiaTimeline *) obj; + _obj->setBezier(bezier, frame, value, time1, value1, cx1, cy1, cx2, cy2, time2, value2); +} + +float spine_physics_constraint_inertia_timeline_get_bezier_value(spine_physics_constraint_inertia_timeline obj, float time, spine_size_t frame, spine_size_t valueOffset, spine_size_t i) { + if (!obj) return 0; + PhysicsConstraintInertiaTimeline *_obj = (PhysicsConstraintInertiaTimeline *) obj; + return _obj->getBezierValue(time, frame, valueOffset, i); +} + +void * spine_physics_constraint_inertia_timeline_get_curves(spine_physics_constraint_inertia_timeline obj) { + if (!obj) return nullptr; + PhysicsConstraintInertiaTimeline *_obj = (PhysicsConstraintInertiaTimeline *) obj; + return _obj->getCurves(); +} + +int32_t spine_physics_constraint_inertia_timeline_get_num_curves(spine_physics_constraint_inertia_timeline obj) { + if (!obj) return 0; + PhysicsConstraintInertiaTimeline *_obj = (PhysicsConstraintInertiaTimeline *) obj; + return (int32_t) _obj->getCurves().size(); +} + +spine_float *spine_physics_constraint_inertia_timeline_get_curves(spine_physics_constraint_inertia_timeline obj) { + if (!obj) return nullptr; + PhysicsConstraintInertiaTimeline *_obj = (PhysicsConstraintInertiaTimeline *) obj; + return (spine_float *) _obj->getCurves().buffer(); +} + +spine_size_t spine_physics_constraint_inertia_timeline_get_frame_entries(spine_physics_constraint_inertia_timeline obj) { + if (!obj) return nullptr; + PhysicsConstraintInertiaTimeline *_obj = (PhysicsConstraintInertiaTimeline *) obj; + return _obj->getFrameEntries(); +} + +spine_size_t spine_physics_constraint_inertia_timeline_get_frame_count(spine_physics_constraint_inertia_timeline obj) { + if (!obj) return nullptr; + PhysicsConstraintInertiaTimeline *_obj = (PhysicsConstraintInertiaTimeline *) obj; + return _obj->getFrameCount(); +} + +void * spine_physics_constraint_inertia_timeline_get_frames(spine_physics_constraint_inertia_timeline obj) { + if (!obj) return nullptr; + PhysicsConstraintInertiaTimeline *_obj = (PhysicsConstraintInertiaTimeline *) obj; + return _obj->getFrames(); +} + +int32_t spine_physics_constraint_inertia_timeline_get_num_frames(spine_physics_constraint_inertia_timeline obj) { + if (!obj) return 0; + PhysicsConstraintInertiaTimeline *_obj = (PhysicsConstraintInertiaTimeline *) obj; + return (int32_t) _obj->getFrames().size(); +} + +spine_float *spine_physics_constraint_inertia_timeline_get_frames(spine_physics_constraint_inertia_timeline obj) { + if (!obj) return nullptr; + PhysicsConstraintInertiaTimeline *_obj = (PhysicsConstraintInertiaTimeline *) obj; + return (spine_float *) _obj->getFrames().buffer(); +} + +float spine_physics_constraint_inertia_timeline_get_duration(spine_physics_constraint_inertia_timeline obj) { + if (!obj) return 0; + PhysicsConstraintInertiaTimeline *_obj = (PhysicsConstraintInertiaTimeline *) obj; + return _obj->getDuration(); +} + +void * spine_physics_constraint_inertia_timeline_get_property_ids(spine_physics_constraint_inertia_timeline obj) { + if (!obj) return nullptr; + PhysicsConstraintInertiaTimeline *_obj = (PhysicsConstraintInertiaTimeline *) obj; + return _obj->getPropertyIds(); +} + +int32_t spine_physics_constraint_inertia_timeline_get_num_property_ids(spine_physics_constraint_inertia_timeline obj) { + if (!obj) return 0; + PhysicsConstraintInertiaTimeline *_obj = (PhysicsConstraintInertiaTimeline *) obj; + return (int32_t) _obj->getPropertyIds().size(); +} + +spine_property_id *spine_physics_constraint_inertia_timeline_get_property_ids(spine_physics_constraint_inertia_timeline obj) { + if (!obj) return nullptr; + PhysicsConstraintInertiaTimeline *_obj = (PhysicsConstraintInertiaTimeline *) obj; + return (spine_property_id *) _obj->getPropertyIds().buffer(); +} + +int32_t spine_physics_constraint_inertia_timeline_get_constraint_index(spine_physics_constraint_inertia_timeline obj) { + if (!obj) return 0; + PhysicsConstraintInertiaTimeline *_obj = (PhysicsConstraintInertiaTimeline *) obj; + return _obj->getConstraintIndex(); +} + +void spine_physics_constraint_inertia_timeline_set_constraint_index(spine_physics_constraint_inertia_timeline obj, int32_t value) { + if (!obj) return; + PhysicsConstraintInertiaTimeline *_obj = (PhysicsConstraintInertiaTimeline *) obj; + _obj->setConstraintIndex(value); +} diff --git a/spine-c-new/src/generated/physics_constraint_inertia_timeline.h b/spine-c-new/src/generated/physics_constraint_inertia_timeline.h new file mode 100644 index 000000000..9284a1dcf --- /dev/null +++ b/spine-c-new/src/generated/physics_constraint_inertia_timeline.h @@ -0,0 +1,74 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#ifndef SPINE_C_PHYSICSCONSTRAINTINERTIATIMELINE_H +#define SPINE_C_PHYSICSCONSTRAINTINERTIATIMELINE_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include "../custom.h" + +SPINE_OPAQUE_TYPE(spine_physics_constraint_inertia_timeline) + +SPINE_C_EXPORT spine_physics_constraint_inertia_timeline spine_physics_constraint_inertia_timeline_create(spine_size_t frameCount, spine_size_t bezierCount, int32_t physicsConstraintIndex); +SPINE_C_EXPORT void spine_physics_constraint_inertia_timeline_dispose(spine_physics_constraint_inertia_timeline obj); +SPINE_C_EXPORT spine_rtti spine_physics_constraint_inertia_timeline_get_rtti(spine_physics_constraint_inertia_timeline obj); +SPINE_C_EXPORT void spine_physics_constraint_inertia_timeline_apply(spine_physics_constraint_inertia_timeline obj, spine_skeleton skeleton, float lastTime, float time, void * pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction, spine_bool appliedPose); +SPINE_C_EXPORT void spine_physics_constraint_inertia_timeline_set_frame(spine_physics_constraint_inertia_timeline obj, spine_size_t frame, float time, float value); +SPINE_C_EXPORT float spine_physics_constraint_inertia_timeline_get_curve_value(spine_physics_constraint_inertia_timeline obj, float time); +SPINE_C_EXPORT float spine_physics_constraint_inertia_timeline_get_relative_value(spine_physics_constraint_inertia_timeline obj, float time, float alpha, spine_mix_blend blend, float current, float setup); +SPINE_C_EXPORT float spine_physics_constraint_inertia_timeline_get_absolute_value(spine_physics_constraint_inertia_timeline obj, float time, float alpha, spine_mix_blend blend, float current, float setup); +SPINE_C_EXPORT float spine_physics_constraint_inertia_timeline_get_absolute_value(spine_physics_constraint_inertia_timeline obj, float time, float alpha, spine_mix_blend blend, float current, float setup, float value); +SPINE_C_EXPORT float spine_physics_constraint_inertia_timeline_get_scale_value(spine_physics_constraint_inertia_timeline obj, float time, float alpha, spine_mix_blend blend, spine_mix_direction direction, float current, float setup); +SPINE_C_EXPORT void spine_physics_constraint_inertia_timeline_set_linear(spine_physics_constraint_inertia_timeline obj, spine_size_t value); +SPINE_C_EXPORT void spine_physics_constraint_inertia_timeline_set_stepped(spine_physics_constraint_inertia_timeline obj, spine_size_t value); +SPINE_C_EXPORT void spine_physics_constraint_inertia_timeline_set_bezier(spine_physics_constraint_inertia_timeline obj, spine_size_t bezier, spine_size_t frame, float value, float time1, float value1, float cx1, float cy1, float cx2, float cy2, float time2, float value2); +SPINE_C_EXPORT float spine_physics_constraint_inertia_timeline_get_bezier_value(spine_physics_constraint_inertia_timeline obj, float time, spine_size_t frame, spine_size_t valueOffset, spine_size_t i); +SPINE_C_EXPORT void * spine_physics_constraint_inertia_timeline_get_curves(spine_physics_constraint_inertia_timeline obj); +SPINE_C_EXPORT int32_t spine_physics_constraint_inertia_timeline_get_num_curves(spine_physics_constraint_inertia_timeline obj); +SPINE_C_EXPORT spine_float *spine_physics_constraint_inertia_timeline_get_curves(spine_physics_constraint_inertia_timeline obj); +SPINE_C_EXPORT spine_size_t spine_physics_constraint_inertia_timeline_get_frame_entries(spine_physics_constraint_inertia_timeline obj); +SPINE_C_EXPORT spine_size_t spine_physics_constraint_inertia_timeline_get_frame_count(spine_physics_constraint_inertia_timeline obj); +SPINE_C_EXPORT void * spine_physics_constraint_inertia_timeline_get_frames(spine_physics_constraint_inertia_timeline obj); +SPINE_C_EXPORT int32_t spine_physics_constraint_inertia_timeline_get_num_frames(spine_physics_constraint_inertia_timeline obj); +SPINE_C_EXPORT spine_float *spine_physics_constraint_inertia_timeline_get_frames(spine_physics_constraint_inertia_timeline obj); +SPINE_C_EXPORT float spine_physics_constraint_inertia_timeline_get_duration(spine_physics_constraint_inertia_timeline obj); +SPINE_C_EXPORT void * spine_physics_constraint_inertia_timeline_get_property_ids(spine_physics_constraint_inertia_timeline obj); +SPINE_C_EXPORT int32_t spine_physics_constraint_inertia_timeline_get_num_property_ids(spine_physics_constraint_inertia_timeline obj); +SPINE_C_EXPORT spine_property_id *spine_physics_constraint_inertia_timeline_get_property_ids(spine_physics_constraint_inertia_timeline obj); +SPINE_C_EXPORT int32_t spine_physics_constraint_inertia_timeline_get_constraint_index(spine_physics_constraint_inertia_timeline obj); +SPINE_C_EXPORT void spine_physics_constraint_inertia_timeline_set_constraint_index(spine_physics_constraint_inertia_timeline obj, int32_t value); + +#ifdef __cplusplus +} +#endif + +#endif // SPINE_C_PHYSICSCONSTRAINTINERTIATIMELINE_H \ No newline at end of file diff --git a/spine-c-new/src/generated/physics_constraint_mass_timeline.cpp b/spine-c-new/src/generated/physics_constraint_mass_timeline.cpp new file mode 100644 index 000000000..7fd32c0cb --- /dev/null +++ b/spine-c-new/src/generated/physics_constraint_mass_timeline.cpp @@ -0,0 +1,199 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#include "physics_constraint_mass_timeline.h" +#include + +using namespace spine; + +spine_physics_constraint_mass_timeline spine_physics_constraint_mass_timeline_create(spine_size_t frameCount, spine_size_t bezierCount, int32_t physicsConstraintIndex) { + PhysicsConstraintMassTimeline *obj = new (__FILE__, __LINE__) PhysicsConstraintMassTimeline(frameCount, bezierCount, physicsConstraintIndex); + return (spine_physics_constraint_mass_timeline) obj; +} + +void spine_physics_constraint_mass_timeline_dispose(spine_physics_constraint_mass_timeline obj) { + if (!obj) return; + delete (PhysicsConstraintMassTimeline *) obj; +} + +spine_rtti spine_physics_constraint_mass_timeline_get_rtti(spine_physics_constraint_mass_timeline obj) { + if (!obj) return nullptr; + PhysicsConstraintMassTimeline *_obj = (PhysicsConstraintMassTimeline *) obj; + return (spine_rtti) &_obj->getRTTI(); +} + +void spine_physics_constraint_mass_timeline_apply(spine_physics_constraint_mass_timeline obj, spine_skeleton skeleton, float lastTime, float time, void * pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction, spine_bool appliedPose) { + if (!obj) return ; + PhysicsConstraintMassTimeline *_obj = (PhysicsConstraintMassTimeline *) obj; + _obj->apply(skeleton, lastTime, time, (Vector *) pEvents, alpha, blend, direction, appliedPose); +} + +void spine_physics_constraint_mass_timeline_set_frame(spine_physics_constraint_mass_timeline obj, spine_size_t frame, float time, float value) { + if (!obj) return ; + PhysicsConstraintMassTimeline *_obj = (PhysicsConstraintMassTimeline *) obj; + _obj->setFrame(frame, time, value); +} + +float spine_physics_constraint_mass_timeline_get_curve_value(spine_physics_constraint_mass_timeline obj, float time) { + if (!obj) return 0; + PhysicsConstraintMassTimeline *_obj = (PhysicsConstraintMassTimeline *) obj; + return _obj->getCurveValue(time); +} + +float spine_physics_constraint_mass_timeline_get_relative_value(spine_physics_constraint_mass_timeline obj, float time, float alpha, spine_mix_blend blend, float current, float setup) { + if (!obj) return 0; + PhysicsConstraintMassTimeline *_obj = (PhysicsConstraintMassTimeline *) obj; + return _obj->getRelativeValue(time, alpha, blend, current, setup); +} + +float spine_physics_constraint_mass_timeline_get_absolute_value(spine_physics_constraint_mass_timeline obj, float time, float alpha, spine_mix_blend blend, float current, float setup) { + if (!obj) return 0; + PhysicsConstraintMassTimeline *_obj = (PhysicsConstraintMassTimeline *) obj; + return _obj->getAbsoluteValue(time, alpha, blend, current, setup); +} + +float spine_physics_constraint_mass_timeline_get_absolute_value(spine_physics_constraint_mass_timeline obj, float time, float alpha, spine_mix_blend blend, float current, float setup, float value) { + if (!obj) return 0; + PhysicsConstraintMassTimeline *_obj = (PhysicsConstraintMassTimeline *) obj; + return _obj->getAbsoluteValue(time, alpha, blend, current, setup, value); +} + +float spine_physics_constraint_mass_timeline_get_scale_value(spine_physics_constraint_mass_timeline obj, float time, float alpha, spine_mix_blend blend, spine_mix_direction direction, float current, float setup) { + if (!obj) return 0; + PhysicsConstraintMassTimeline *_obj = (PhysicsConstraintMassTimeline *) obj; + return _obj->getScaleValue(time, alpha, blend, direction, current, setup); +} + +void spine_physics_constraint_mass_timeline_set_linear(spine_physics_constraint_mass_timeline obj, spine_size_t value) { + if (!obj) return; + PhysicsConstraintMassTimeline *_obj = (PhysicsConstraintMassTimeline *) obj; + _obj->setLinear(value); +} + +void spine_physics_constraint_mass_timeline_set_stepped(spine_physics_constraint_mass_timeline obj, spine_size_t value) { + if (!obj) return; + PhysicsConstraintMassTimeline *_obj = (PhysicsConstraintMassTimeline *) obj; + _obj->setStepped(value); +} + +void spine_physics_constraint_mass_timeline_set_bezier(spine_physics_constraint_mass_timeline obj, spine_size_t bezier, spine_size_t frame, float value, float time1, float value1, float cx1, float cy1, float cx2, float cy2, float time2, float value2) { + if (!obj) return ; + PhysicsConstraintMassTimeline *_obj = (PhysicsConstraintMassTimeline *) obj; + _obj->setBezier(bezier, frame, value, time1, value1, cx1, cy1, cx2, cy2, time2, value2); +} + +float spine_physics_constraint_mass_timeline_get_bezier_value(spine_physics_constraint_mass_timeline obj, float time, spine_size_t frame, spine_size_t valueOffset, spine_size_t i) { + if (!obj) return 0; + PhysicsConstraintMassTimeline *_obj = (PhysicsConstraintMassTimeline *) obj; + return _obj->getBezierValue(time, frame, valueOffset, i); +} + +void * spine_physics_constraint_mass_timeline_get_curves(spine_physics_constraint_mass_timeline obj) { + if (!obj) return nullptr; + PhysicsConstraintMassTimeline *_obj = (PhysicsConstraintMassTimeline *) obj; + return _obj->getCurves(); +} + +int32_t spine_physics_constraint_mass_timeline_get_num_curves(spine_physics_constraint_mass_timeline obj) { + if (!obj) return 0; + PhysicsConstraintMassTimeline *_obj = (PhysicsConstraintMassTimeline *) obj; + return (int32_t) _obj->getCurves().size(); +} + +spine_float *spine_physics_constraint_mass_timeline_get_curves(spine_physics_constraint_mass_timeline obj) { + if (!obj) return nullptr; + PhysicsConstraintMassTimeline *_obj = (PhysicsConstraintMassTimeline *) obj; + return (spine_float *) _obj->getCurves().buffer(); +} + +spine_size_t spine_physics_constraint_mass_timeline_get_frame_entries(spine_physics_constraint_mass_timeline obj) { + if (!obj) return nullptr; + PhysicsConstraintMassTimeline *_obj = (PhysicsConstraintMassTimeline *) obj; + return _obj->getFrameEntries(); +} + +spine_size_t spine_physics_constraint_mass_timeline_get_frame_count(spine_physics_constraint_mass_timeline obj) { + if (!obj) return nullptr; + PhysicsConstraintMassTimeline *_obj = (PhysicsConstraintMassTimeline *) obj; + return _obj->getFrameCount(); +} + +void * spine_physics_constraint_mass_timeline_get_frames(spine_physics_constraint_mass_timeline obj) { + if (!obj) return nullptr; + PhysicsConstraintMassTimeline *_obj = (PhysicsConstraintMassTimeline *) obj; + return _obj->getFrames(); +} + +int32_t spine_physics_constraint_mass_timeline_get_num_frames(spine_physics_constraint_mass_timeline obj) { + if (!obj) return 0; + PhysicsConstraintMassTimeline *_obj = (PhysicsConstraintMassTimeline *) obj; + return (int32_t) _obj->getFrames().size(); +} + +spine_float *spine_physics_constraint_mass_timeline_get_frames(spine_physics_constraint_mass_timeline obj) { + if (!obj) return nullptr; + PhysicsConstraintMassTimeline *_obj = (PhysicsConstraintMassTimeline *) obj; + return (spine_float *) _obj->getFrames().buffer(); +} + +float spine_physics_constraint_mass_timeline_get_duration(spine_physics_constraint_mass_timeline obj) { + if (!obj) return 0; + PhysicsConstraintMassTimeline *_obj = (PhysicsConstraintMassTimeline *) obj; + return _obj->getDuration(); +} + +void * spine_physics_constraint_mass_timeline_get_property_ids(spine_physics_constraint_mass_timeline obj) { + if (!obj) return nullptr; + PhysicsConstraintMassTimeline *_obj = (PhysicsConstraintMassTimeline *) obj; + return _obj->getPropertyIds(); +} + +int32_t spine_physics_constraint_mass_timeline_get_num_property_ids(spine_physics_constraint_mass_timeline obj) { + if (!obj) return 0; + PhysicsConstraintMassTimeline *_obj = (PhysicsConstraintMassTimeline *) obj; + return (int32_t) _obj->getPropertyIds().size(); +} + +spine_property_id *spine_physics_constraint_mass_timeline_get_property_ids(spine_physics_constraint_mass_timeline obj) { + if (!obj) return nullptr; + PhysicsConstraintMassTimeline *_obj = (PhysicsConstraintMassTimeline *) obj; + return (spine_property_id *) _obj->getPropertyIds().buffer(); +} + +int32_t spine_physics_constraint_mass_timeline_get_constraint_index(spine_physics_constraint_mass_timeline obj) { + if (!obj) return 0; + PhysicsConstraintMassTimeline *_obj = (PhysicsConstraintMassTimeline *) obj; + return _obj->getConstraintIndex(); +} + +void spine_physics_constraint_mass_timeline_set_constraint_index(spine_physics_constraint_mass_timeline obj, int32_t value) { + if (!obj) return; + PhysicsConstraintMassTimeline *_obj = (PhysicsConstraintMassTimeline *) obj; + _obj->setConstraintIndex(value); +} diff --git a/spine-c-new/src/generated/physics_constraint_mass_timeline.h b/spine-c-new/src/generated/physics_constraint_mass_timeline.h new file mode 100644 index 000000000..de9321f57 --- /dev/null +++ b/spine-c-new/src/generated/physics_constraint_mass_timeline.h @@ -0,0 +1,74 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#ifndef SPINE_C_PHYSICSCONSTRAINTMASSTIMELINE_H +#define SPINE_C_PHYSICSCONSTRAINTMASSTIMELINE_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include "../custom.h" + +SPINE_OPAQUE_TYPE(spine_physics_constraint_mass_timeline) + +SPINE_C_EXPORT spine_physics_constraint_mass_timeline spine_physics_constraint_mass_timeline_create(spine_size_t frameCount, spine_size_t bezierCount, int32_t physicsConstraintIndex); +SPINE_C_EXPORT void spine_physics_constraint_mass_timeline_dispose(spine_physics_constraint_mass_timeline obj); +SPINE_C_EXPORT spine_rtti spine_physics_constraint_mass_timeline_get_rtti(spine_physics_constraint_mass_timeline obj); +SPINE_C_EXPORT void spine_physics_constraint_mass_timeline_apply(spine_physics_constraint_mass_timeline obj, spine_skeleton skeleton, float lastTime, float time, void * pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction, spine_bool appliedPose); +SPINE_C_EXPORT void spine_physics_constraint_mass_timeline_set_frame(spine_physics_constraint_mass_timeline obj, spine_size_t frame, float time, float value); +SPINE_C_EXPORT float spine_physics_constraint_mass_timeline_get_curve_value(spine_physics_constraint_mass_timeline obj, float time); +SPINE_C_EXPORT float spine_physics_constraint_mass_timeline_get_relative_value(spine_physics_constraint_mass_timeline obj, float time, float alpha, spine_mix_blend blend, float current, float setup); +SPINE_C_EXPORT float spine_physics_constraint_mass_timeline_get_absolute_value(spine_physics_constraint_mass_timeline obj, float time, float alpha, spine_mix_blend blend, float current, float setup); +SPINE_C_EXPORT float spine_physics_constraint_mass_timeline_get_absolute_value(spine_physics_constraint_mass_timeline obj, float time, float alpha, spine_mix_blend blend, float current, float setup, float value); +SPINE_C_EXPORT float spine_physics_constraint_mass_timeline_get_scale_value(spine_physics_constraint_mass_timeline obj, float time, float alpha, spine_mix_blend blend, spine_mix_direction direction, float current, float setup); +SPINE_C_EXPORT void spine_physics_constraint_mass_timeline_set_linear(spine_physics_constraint_mass_timeline obj, spine_size_t value); +SPINE_C_EXPORT void spine_physics_constraint_mass_timeline_set_stepped(spine_physics_constraint_mass_timeline obj, spine_size_t value); +SPINE_C_EXPORT void spine_physics_constraint_mass_timeline_set_bezier(spine_physics_constraint_mass_timeline obj, spine_size_t bezier, spine_size_t frame, float value, float time1, float value1, float cx1, float cy1, float cx2, float cy2, float time2, float value2); +SPINE_C_EXPORT float spine_physics_constraint_mass_timeline_get_bezier_value(spine_physics_constraint_mass_timeline obj, float time, spine_size_t frame, spine_size_t valueOffset, spine_size_t i); +SPINE_C_EXPORT void * spine_physics_constraint_mass_timeline_get_curves(spine_physics_constraint_mass_timeline obj); +SPINE_C_EXPORT int32_t spine_physics_constraint_mass_timeline_get_num_curves(spine_physics_constraint_mass_timeline obj); +SPINE_C_EXPORT spine_float *spine_physics_constraint_mass_timeline_get_curves(spine_physics_constraint_mass_timeline obj); +SPINE_C_EXPORT spine_size_t spine_physics_constraint_mass_timeline_get_frame_entries(spine_physics_constraint_mass_timeline obj); +SPINE_C_EXPORT spine_size_t spine_physics_constraint_mass_timeline_get_frame_count(spine_physics_constraint_mass_timeline obj); +SPINE_C_EXPORT void * spine_physics_constraint_mass_timeline_get_frames(spine_physics_constraint_mass_timeline obj); +SPINE_C_EXPORT int32_t spine_physics_constraint_mass_timeline_get_num_frames(spine_physics_constraint_mass_timeline obj); +SPINE_C_EXPORT spine_float *spine_physics_constraint_mass_timeline_get_frames(spine_physics_constraint_mass_timeline obj); +SPINE_C_EXPORT float spine_physics_constraint_mass_timeline_get_duration(spine_physics_constraint_mass_timeline obj); +SPINE_C_EXPORT void * spine_physics_constraint_mass_timeline_get_property_ids(spine_physics_constraint_mass_timeline obj); +SPINE_C_EXPORT int32_t spine_physics_constraint_mass_timeline_get_num_property_ids(spine_physics_constraint_mass_timeline obj); +SPINE_C_EXPORT spine_property_id *spine_physics_constraint_mass_timeline_get_property_ids(spine_physics_constraint_mass_timeline obj); +SPINE_C_EXPORT int32_t spine_physics_constraint_mass_timeline_get_constraint_index(spine_physics_constraint_mass_timeline obj); +SPINE_C_EXPORT void spine_physics_constraint_mass_timeline_set_constraint_index(spine_physics_constraint_mass_timeline obj, int32_t value); + +#ifdef __cplusplus +} +#endif + +#endif // SPINE_C_PHYSICSCONSTRAINTMASSTIMELINE_H \ No newline at end of file diff --git a/spine-c-new/src/generated/physics_constraint_mix_timeline.cpp b/spine-c-new/src/generated/physics_constraint_mix_timeline.cpp new file mode 100644 index 000000000..a50589dfd --- /dev/null +++ b/spine-c-new/src/generated/physics_constraint_mix_timeline.cpp @@ -0,0 +1,199 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#include "physics_constraint_mix_timeline.h" +#include + +using namespace spine; + +spine_physics_constraint_mix_timeline spine_physics_constraint_mix_timeline_create(spine_size_t frameCount, spine_size_t bezierCount, int32_t physicsConstraintIndex) { + PhysicsConstraintMixTimeline *obj = new (__FILE__, __LINE__) PhysicsConstraintMixTimeline(frameCount, bezierCount, physicsConstraintIndex); + return (spine_physics_constraint_mix_timeline) obj; +} + +void spine_physics_constraint_mix_timeline_dispose(spine_physics_constraint_mix_timeline obj) { + if (!obj) return; + delete (PhysicsConstraintMixTimeline *) obj; +} + +spine_rtti spine_physics_constraint_mix_timeline_get_rtti(spine_physics_constraint_mix_timeline obj) { + if (!obj) return nullptr; + PhysicsConstraintMixTimeline *_obj = (PhysicsConstraintMixTimeline *) obj; + return (spine_rtti) &_obj->getRTTI(); +} + +void spine_physics_constraint_mix_timeline_apply(spine_physics_constraint_mix_timeline obj, spine_skeleton skeleton, float lastTime, float time, void * pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction, spine_bool appliedPose) { + if (!obj) return ; + PhysicsConstraintMixTimeline *_obj = (PhysicsConstraintMixTimeline *) obj; + _obj->apply(skeleton, lastTime, time, (Vector *) pEvents, alpha, blend, direction, appliedPose); +} + +void spine_physics_constraint_mix_timeline_set_frame(spine_physics_constraint_mix_timeline obj, spine_size_t frame, float time, float value) { + if (!obj) return ; + PhysicsConstraintMixTimeline *_obj = (PhysicsConstraintMixTimeline *) obj; + _obj->setFrame(frame, time, value); +} + +float spine_physics_constraint_mix_timeline_get_curve_value(spine_physics_constraint_mix_timeline obj, float time) { + if (!obj) return 0; + PhysicsConstraintMixTimeline *_obj = (PhysicsConstraintMixTimeline *) obj; + return _obj->getCurveValue(time); +} + +float spine_physics_constraint_mix_timeline_get_relative_value(spine_physics_constraint_mix_timeline obj, float time, float alpha, spine_mix_blend blend, float current, float setup) { + if (!obj) return 0; + PhysicsConstraintMixTimeline *_obj = (PhysicsConstraintMixTimeline *) obj; + return _obj->getRelativeValue(time, alpha, blend, current, setup); +} + +float spine_physics_constraint_mix_timeline_get_absolute_value(spine_physics_constraint_mix_timeline obj, float time, float alpha, spine_mix_blend blend, float current, float setup) { + if (!obj) return 0; + PhysicsConstraintMixTimeline *_obj = (PhysicsConstraintMixTimeline *) obj; + return _obj->getAbsoluteValue(time, alpha, blend, current, setup); +} + +float spine_physics_constraint_mix_timeline_get_absolute_value(spine_physics_constraint_mix_timeline obj, float time, float alpha, spine_mix_blend blend, float current, float setup, float value) { + if (!obj) return 0; + PhysicsConstraintMixTimeline *_obj = (PhysicsConstraintMixTimeline *) obj; + return _obj->getAbsoluteValue(time, alpha, blend, current, setup, value); +} + +float spine_physics_constraint_mix_timeline_get_scale_value(spine_physics_constraint_mix_timeline obj, float time, float alpha, spine_mix_blend blend, spine_mix_direction direction, float current, float setup) { + if (!obj) return 0; + PhysicsConstraintMixTimeline *_obj = (PhysicsConstraintMixTimeline *) obj; + return _obj->getScaleValue(time, alpha, blend, direction, current, setup); +} + +void spine_physics_constraint_mix_timeline_set_linear(spine_physics_constraint_mix_timeline obj, spine_size_t value) { + if (!obj) return; + PhysicsConstraintMixTimeline *_obj = (PhysicsConstraintMixTimeline *) obj; + _obj->setLinear(value); +} + +void spine_physics_constraint_mix_timeline_set_stepped(spine_physics_constraint_mix_timeline obj, spine_size_t value) { + if (!obj) return; + PhysicsConstraintMixTimeline *_obj = (PhysicsConstraintMixTimeline *) obj; + _obj->setStepped(value); +} + +void spine_physics_constraint_mix_timeline_set_bezier(spine_physics_constraint_mix_timeline obj, spine_size_t bezier, spine_size_t frame, float value, float time1, float value1, float cx1, float cy1, float cx2, float cy2, float time2, float value2) { + if (!obj) return ; + PhysicsConstraintMixTimeline *_obj = (PhysicsConstraintMixTimeline *) obj; + _obj->setBezier(bezier, frame, value, time1, value1, cx1, cy1, cx2, cy2, time2, value2); +} + +float spine_physics_constraint_mix_timeline_get_bezier_value(spine_physics_constraint_mix_timeline obj, float time, spine_size_t frame, spine_size_t valueOffset, spine_size_t i) { + if (!obj) return 0; + PhysicsConstraintMixTimeline *_obj = (PhysicsConstraintMixTimeline *) obj; + return _obj->getBezierValue(time, frame, valueOffset, i); +} + +void * spine_physics_constraint_mix_timeline_get_curves(spine_physics_constraint_mix_timeline obj) { + if (!obj) return nullptr; + PhysicsConstraintMixTimeline *_obj = (PhysicsConstraintMixTimeline *) obj; + return _obj->getCurves(); +} + +int32_t spine_physics_constraint_mix_timeline_get_num_curves(spine_physics_constraint_mix_timeline obj) { + if (!obj) return 0; + PhysicsConstraintMixTimeline *_obj = (PhysicsConstraintMixTimeline *) obj; + return (int32_t) _obj->getCurves().size(); +} + +spine_float *spine_physics_constraint_mix_timeline_get_curves(spine_physics_constraint_mix_timeline obj) { + if (!obj) return nullptr; + PhysicsConstraintMixTimeline *_obj = (PhysicsConstraintMixTimeline *) obj; + return (spine_float *) _obj->getCurves().buffer(); +} + +spine_size_t spine_physics_constraint_mix_timeline_get_frame_entries(spine_physics_constraint_mix_timeline obj) { + if (!obj) return nullptr; + PhysicsConstraintMixTimeline *_obj = (PhysicsConstraintMixTimeline *) obj; + return _obj->getFrameEntries(); +} + +spine_size_t spine_physics_constraint_mix_timeline_get_frame_count(spine_physics_constraint_mix_timeline obj) { + if (!obj) return nullptr; + PhysicsConstraintMixTimeline *_obj = (PhysicsConstraintMixTimeline *) obj; + return _obj->getFrameCount(); +} + +void * spine_physics_constraint_mix_timeline_get_frames(spine_physics_constraint_mix_timeline obj) { + if (!obj) return nullptr; + PhysicsConstraintMixTimeline *_obj = (PhysicsConstraintMixTimeline *) obj; + return _obj->getFrames(); +} + +int32_t spine_physics_constraint_mix_timeline_get_num_frames(spine_physics_constraint_mix_timeline obj) { + if (!obj) return 0; + PhysicsConstraintMixTimeline *_obj = (PhysicsConstraintMixTimeline *) obj; + return (int32_t) _obj->getFrames().size(); +} + +spine_float *spine_physics_constraint_mix_timeline_get_frames(spine_physics_constraint_mix_timeline obj) { + if (!obj) return nullptr; + PhysicsConstraintMixTimeline *_obj = (PhysicsConstraintMixTimeline *) obj; + return (spine_float *) _obj->getFrames().buffer(); +} + +float spine_physics_constraint_mix_timeline_get_duration(spine_physics_constraint_mix_timeline obj) { + if (!obj) return 0; + PhysicsConstraintMixTimeline *_obj = (PhysicsConstraintMixTimeline *) obj; + return _obj->getDuration(); +} + +void * spine_physics_constraint_mix_timeline_get_property_ids(spine_physics_constraint_mix_timeline obj) { + if (!obj) return nullptr; + PhysicsConstraintMixTimeline *_obj = (PhysicsConstraintMixTimeline *) obj; + return _obj->getPropertyIds(); +} + +int32_t spine_physics_constraint_mix_timeline_get_num_property_ids(spine_physics_constraint_mix_timeline obj) { + if (!obj) return 0; + PhysicsConstraintMixTimeline *_obj = (PhysicsConstraintMixTimeline *) obj; + return (int32_t) _obj->getPropertyIds().size(); +} + +spine_property_id *spine_physics_constraint_mix_timeline_get_property_ids(spine_physics_constraint_mix_timeline obj) { + if (!obj) return nullptr; + PhysicsConstraintMixTimeline *_obj = (PhysicsConstraintMixTimeline *) obj; + return (spine_property_id *) _obj->getPropertyIds().buffer(); +} + +int32_t spine_physics_constraint_mix_timeline_get_constraint_index(spine_physics_constraint_mix_timeline obj) { + if (!obj) return 0; + PhysicsConstraintMixTimeline *_obj = (PhysicsConstraintMixTimeline *) obj; + return _obj->getConstraintIndex(); +} + +void spine_physics_constraint_mix_timeline_set_constraint_index(spine_physics_constraint_mix_timeline obj, int32_t value) { + if (!obj) return; + PhysicsConstraintMixTimeline *_obj = (PhysicsConstraintMixTimeline *) obj; + _obj->setConstraintIndex(value); +} diff --git a/spine-c-new/src/generated/physics_constraint_mix_timeline.h b/spine-c-new/src/generated/physics_constraint_mix_timeline.h new file mode 100644 index 000000000..5384a3008 --- /dev/null +++ b/spine-c-new/src/generated/physics_constraint_mix_timeline.h @@ -0,0 +1,74 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#ifndef SPINE_C_PHYSICSCONSTRAINTMIXTIMELINE_H +#define SPINE_C_PHYSICSCONSTRAINTMIXTIMELINE_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include "../custom.h" + +SPINE_OPAQUE_TYPE(spine_physics_constraint_mix_timeline) + +SPINE_C_EXPORT spine_physics_constraint_mix_timeline spine_physics_constraint_mix_timeline_create(spine_size_t frameCount, spine_size_t bezierCount, int32_t physicsConstraintIndex); +SPINE_C_EXPORT void spine_physics_constraint_mix_timeline_dispose(spine_physics_constraint_mix_timeline obj); +SPINE_C_EXPORT spine_rtti spine_physics_constraint_mix_timeline_get_rtti(spine_physics_constraint_mix_timeline obj); +SPINE_C_EXPORT void spine_physics_constraint_mix_timeline_apply(spine_physics_constraint_mix_timeline obj, spine_skeleton skeleton, float lastTime, float time, void * pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction, spine_bool appliedPose); +SPINE_C_EXPORT void spine_physics_constraint_mix_timeline_set_frame(spine_physics_constraint_mix_timeline obj, spine_size_t frame, float time, float value); +SPINE_C_EXPORT float spine_physics_constraint_mix_timeline_get_curve_value(spine_physics_constraint_mix_timeline obj, float time); +SPINE_C_EXPORT float spine_physics_constraint_mix_timeline_get_relative_value(spine_physics_constraint_mix_timeline obj, float time, float alpha, spine_mix_blend blend, float current, float setup); +SPINE_C_EXPORT float spine_physics_constraint_mix_timeline_get_absolute_value(spine_physics_constraint_mix_timeline obj, float time, float alpha, spine_mix_blend blend, float current, float setup); +SPINE_C_EXPORT float spine_physics_constraint_mix_timeline_get_absolute_value(spine_physics_constraint_mix_timeline obj, float time, float alpha, spine_mix_blend blend, float current, float setup, float value); +SPINE_C_EXPORT float spine_physics_constraint_mix_timeline_get_scale_value(spine_physics_constraint_mix_timeline obj, float time, float alpha, spine_mix_blend blend, spine_mix_direction direction, float current, float setup); +SPINE_C_EXPORT void spine_physics_constraint_mix_timeline_set_linear(spine_physics_constraint_mix_timeline obj, spine_size_t value); +SPINE_C_EXPORT void spine_physics_constraint_mix_timeline_set_stepped(spine_physics_constraint_mix_timeline obj, spine_size_t value); +SPINE_C_EXPORT void spine_physics_constraint_mix_timeline_set_bezier(spine_physics_constraint_mix_timeline obj, spine_size_t bezier, spine_size_t frame, float value, float time1, float value1, float cx1, float cy1, float cx2, float cy2, float time2, float value2); +SPINE_C_EXPORT float spine_physics_constraint_mix_timeline_get_bezier_value(spine_physics_constraint_mix_timeline obj, float time, spine_size_t frame, spine_size_t valueOffset, spine_size_t i); +SPINE_C_EXPORT void * spine_physics_constraint_mix_timeline_get_curves(spine_physics_constraint_mix_timeline obj); +SPINE_C_EXPORT int32_t spine_physics_constraint_mix_timeline_get_num_curves(spine_physics_constraint_mix_timeline obj); +SPINE_C_EXPORT spine_float *spine_physics_constraint_mix_timeline_get_curves(spine_physics_constraint_mix_timeline obj); +SPINE_C_EXPORT spine_size_t spine_physics_constraint_mix_timeline_get_frame_entries(spine_physics_constraint_mix_timeline obj); +SPINE_C_EXPORT spine_size_t spine_physics_constraint_mix_timeline_get_frame_count(spine_physics_constraint_mix_timeline obj); +SPINE_C_EXPORT void * spine_physics_constraint_mix_timeline_get_frames(spine_physics_constraint_mix_timeline obj); +SPINE_C_EXPORT int32_t spine_physics_constraint_mix_timeline_get_num_frames(spine_physics_constraint_mix_timeline obj); +SPINE_C_EXPORT spine_float *spine_physics_constraint_mix_timeline_get_frames(spine_physics_constraint_mix_timeline obj); +SPINE_C_EXPORT float spine_physics_constraint_mix_timeline_get_duration(spine_physics_constraint_mix_timeline obj); +SPINE_C_EXPORT void * spine_physics_constraint_mix_timeline_get_property_ids(spine_physics_constraint_mix_timeline obj); +SPINE_C_EXPORT int32_t spine_physics_constraint_mix_timeline_get_num_property_ids(spine_physics_constraint_mix_timeline obj); +SPINE_C_EXPORT spine_property_id *spine_physics_constraint_mix_timeline_get_property_ids(spine_physics_constraint_mix_timeline obj); +SPINE_C_EXPORT int32_t spine_physics_constraint_mix_timeline_get_constraint_index(spine_physics_constraint_mix_timeline obj); +SPINE_C_EXPORT void spine_physics_constraint_mix_timeline_set_constraint_index(spine_physics_constraint_mix_timeline obj, int32_t value); + +#ifdef __cplusplus +} +#endif + +#endif // SPINE_C_PHYSICSCONSTRAINTMIXTIMELINE_H \ No newline at end of file diff --git a/spine-c-new/src/generated/physics_constraint_pose.cpp b/spine-c-new/src/generated/physics_constraint_pose.cpp new file mode 100644 index 000000000..5452de9a0 --- /dev/null +++ b/spine-c-new/src/generated/physics_constraint_pose.cpp @@ -0,0 +1,133 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#include "physics_constraint_pose.h" +#include + +using namespace spine; + +spine_physics_constraint_pose spine_physics_constraint_pose_create(void) { + PhysicsConstraintPose *obj = new (__FILE__, __LINE__) PhysicsConstraintPose(); + return (spine_physics_constraint_pose) obj; +} + +void spine_physics_constraint_pose_dispose(spine_physics_constraint_pose obj) { + if (!obj) return; + delete (PhysicsConstraintPose *) obj; +} + +void spine_physics_constraint_pose_set(spine_physics_constraint_pose obj, spine_physics_constraint_pose value) { + if (!obj) return; + PhysicsConstraintPose *_obj = (PhysicsConstraintPose *) obj; + _obj->set(value); +} + +float spine_physics_constraint_pose_get_inertia(spine_physics_constraint_pose obj) { + if (!obj) return 0; + PhysicsConstraintPose *_obj = (PhysicsConstraintPose *) obj; + return _obj->getInertia(); +} + +void spine_physics_constraint_pose_set_inertia(spine_physics_constraint_pose obj, float value) { + if (!obj) return; + PhysicsConstraintPose *_obj = (PhysicsConstraintPose *) obj; + _obj->setInertia(value); +} + +float spine_physics_constraint_pose_get_strength(spine_physics_constraint_pose obj) { + if (!obj) return 0; + PhysicsConstraintPose *_obj = (PhysicsConstraintPose *) obj; + return _obj->getStrength(); +} + +void spine_physics_constraint_pose_set_strength(spine_physics_constraint_pose obj, float value) { + if (!obj) return; + PhysicsConstraintPose *_obj = (PhysicsConstraintPose *) obj; + _obj->setStrength(value); +} + +float spine_physics_constraint_pose_get_damping(spine_physics_constraint_pose obj) { + if (!obj) return 0; + PhysicsConstraintPose *_obj = (PhysicsConstraintPose *) obj; + return _obj->getDamping(); +} + +void spine_physics_constraint_pose_set_damping(spine_physics_constraint_pose obj, float value) { + if (!obj) return; + PhysicsConstraintPose *_obj = (PhysicsConstraintPose *) obj; + _obj->setDamping(value); +} + +float spine_physics_constraint_pose_get_mass_inverse(spine_physics_constraint_pose obj) { + if (!obj) return 0; + PhysicsConstraintPose *_obj = (PhysicsConstraintPose *) obj; + return _obj->getMassInverse(); +} + +void spine_physics_constraint_pose_set_mass_inverse(spine_physics_constraint_pose obj, float value) { + if (!obj) return; + PhysicsConstraintPose *_obj = (PhysicsConstraintPose *) obj; + _obj->setMassInverse(value); +} + +float spine_physics_constraint_pose_get_wind(spine_physics_constraint_pose obj) { + if (!obj) return 0; + PhysicsConstraintPose *_obj = (PhysicsConstraintPose *) obj; + return _obj->getWind(); +} + +void spine_physics_constraint_pose_set_wind(spine_physics_constraint_pose obj, float value) { + if (!obj) return; + PhysicsConstraintPose *_obj = (PhysicsConstraintPose *) obj; + _obj->setWind(value); +} + +float spine_physics_constraint_pose_get_gravity(spine_physics_constraint_pose obj) { + if (!obj) return 0; + PhysicsConstraintPose *_obj = (PhysicsConstraintPose *) obj; + return _obj->getGravity(); +} + +void spine_physics_constraint_pose_set_gravity(spine_physics_constraint_pose obj, float value) { + if (!obj) return; + PhysicsConstraintPose *_obj = (PhysicsConstraintPose *) obj; + _obj->setGravity(value); +} + +float spine_physics_constraint_pose_get_mix(spine_physics_constraint_pose obj) { + if (!obj) return 0; + PhysicsConstraintPose *_obj = (PhysicsConstraintPose *) obj; + return _obj->getMix(); +} + +void spine_physics_constraint_pose_set_mix(spine_physics_constraint_pose obj, float value) { + if (!obj) return; + PhysicsConstraintPose *_obj = (PhysicsConstraintPose *) obj; + _obj->setMix(value); +} diff --git a/spine-c-new/src/generated/physics_constraint_pose.h b/spine-c-new/src/generated/physics_constraint_pose.h new file mode 100644 index 000000000..cf18aa8c9 --- /dev/null +++ b/spine-c-new/src/generated/physics_constraint_pose.h @@ -0,0 +1,63 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#ifndef SPINE_C_PHYSICSCONSTRAINTPOSE_H +#define SPINE_C_PHYSICSCONSTRAINTPOSE_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include "../custom.h" + +SPINE_OPAQUE_TYPE(spine_physics_constraint_pose) + +SPINE_C_EXPORT spine_physics_constraint_pose spine_physics_constraint_pose_create(void); +SPINE_C_EXPORT void spine_physics_constraint_pose_dispose(spine_physics_constraint_pose obj); +SPINE_C_EXPORT void spine_physics_constraint_pose_set(spine_physics_constraint_pose obj, spine_physics_constraint_pose value); +SPINE_C_EXPORT float spine_physics_constraint_pose_get_inertia(spine_physics_constraint_pose obj); +SPINE_C_EXPORT void spine_physics_constraint_pose_set_inertia(spine_physics_constraint_pose obj, float value); +SPINE_C_EXPORT float spine_physics_constraint_pose_get_strength(spine_physics_constraint_pose obj); +SPINE_C_EXPORT void spine_physics_constraint_pose_set_strength(spine_physics_constraint_pose obj, float value); +SPINE_C_EXPORT float spine_physics_constraint_pose_get_damping(spine_physics_constraint_pose obj); +SPINE_C_EXPORT void spine_physics_constraint_pose_set_damping(spine_physics_constraint_pose obj, float value); +SPINE_C_EXPORT float spine_physics_constraint_pose_get_mass_inverse(spine_physics_constraint_pose obj); +SPINE_C_EXPORT void spine_physics_constraint_pose_set_mass_inverse(spine_physics_constraint_pose obj, float value); +SPINE_C_EXPORT float spine_physics_constraint_pose_get_wind(spine_physics_constraint_pose obj); +SPINE_C_EXPORT void spine_physics_constraint_pose_set_wind(spine_physics_constraint_pose obj, float value); +SPINE_C_EXPORT float spine_physics_constraint_pose_get_gravity(spine_physics_constraint_pose obj); +SPINE_C_EXPORT void spine_physics_constraint_pose_set_gravity(spine_physics_constraint_pose obj, float value); +SPINE_C_EXPORT float spine_physics_constraint_pose_get_mix(spine_physics_constraint_pose obj); +SPINE_C_EXPORT void spine_physics_constraint_pose_set_mix(spine_physics_constraint_pose obj, float value); + +#ifdef __cplusplus +} +#endif + +#endif // SPINE_C_PHYSICSCONSTRAINTPOSE_H \ No newline at end of file diff --git a/spine-c-new/src/generated/physics_constraint_reset_timeline.cpp b/spine-c-new/src/generated/physics_constraint_reset_timeline.cpp new file mode 100644 index 000000000..0cbeeff2a --- /dev/null +++ b/spine-c-new/src/generated/physics_constraint_reset_timeline.cpp @@ -0,0 +1,127 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#include "physics_constraint_reset_timeline.h" +#include + +using namespace spine; + +spine_physics_constraint_reset_timeline spine_physics_constraint_reset_timeline_create(spine_size_t frameCount, int32_t constraintIndex) { + PhysicsConstraintResetTimeline *obj = new (__FILE__, __LINE__) PhysicsConstraintResetTimeline(frameCount, constraintIndex); + return (spine_physics_constraint_reset_timeline) obj; +} + +void spine_physics_constraint_reset_timeline_dispose(spine_physics_constraint_reset_timeline obj) { + if (!obj) return; + delete (PhysicsConstraintResetTimeline *) obj; +} + +spine_rtti spine_physics_constraint_reset_timeline_get_rtti(spine_physics_constraint_reset_timeline obj) { + if (!obj) return nullptr; + PhysicsConstraintResetTimeline *_obj = (PhysicsConstraintResetTimeline *) obj; + return (spine_rtti) &_obj->getRTTI(); +} + +void spine_physics_constraint_reset_timeline_apply(spine_physics_constraint_reset_timeline obj, spine_skeleton skeleton, float lastTime, float time, void * pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction, spine_bool appliedPose) { + if (!obj) return ; + PhysicsConstraintResetTimeline *_obj = (PhysicsConstraintResetTimeline *) obj; + _obj->apply(skeleton, lastTime, time, (Vector *) pEvents, alpha, blend, direction, appliedPose); +} + +int32_t spine_physics_constraint_reset_timeline_get_frame_count(spine_physics_constraint_reset_timeline obj) { + if (!obj) return 0; + PhysicsConstraintResetTimeline *_obj = (PhysicsConstraintResetTimeline *) obj; + return _obj->getFrameCount(); +} + +int32_t spine_physics_constraint_reset_timeline_get_constraint_index(spine_physics_constraint_reset_timeline obj) { + if (!obj) return 0; + PhysicsConstraintResetTimeline *_obj = (PhysicsConstraintResetTimeline *) obj; + return _obj->getConstraintIndex(); +} + +void spine_physics_constraint_reset_timeline_set_frame(spine_physics_constraint_reset_timeline obj, int32_t frame, float time) { + if (!obj) return ; + PhysicsConstraintResetTimeline *_obj = (PhysicsConstraintResetTimeline *) obj; + _obj->setFrame(frame, time); +} + +spine_size_t spine_physics_constraint_reset_timeline_get_frame_entries(spine_physics_constraint_reset_timeline obj) { + if (!obj) return nullptr; + PhysicsConstraintResetTimeline *_obj = (PhysicsConstraintResetTimeline *) obj; + return _obj->getFrameEntries(); +} + +void * spine_physics_constraint_reset_timeline_get_frames(spine_physics_constraint_reset_timeline obj) { + if (!obj) return nullptr; + PhysicsConstraintResetTimeline *_obj = (PhysicsConstraintResetTimeline *) obj; + return _obj->getFrames(); +} + +int32_t spine_physics_constraint_reset_timeline_get_num_frames(spine_physics_constraint_reset_timeline obj) { + if (!obj) return 0; + PhysicsConstraintResetTimeline *_obj = (PhysicsConstraintResetTimeline *) obj; + return (int32_t) _obj->getFrames().size(); +} + +spine_float *spine_physics_constraint_reset_timeline_get_frames(spine_physics_constraint_reset_timeline obj) { + if (!obj) return nullptr; + PhysicsConstraintResetTimeline *_obj = (PhysicsConstraintResetTimeline *) obj; + return (spine_float *) _obj->getFrames().buffer(); +} + +float spine_physics_constraint_reset_timeline_get_duration(spine_physics_constraint_reset_timeline obj) { + if (!obj) return 0; + PhysicsConstraintResetTimeline *_obj = (PhysicsConstraintResetTimeline *) obj; + return _obj->getDuration(); +} + +void * spine_physics_constraint_reset_timeline_get_property_ids(spine_physics_constraint_reset_timeline obj) { + if (!obj) return nullptr; + PhysicsConstraintResetTimeline *_obj = (PhysicsConstraintResetTimeline *) obj; + return _obj->getPropertyIds(); +} + +int32_t spine_physics_constraint_reset_timeline_get_num_property_ids(spine_physics_constraint_reset_timeline obj) { + if (!obj) return 0; + PhysicsConstraintResetTimeline *_obj = (PhysicsConstraintResetTimeline *) obj; + return (int32_t) _obj->getPropertyIds().size(); +} + +spine_property_id *spine_physics_constraint_reset_timeline_get_property_ids(spine_physics_constraint_reset_timeline obj) { + if (!obj) return nullptr; + PhysicsConstraintResetTimeline *_obj = (PhysicsConstraintResetTimeline *) obj; + return (spine_property_id *) _obj->getPropertyIds().buffer(); +} + +void spine_physics_constraint_reset_timeline_set_constraint_index(spine_physics_constraint_reset_timeline obj, int32_t value) { + if (!obj) return; + PhysicsConstraintResetTimeline *_obj = (PhysicsConstraintResetTimeline *) obj; + _obj->setConstraintIndex(value); +} diff --git a/spine-c-new/src/generated/physics_constraint_reset_timeline.h b/spine-c-new/src/generated/physics_constraint_reset_timeline.h new file mode 100644 index 000000000..69ab478f8 --- /dev/null +++ b/spine-c-new/src/generated/physics_constraint_reset_timeline.h @@ -0,0 +1,62 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#ifndef SPINE_C_PHYSICSCONSTRAINTRESETTIMELINE_H +#define SPINE_C_PHYSICSCONSTRAINTRESETTIMELINE_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include "../custom.h" + +SPINE_OPAQUE_TYPE(spine_physics_constraint_reset_timeline) + +SPINE_C_EXPORT spine_physics_constraint_reset_timeline spine_physics_constraint_reset_timeline_create(spine_size_t frameCount, int32_t constraintIndex); +SPINE_C_EXPORT void spine_physics_constraint_reset_timeline_dispose(spine_physics_constraint_reset_timeline obj); +SPINE_C_EXPORT spine_rtti spine_physics_constraint_reset_timeline_get_rtti(spine_physics_constraint_reset_timeline obj); +SPINE_C_EXPORT void spine_physics_constraint_reset_timeline_apply(spine_physics_constraint_reset_timeline obj, spine_skeleton skeleton, float lastTime, float time, void * pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction, spine_bool appliedPose); +SPINE_C_EXPORT int32_t spine_physics_constraint_reset_timeline_get_frame_count(spine_physics_constraint_reset_timeline obj); +SPINE_C_EXPORT int32_t spine_physics_constraint_reset_timeline_get_constraint_index(spine_physics_constraint_reset_timeline obj); +SPINE_C_EXPORT void spine_physics_constraint_reset_timeline_set_frame(spine_physics_constraint_reset_timeline obj, int32_t frame, float time); +SPINE_C_EXPORT spine_size_t spine_physics_constraint_reset_timeline_get_frame_entries(spine_physics_constraint_reset_timeline obj); +SPINE_C_EXPORT void * spine_physics_constraint_reset_timeline_get_frames(spine_physics_constraint_reset_timeline obj); +SPINE_C_EXPORT int32_t spine_physics_constraint_reset_timeline_get_num_frames(spine_physics_constraint_reset_timeline obj); +SPINE_C_EXPORT spine_float *spine_physics_constraint_reset_timeline_get_frames(spine_physics_constraint_reset_timeline obj); +SPINE_C_EXPORT float spine_physics_constraint_reset_timeline_get_duration(spine_physics_constraint_reset_timeline obj); +SPINE_C_EXPORT void * spine_physics_constraint_reset_timeline_get_property_ids(spine_physics_constraint_reset_timeline obj); +SPINE_C_EXPORT int32_t spine_physics_constraint_reset_timeline_get_num_property_ids(spine_physics_constraint_reset_timeline obj); +SPINE_C_EXPORT spine_property_id *spine_physics_constraint_reset_timeline_get_property_ids(spine_physics_constraint_reset_timeline obj); +SPINE_C_EXPORT void spine_physics_constraint_reset_timeline_set_constraint_index(spine_physics_constraint_reset_timeline obj, int32_t value); + +#ifdef __cplusplus +} +#endif + +#endif // SPINE_C_PHYSICSCONSTRAINTRESETTIMELINE_H \ No newline at end of file diff --git a/spine-c-new/src/generated/physics_constraint_strength_timeline.cpp b/spine-c-new/src/generated/physics_constraint_strength_timeline.cpp new file mode 100644 index 000000000..63574700b --- /dev/null +++ b/spine-c-new/src/generated/physics_constraint_strength_timeline.cpp @@ -0,0 +1,199 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#include "physics_constraint_strength_timeline.h" +#include + +using namespace spine; + +spine_physics_constraint_strength_timeline spine_physics_constraint_strength_timeline_create(spine_size_t frameCount, spine_size_t bezierCount, int32_t physicsConstraintIndex) { + PhysicsConstraintStrengthTimeline *obj = new (__FILE__, __LINE__) PhysicsConstraintStrengthTimeline(frameCount, bezierCount, physicsConstraintIndex); + return (spine_physics_constraint_strength_timeline) obj; +} + +void spine_physics_constraint_strength_timeline_dispose(spine_physics_constraint_strength_timeline obj) { + if (!obj) return; + delete (PhysicsConstraintStrengthTimeline *) obj; +} + +spine_rtti spine_physics_constraint_strength_timeline_get_rtti(spine_physics_constraint_strength_timeline obj) { + if (!obj) return nullptr; + PhysicsConstraintStrengthTimeline *_obj = (PhysicsConstraintStrengthTimeline *) obj; + return (spine_rtti) &_obj->getRTTI(); +} + +void spine_physics_constraint_strength_timeline_apply(spine_physics_constraint_strength_timeline obj, spine_skeleton skeleton, float lastTime, float time, void * pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction, spine_bool appliedPose) { + if (!obj) return ; + PhysicsConstraintStrengthTimeline *_obj = (PhysicsConstraintStrengthTimeline *) obj; + _obj->apply(skeleton, lastTime, time, (Vector *) pEvents, alpha, blend, direction, appliedPose); +} + +void spine_physics_constraint_strength_timeline_set_frame(spine_physics_constraint_strength_timeline obj, spine_size_t frame, float time, float value) { + if (!obj) return ; + PhysicsConstraintStrengthTimeline *_obj = (PhysicsConstraintStrengthTimeline *) obj; + _obj->setFrame(frame, time, value); +} + +float spine_physics_constraint_strength_timeline_get_curve_value(spine_physics_constraint_strength_timeline obj, float time) { + if (!obj) return 0; + PhysicsConstraintStrengthTimeline *_obj = (PhysicsConstraintStrengthTimeline *) obj; + return _obj->getCurveValue(time); +} + +float spine_physics_constraint_strength_timeline_get_relative_value(spine_physics_constraint_strength_timeline obj, float time, float alpha, spine_mix_blend blend, float current, float setup) { + if (!obj) return 0; + PhysicsConstraintStrengthTimeline *_obj = (PhysicsConstraintStrengthTimeline *) obj; + return _obj->getRelativeValue(time, alpha, blend, current, setup); +} + +float spine_physics_constraint_strength_timeline_get_absolute_value(spine_physics_constraint_strength_timeline obj, float time, float alpha, spine_mix_blend blend, float current, float setup) { + if (!obj) return 0; + PhysicsConstraintStrengthTimeline *_obj = (PhysicsConstraintStrengthTimeline *) obj; + return _obj->getAbsoluteValue(time, alpha, blend, current, setup); +} + +float spine_physics_constraint_strength_timeline_get_absolute_value(spine_physics_constraint_strength_timeline obj, float time, float alpha, spine_mix_blend blend, float current, float setup, float value) { + if (!obj) return 0; + PhysicsConstraintStrengthTimeline *_obj = (PhysicsConstraintStrengthTimeline *) obj; + return _obj->getAbsoluteValue(time, alpha, blend, current, setup, value); +} + +float spine_physics_constraint_strength_timeline_get_scale_value(spine_physics_constraint_strength_timeline obj, float time, float alpha, spine_mix_blend blend, spine_mix_direction direction, float current, float setup) { + if (!obj) return 0; + PhysicsConstraintStrengthTimeline *_obj = (PhysicsConstraintStrengthTimeline *) obj; + return _obj->getScaleValue(time, alpha, blend, direction, current, setup); +} + +void spine_physics_constraint_strength_timeline_set_linear(spine_physics_constraint_strength_timeline obj, spine_size_t value) { + if (!obj) return; + PhysicsConstraintStrengthTimeline *_obj = (PhysicsConstraintStrengthTimeline *) obj; + _obj->setLinear(value); +} + +void spine_physics_constraint_strength_timeline_set_stepped(spine_physics_constraint_strength_timeline obj, spine_size_t value) { + if (!obj) return; + PhysicsConstraintStrengthTimeline *_obj = (PhysicsConstraintStrengthTimeline *) obj; + _obj->setStepped(value); +} + +void spine_physics_constraint_strength_timeline_set_bezier(spine_physics_constraint_strength_timeline obj, spine_size_t bezier, spine_size_t frame, float value, float time1, float value1, float cx1, float cy1, float cx2, float cy2, float time2, float value2) { + if (!obj) return ; + PhysicsConstraintStrengthTimeline *_obj = (PhysicsConstraintStrengthTimeline *) obj; + _obj->setBezier(bezier, frame, value, time1, value1, cx1, cy1, cx2, cy2, time2, value2); +} + +float spine_physics_constraint_strength_timeline_get_bezier_value(spine_physics_constraint_strength_timeline obj, float time, spine_size_t frame, spine_size_t valueOffset, spine_size_t i) { + if (!obj) return 0; + PhysicsConstraintStrengthTimeline *_obj = (PhysicsConstraintStrengthTimeline *) obj; + return _obj->getBezierValue(time, frame, valueOffset, i); +} + +void * spine_physics_constraint_strength_timeline_get_curves(spine_physics_constraint_strength_timeline obj) { + if (!obj) return nullptr; + PhysicsConstraintStrengthTimeline *_obj = (PhysicsConstraintStrengthTimeline *) obj; + return _obj->getCurves(); +} + +int32_t spine_physics_constraint_strength_timeline_get_num_curves(spine_physics_constraint_strength_timeline obj) { + if (!obj) return 0; + PhysicsConstraintStrengthTimeline *_obj = (PhysicsConstraintStrengthTimeline *) obj; + return (int32_t) _obj->getCurves().size(); +} + +spine_float *spine_physics_constraint_strength_timeline_get_curves(spine_physics_constraint_strength_timeline obj) { + if (!obj) return nullptr; + PhysicsConstraintStrengthTimeline *_obj = (PhysicsConstraintStrengthTimeline *) obj; + return (spine_float *) _obj->getCurves().buffer(); +} + +spine_size_t spine_physics_constraint_strength_timeline_get_frame_entries(spine_physics_constraint_strength_timeline obj) { + if (!obj) return nullptr; + PhysicsConstraintStrengthTimeline *_obj = (PhysicsConstraintStrengthTimeline *) obj; + return _obj->getFrameEntries(); +} + +spine_size_t spine_physics_constraint_strength_timeline_get_frame_count(spine_physics_constraint_strength_timeline obj) { + if (!obj) return nullptr; + PhysicsConstraintStrengthTimeline *_obj = (PhysicsConstraintStrengthTimeline *) obj; + return _obj->getFrameCount(); +} + +void * spine_physics_constraint_strength_timeline_get_frames(spine_physics_constraint_strength_timeline obj) { + if (!obj) return nullptr; + PhysicsConstraintStrengthTimeline *_obj = (PhysicsConstraintStrengthTimeline *) obj; + return _obj->getFrames(); +} + +int32_t spine_physics_constraint_strength_timeline_get_num_frames(spine_physics_constraint_strength_timeline obj) { + if (!obj) return 0; + PhysicsConstraintStrengthTimeline *_obj = (PhysicsConstraintStrengthTimeline *) obj; + return (int32_t) _obj->getFrames().size(); +} + +spine_float *spine_physics_constraint_strength_timeline_get_frames(spine_physics_constraint_strength_timeline obj) { + if (!obj) return nullptr; + PhysicsConstraintStrengthTimeline *_obj = (PhysicsConstraintStrengthTimeline *) obj; + return (spine_float *) _obj->getFrames().buffer(); +} + +float spine_physics_constraint_strength_timeline_get_duration(spine_physics_constraint_strength_timeline obj) { + if (!obj) return 0; + PhysicsConstraintStrengthTimeline *_obj = (PhysicsConstraintStrengthTimeline *) obj; + return _obj->getDuration(); +} + +void * spine_physics_constraint_strength_timeline_get_property_ids(spine_physics_constraint_strength_timeline obj) { + if (!obj) return nullptr; + PhysicsConstraintStrengthTimeline *_obj = (PhysicsConstraintStrengthTimeline *) obj; + return _obj->getPropertyIds(); +} + +int32_t spine_physics_constraint_strength_timeline_get_num_property_ids(spine_physics_constraint_strength_timeline obj) { + if (!obj) return 0; + PhysicsConstraintStrengthTimeline *_obj = (PhysicsConstraintStrengthTimeline *) obj; + return (int32_t) _obj->getPropertyIds().size(); +} + +spine_property_id *spine_physics_constraint_strength_timeline_get_property_ids(spine_physics_constraint_strength_timeline obj) { + if (!obj) return nullptr; + PhysicsConstraintStrengthTimeline *_obj = (PhysicsConstraintStrengthTimeline *) obj; + return (spine_property_id *) _obj->getPropertyIds().buffer(); +} + +int32_t spine_physics_constraint_strength_timeline_get_constraint_index(spine_physics_constraint_strength_timeline obj) { + if (!obj) return 0; + PhysicsConstraintStrengthTimeline *_obj = (PhysicsConstraintStrengthTimeline *) obj; + return _obj->getConstraintIndex(); +} + +void spine_physics_constraint_strength_timeline_set_constraint_index(spine_physics_constraint_strength_timeline obj, int32_t value) { + if (!obj) return; + PhysicsConstraintStrengthTimeline *_obj = (PhysicsConstraintStrengthTimeline *) obj; + _obj->setConstraintIndex(value); +} diff --git a/spine-c-new/src/generated/physics_constraint_strength_timeline.h b/spine-c-new/src/generated/physics_constraint_strength_timeline.h new file mode 100644 index 000000000..c81d6f538 --- /dev/null +++ b/spine-c-new/src/generated/physics_constraint_strength_timeline.h @@ -0,0 +1,74 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#ifndef SPINE_C_PHYSICSCONSTRAINTSTRENGTHTIMELINE_H +#define SPINE_C_PHYSICSCONSTRAINTSTRENGTHTIMELINE_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include "../custom.h" + +SPINE_OPAQUE_TYPE(spine_physics_constraint_strength_timeline) + +SPINE_C_EXPORT spine_physics_constraint_strength_timeline spine_physics_constraint_strength_timeline_create(spine_size_t frameCount, spine_size_t bezierCount, int32_t physicsConstraintIndex); +SPINE_C_EXPORT void spine_physics_constraint_strength_timeline_dispose(spine_physics_constraint_strength_timeline obj); +SPINE_C_EXPORT spine_rtti spine_physics_constraint_strength_timeline_get_rtti(spine_physics_constraint_strength_timeline obj); +SPINE_C_EXPORT void spine_physics_constraint_strength_timeline_apply(spine_physics_constraint_strength_timeline obj, spine_skeleton skeleton, float lastTime, float time, void * pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction, spine_bool appliedPose); +SPINE_C_EXPORT void spine_physics_constraint_strength_timeline_set_frame(spine_physics_constraint_strength_timeline obj, spine_size_t frame, float time, float value); +SPINE_C_EXPORT float spine_physics_constraint_strength_timeline_get_curve_value(spine_physics_constraint_strength_timeline obj, float time); +SPINE_C_EXPORT float spine_physics_constraint_strength_timeline_get_relative_value(spine_physics_constraint_strength_timeline obj, float time, float alpha, spine_mix_blend blend, float current, float setup); +SPINE_C_EXPORT float spine_physics_constraint_strength_timeline_get_absolute_value(spine_physics_constraint_strength_timeline obj, float time, float alpha, spine_mix_blend blend, float current, float setup); +SPINE_C_EXPORT float spine_physics_constraint_strength_timeline_get_absolute_value(spine_physics_constraint_strength_timeline obj, float time, float alpha, spine_mix_blend blend, float current, float setup, float value); +SPINE_C_EXPORT float spine_physics_constraint_strength_timeline_get_scale_value(spine_physics_constraint_strength_timeline obj, float time, float alpha, spine_mix_blend blend, spine_mix_direction direction, float current, float setup); +SPINE_C_EXPORT void spine_physics_constraint_strength_timeline_set_linear(spine_physics_constraint_strength_timeline obj, spine_size_t value); +SPINE_C_EXPORT void spine_physics_constraint_strength_timeline_set_stepped(spine_physics_constraint_strength_timeline obj, spine_size_t value); +SPINE_C_EXPORT void spine_physics_constraint_strength_timeline_set_bezier(spine_physics_constraint_strength_timeline obj, spine_size_t bezier, spine_size_t frame, float value, float time1, float value1, float cx1, float cy1, float cx2, float cy2, float time2, float value2); +SPINE_C_EXPORT float spine_physics_constraint_strength_timeline_get_bezier_value(spine_physics_constraint_strength_timeline obj, float time, spine_size_t frame, spine_size_t valueOffset, spine_size_t i); +SPINE_C_EXPORT void * spine_physics_constraint_strength_timeline_get_curves(spine_physics_constraint_strength_timeline obj); +SPINE_C_EXPORT int32_t spine_physics_constraint_strength_timeline_get_num_curves(spine_physics_constraint_strength_timeline obj); +SPINE_C_EXPORT spine_float *spine_physics_constraint_strength_timeline_get_curves(spine_physics_constraint_strength_timeline obj); +SPINE_C_EXPORT spine_size_t spine_physics_constraint_strength_timeline_get_frame_entries(spine_physics_constraint_strength_timeline obj); +SPINE_C_EXPORT spine_size_t spine_physics_constraint_strength_timeline_get_frame_count(spine_physics_constraint_strength_timeline obj); +SPINE_C_EXPORT void * spine_physics_constraint_strength_timeline_get_frames(spine_physics_constraint_strength_timeline obj); +SPINE_C_EXPORT int32_t spine_physics_constraint_strength_timeline_get_num_frames(spine_physics_constraint_strength_timeline obj); +SPINE_C_EXPORT spine_float *spine_physics_constraint_strength_timeline_get_frames(spine_physics_constraint_strength_timeline obj); +SPINE_C_EXPORT float spine_physics_constraint_strength_timeline_get_duration(spine_physics_constraint_strength_timeline obj); +SPINE_C_EXPORT void * spine_physics_constraint_strength_timeline_get_property_ids(spine_physics_constraint_strength_timeline obj); +SPINE_C_EXPORT int32_t spine_physics_constraint_strength_timeline_get_num_property_ids(spine_physics_constraint_strength_timeline obj); +SPINE_C_EXPORT spine_property_id *spine_physics_constraint_strength_timeline_get_property_ids(spine_physics_constraint_strength_timeline obj); +SPINE_C_EXPORT int32_t spine_physics_constraint_strength_timeline_get_constraint_index(spine_physics_constraint_strength_timeline obj); +SPINE_C_EXPORT void spine_physics_constraint_strength_timeline_set_constraint_index(spine_physics_constraint_strength_timeline obj, int32_t value); + +#ifdef __cplusplus +} +#endif + +#endif // SPINE_C_PHYSICSCONSTRAINTSTRENGTHTIMELINE_H \ No newline at end of file diff --git a/spine-c-new/src/generated/physics_constraint_timeline.cpp b/spine-c-new/src/generated/physics_constraint_timeline.cpp new file mode 100644 index 000000000..df195cd0d --- /dev/null +++ b/spine-c-new/src/generated/physics_constraint_timeline.cpp @@ -0,0 +1,199 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#include "physics_constraint_timeline.h" +#include + +using namespace spine; + +spine_physics_constraint_timeline spine_physics_constraint_timeline_create(spine_size_t frameCount, spine_size_t bezierCount, int32_t constraintIndex, spine_property property) { + PhysicsConstraintTimeline *obj = new (__FILE__, __LINE__) PhysicsConstraintTimeline(frameCount, bezierCount, constraintIndex, property); + return (spine_physics_constraint_timeline) obj; +} + +void spine_physics_constraint_timeline_dispose(spine_physics_constraint_timeline obj) { + if (!obj) return; + delete (PhysicsConstraintTimeline *) obj; +} + +spine_rtti spine_physics_constraint_timeline_get_rtti(spine_physics_constraint_timeline obj) { + if (!obj) return nullptr; + PhysicsConstraintTimeline *_obj = (PhysicsConstraintTimeline *) obj; + return (spine_rtti) &_obj->getRTTI(); +} + +void spine_physics_constraint_timeline_apply(spine_physics_constraint_timeline obj, spine_skeleton skeleton, float lastTime, float time, void * pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction, spine_bool appliedPose) { + if (!obj) return ; + PhysicsConstraintTimeline *_obj = (PhysicsConstraintTimeline *) obj; + _obj->apply(skeleton, lastTime, time, (Vector *) pEvents, alpha, blend, direction, appliedPose); +} + +void spine_physics_constraint_timeline_set_frame(spine_physics_constraint_timeline obj, spine_size_t frame, float time, float value) { + if (!obj) return ; + PhysicsConstraintTimeline *_obj = (PhysicsConstraintTimeline *) obj; + _obj->setFrame(frame, time, value); +} + +float spine_physics_constraint_timeline_get_curve_value(spine_physics_constraint_timeline obj, float time) { + if (!obj) return 0; + PhysicsConstraintTimeline *_obj = (PhysicsConstraintTimeline *) obj; + return _obj->getCurveValue(time); +} + +float spine_physics_constraint_timeline_get_relative_value(spine_physics_constraint_timeline obj, float time, float alpha, spine_mix_blend blend, float current, float setup) { + if (!obj) return 0; + PhysicsConstraintTimeline *_obj = (PhysicsConstraintTimeline *) obj; + return _obj->getRelativeValue(time, alpha, blend, current, setup); +} + +float spine_physics_constraint_timeline_get_absolute_value(spine_physics_constraint_timeline obj, float time, float alpha, spine_mix_blend blend, float current, float setup) { + if (!obj) return 0; + PhysicsConstraintTimeline *_obj = (PhysicsConstraintTimeline *) obj; + return _obj->getAbsoluteValue(time, alpha, blend, current, setup); +} + +float spine_physics_constraint_timeline_get_absolute_value(spine_physics_constraint_timeline obj, float time, float alpha, spine_mix_blend blend, float current, float setup, float value) { + if (!obj) return 0; + PhysicsConstraintTimeline *_obj = (PhysicsConstraintTimeline *) obj; + return _obj->getAbsoluteValue(time, alpha, blend, current, setup, value); +} + +float spine_physics_constraint_timeline_get_scale_value(spine_physics_constraint_timeline obj, float time, float alpha, spine_mix_blend blend, spine_mix_direction direction, float current, float setup) { + if (!obj) return 0; + PhysicsConstraintTimeline *_obj = (PhysicsConstraintTimeline *) obj; + return _obj->getScaleValue(time, alpha, blend, direction, current, setup); +} + +void spine_physics_constraint_timeline_set_linear(spine_physics_constraint_timeline obj, spine_size_t value) { + if (!obj) return; + PhysicsConstraintTimeline *_obj = (PhysicsConstraintTimeline *) obj; + _obj->setLinear(value); +} + +void spine_physics_constraint_timeline_set_stepped(spine_physics_constraint_timeline obj, spine_size_t value) { + if (!obj) return; + PhysicsConstraintTimeline *_obj = (PhysicsConstraintTimeline *) obj; + _obj->setStepped(value); +} + +void spine_physics_constraint_timeline_set_bezier(spine_physics_constraint_timeline obj, spine_size_t bezier, spine_size_t frame, float value, float time1, float value1, float cx1, float cy1, float cx2, float cy2, float time2, float value2) { + if (!obj) return ; + PhysicsConstraintTimeline *_obj = (PhysicsConstraintTimeline *) obj; + _obj->setBezier(bezier, frame, value, time1, value1, cx1, cy1, cx2, cy2, time2, value2); +} + +float spine_physics_constraint_timeline_get_bezier_value(spine_physics_constraint_timeline obj, float time, spine_size_t frame, spine_size_t valueOffset, spine_size_t i) { + if (!obj) return 0; + PhysicsConstraintTimeline *_obj = (PhysicsConstraintTimeline *) obj; + return _obj->getBezierValue(time, frame, valueOffset, i); +} + +void * spine_physics_constraint_timeline_get_curves(spine_physics_constraint_timeline obj) { + if (!obj) return nullptr; + PhysicsConstraintTimeline *_obj = (PhysicsConstraintTimeline *) obj; + return _obj->getCurves(); +} + +int32_t spine_physics_constraint_timeline_get_num_curves(spine_physics_constraint_timeline obj) { + if (!obj) return 0; + PhysicsConstraintTimeline *_obj = (PhysicsConstraintTimeline *) obj; + return (int32_t) _obj->getCurves().size(); +} + +spine_float *spine_physics_constraint_timeline_get_curves(spine_physics_constraint_timeline obj) { + if (!obj) return nullptr; + PhysicsConstraintTimeline *_obj = (PhysicsConstraintTimeline *) obj; + return (spine_float *) _obj->getCurves().buffer(); +} + +spine_size_t spine_physics_constraint_timeline_get_frame_entries(spine_physics_constraint_timeline obj) { + if (!obj) return nullptr; + PhysicsConstraintTimeline *_obj = (PhysicsConstraintTimeline *) obj; + return _obj->getFrameEntries(); +} + +spine_size_t spine_physics_constraint_timeline_get_frame_count(spine_physics_constraint_timeline obj) { + if (!obj) return nullptr; + PhysicsConstraintTimeline *_obj = (PhysicsConstraintTimeline *) obj; + return _obj->getFrameCount(); +} + +void * spine_physics_constraint_timeline_get_frames(spine_physics_constraint_timeline obj) { + if (!obj) return nullptr; + PhysicsConstraintTimeline *_obj = (PhysicsConstraintTimeline *) obj; + return _obj->getFrames(); +} + +int32_t spine_physics_constraint_timeline_get_num_frames(spine_physics_constraint_timeline obj) { + if (!obj) return 0; + PhysicsConstraintTimeline *_obj = (PhysicsConstraintTimeline *) obj; + return (int32_t) _obj->getFrames().size(); +} + +spine_float *spine_physics_constraint_timeline_get_frames(spine_physics_constraint_timeline obj) { + if (!obj) return nullptr; + PhysicsConstraintTimeline *_obj = (PhysicsConstraintTimeline *) obj; + return (spine_float *) _obj->getFrames().buffer(); +} + +float spine_physics_constraint_timeline_get_duration(spine_physics_constraint_timeline obj) { + if (!obj) return 0; + PhysicsConstraintTimeline *_obj = (PhysicsConstraintTimeline *) obj; + return _obj->getDuration(); +} + +void * spine_physics_constraint_timeline_get_property_ids(spine_physics_constraint_timeline obj) { + if (!obj) return nullptr; + PhysicsConstraintTimeline *_obj = (PhysicsConstraintTimeline *) obj; + return _obj->getPropertyIds(); +} + +int32_t spine_physics_constraint_timeline_get_num_property_ids(spine_physics_constraint_timeline obj) { + if (!obj) return 0; + PhysicsConstraintTimeline *_obj = (PhysicsConstraintTimeline *) obj; + return (int32_t) _obj->getPropertyIds().size(); +} + +spine_property_id *spine_physics_constraint_timeline_get_property_ids(spine_physics_constraint_timeline obj) { + if (!obj) return nullptr; + PhysicsConstraintTimeline *_obj = (PhysicsConstraintTimeline *) obj; + return (spine_property_id *) _obj->getPropertyIds().buffer(); +} + +int32_t spine_physics_constraint_timeline_get_constraint_index(spine_physics_constraint_timeline obj) { + if (!obj) return 0; + PhysicsConstraintTimeline *_obj = (PhysicsConstraintTimeline *) obj; + return _obj->getConstraintIndex(); +} + +void spine_physics_constraint_timeline_set_constraint_index(spine_physics_constraint_timeline obj, int32_t value) { + if (!obj) return; + PhysicsConstraintTimeline *_obj = (PhysicsConstraintTimeline *) obj; + _obj->setConstraintIndex(value); +} diff --git a/spine-c-new/src/generated/physics_constraint_timeline.h b/spine-c-new/src/generated/physics_constraint_timeline.h new file mode 100644 index 000000000..8d4d7c74d --- /dev/null +++ b/spine-c-new/src/generated/physics_constraint_timeline.h @@ -0,0 +1,74 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#ifndef SPINE_C_PHYSICSCONSTRAINTTIMELINE_H +#define SPINE_C_PHYSICSCONSTRAINTTIMELINE_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include "../custom.h" + +SPINE_OPAQUE_TYPE(spine_physics_constraint_timeline) + +SPINE_C_EXPORT spine_physics_constraint_timeline spine_physics_constraint_timeline_create(spine_size_t frameCount, spine_size_t bezierCount, int32_t constraintIndex, spine_property property); +SPINE_C_EXPORT void spine_physics_constraint_timeline_dispose(spine_physics_constraint_timeline obj); +SPINE_C_EXPORT spine_rtti spine_physics_constraint_timeline_get_rtti(spine_physics_constraint_timeline obj); +SPINE_C_EXPORT void spine_physics_constraint_timeline_apply(spine_physics_constraint_timeline obj, spine_skeleton skeleton, float lastTime, float time, void * pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction, spine_bool appliedPose); +SPINE_C_EXPORT void spine_physics_constraint_timeline_set_frame(spine_physics_constraint_timeline obj, spine_size_t frame, float time, float value); +SPINE_C_EXPORT float spine_physics_constraint_timeline_get_curve_value(spine_physics_constraint_timeline obj, float time); +SPINE_C_EXPORT float spine_physics_constraint_timeline_get_relative_value(spine_physics_constraint_timeline obj, float time, float alpha, spine_mix_blend blend, float current, float setup); +SPINE_C_EXPORT float spine_physics_constraint_timeline_get_absolute_value(spine_physics_constraint_timeline obj, float time, float alpha, spine_mix_blend blend, float current, float setup); +SPINE_C_EXPORT float spine_physics_constraint_timeline_get_absolute_value(spine_physics_constraint_timeline obj, float time, float alpha, spine_mix_blend blend, float current, float setup, float value); +SPINE_C_EXPORT float spine_physics_constraint_timeline_get_scale_value(spine_physics_constraint_timeline obj, float time, float alpha, spine_mix_blend blend, spine_mix_direction direction, float current, float setup); +SPINE_C_EXPORT void spine_physics_constraint_timeline_set_linear(spine_physics_constraint_timeline obj, spine_size_t value); +SPINE_C_EXPORT void spine_physics_constraint_timeline_set_stepped(spine_physics_constraint_timeline obj, spine_size_t value); +SPINE_C_EXPORT void spine_physics_constraint_timeline_set_bezier(spine_physics_constraint_timeline obj, spine_size_t bezier, spine_size_t frame, float value, float time1, float value1, float cx1, float cy1, float cx2, float cy2, float time2, float value2); +SPINE_C_EXPORT float spine_physics_constraint_timeline_get_bezier_value(spine_physics_constraint_timeline obj, float time, spine_size_t frame, spine_size_t valueOffset, spine_size_t i); +SPINE_C_EXPORT void * spine_physics_constraint_timeline_get_curves(spine_physics_constraint_timeline obj); +SPINE_C_EXPORT int32_t spine_physics_constraint_timeline_get_num_curves(spine_physics_constraint_timeline obj); +SPINE_C_EXPORT spine_float *spine_physics_constraint_timeline_get_curves(spine_physics_constraint_timeline obj); +SPINE_C_EXPORT spine_size_t spine_physics_constraint_timeline_get_frame_entries(spine_physics_constraint_timeline obj); +SPINE_C_EXPORT spine_size_t spine_physics_constraint_timeline_get_frame_count(spine_physics_constraint_timeline obj); +SPINE_C_EXPORT void * spine_physics_constraint_timeline_get_frames(spine_physics_constraint_timeline obj); +SPINE_C_EXPORT int32_t spine_physics_constraint_timeline_get_num_frames(spine_physics_constraint_timeline obj); +SPINE_C_EXPORT spine_float *spine_physics_constraint_timeline_get_frames(spine_physics_constraint_timeline obj); +SPINE_C_EXPORT float spine_physics_constraint_timeline_get_duration(spine_physics_constraint_timeline obj); +SPINE_C_EXPORT void * spine_physics_constraint_timeline_get_property_ids(spine_physics_constraint_timeline obj); +SPINE_C_EXPORT int32_t spine_physics_constraint_timeline_get_num_property_ids(spine_physics_constraint_timeline obj); +SPINE_C_EXPORT spine_property_id *spine_physics_constraint_timeline_get_property_ids(spine_physics_constraint_timeline obj); +SPINE_C_EXPORT int32_t spine_physics_constraint_timeline_get_constraint_index(spine_physics_constraint_timeline obj); +SPINE_C_EXPORT void spine_physics_constraint_timeline_set_constraint_index(spine_physics_constraint_timeline obj, int32_t value); + +#ifdef __cplusplus +} +#endif + +#endif // SPINE_C_PHYSICSCONSTRAINTTIMELINE_H \ No newline at end of file diff --git a/spine-c-new/src/generated/physics_constraint_wind_timeline.cpp b/spine-c-new/src/generated/physics_constraint_wind_timeline.cpp new file mode 100644 index 000000000..82fc9140a --- /dev/null +++ b/spine-c-new/src/generated/physics_constraint_wind_timeline.cpp @@ -0,0 +1,199 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#include "physics_constraint_wind_timeline.h" +#include + +using namespace spine; + +spine_physics_constraint_wind_timeline spine_physics_constraint_wind_timeline_create(spine_size_t frameCount, spine_size_t bezierCount, int32_t physicsConstraintIndex) { + PhysicsConstraintWindTimeline *obj = new (__FILE__, __LINE__) PhysicsConstraintWindTimeline(frameCount, bezierCount, physicsConstraintIndex); + return (spine_physics_constraint_wind_timeline) obj; +} + +void spine_physics_constraint_wind_timeline_dispose(spine_physics_constraint_wind_timeline obj) { + if (!obj) return; + delete (PhysicsConstraintWindTimeline *) obj; +} + +spine_rtti spine_physics_constraint_wind_timeline_get_rtti(spine_physics_constraint_wind_timeline obj) { + if (!obj) return nullptr; + PhysicsConstraintWindTimeline *_obj = (PhysicsConstraintWindTimeline *) obj; + return (spine_rtti) &_obj->getRTTI(); +} + +void spine_physics_constraint_wind_timeline_apply(spine_physics_constraint_wind_timeline obj, spine_skeleton skeleton, float lastTime, float time, void * pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction, spine_bool appliedPose) { + if (!obj) return ; + PhysicsConstraintWindTimeline *_obj = (PhysicsConstraintWindTimeline *) obj; + _obj->apply(skeleton, lastTime, time, (Vector *) pEvents, alpha, blend, direction, appliedPose); +} + +void spine_physics_constraint_wind_timeline_set_frame(spine_physics_constraint_wind_timeline obj, spine_size_t frame, float time, float value) { + if (!obj) return ; + PhysicsConstraintWindTimeline *_obj = (PhysicsConstraintWindTimeline *) obj; + _obj->setFrame(frame, time, value); +} + +float spine_physics_constraint_wind_timeline_get_curve_value(spine_physics_constraint_wind_timeline obj, float time) { + if (!obj) return 0; + PhysicsConstraintWindTimeline *_obj = (PhysicsConstraintWindTimeline *) obj; + return _obj->getCurveValue(time); +} + +float spine_physics_constraint_wind_timeline_get_relative_value(spine_physics_constraint_wind_timeline obj, float time, float alpha, spine_mix_blend blend, float current, float setup) { + if (!obj) return 0; + PhysicsConstraintWindTimeline *_obj = (PhysicsConstraintWindTimeline *) obj; + return _obj->getRelativeValue(time, alpha, blend, current, setup); +} + +float spine_physics_constraint_wind_timeline_get_absolute_value(spine_physics_constraint_wind_timeline obj, float time, float alpha, spine_mix_blend blend, float current, float setup) { + if (!obj) return 0; + PhysicsConstraintWindTimeline *_obj = (PhysicsConstraintWindTimeline *) obj; + return _obj->getAbsoluteValue(time, alpha, blend, current, setup); +} + +float spine_physics_constraint_wind_timeline_get_absolute_value(spine_physics_constraint_wind_timeline obj, float time, float alpha, spine_mix_blend blend, float current, float setup, float value) { + if (!obj) return 0; + PhysicsConstraintWindTimeline *_obj = (PhysicsConstraintWindTimeline *) obj; + return _obj->getAbsoluteValue(time, alpha, blend, current, setup, value); +} + +float spine_physics_constraint_wind_timeline_get_scale_value(spine_physics_constraint_wind_timeline obj, float time, float alpha, spine_mix_blend blend, spine_mix_direction direction, float current, float setup) { + if (!obj) return 0; + PhysicsConstraintWindTimeline *_obj = (PhysicsConstraintWindTimeline *) obj; + return _obj->getScaleValue(time, alpha, blend, direction, current, setup); +} + +void spine_physics_constraint_wind_timeline_set_linear(spine_physics_constraint_wind_timeline obj, spine_size_t value) { + if (!obj) return; + PhysicsConstraintWindTimeline *_obj = (PhysicsConstraintWindTimeline *) obj; + _obj->setLinear(value); +} + +void spine_physics_constraint_wind_timeline_set_stepped(spine_physics_constraint_wind_timeline obj, spine_size_t value) { + if (!obj) return; + PhysicsConstraintWindTimeline *_obj = (PhysicsConstraintWindTimeline *) obj; + _obj->setStepped(value); +} + +void spine_physics_constraint_wind_timeline_set_bezier(spine_physics_constraint_wind_timeline obj, spine_size_t bezier, spine_size_t frame, float value, float time1, float value1, float cx1, float cy1, float cx2, float cy2, float time2, float value2) { + if (!obj) return ; + PhysicsConstraintWindTimeline *_obj = (PhysicsConstraintWindTimeline *) obj; + _obj->setBezier(bezier, frame, value, time1, value1, cx1, cy1, cx2, cy2, time2, value2); +} + +float spine_physics_constraint_wind_timeline_get_bezier_value(spine_physics_constraint_wind_timeline obj, float time, spine_size_t frame, spine_size_t valueOffset, spine_size_t i) { + if (!obj) return 0; + PhysicsConstraintWindTimeline *_obj = (PhysicsConstraintWindTimeline *) obj; + return _obj->getBezierValue(time, frame, valueOffset, i); +} + +void * spine_physics_constraint_wind_timeline_get_curves(spine_physics_constraint_wind_timeline obj) { + if (!obj) return nullptr; + PhysicsConstraintWindTimeline *_obj = (PhysicsConstraintWindTimeline *) obj; + return _obj->getCurves(); +} + +int32_t spine_physics_constraint_wind_timeline_get_num_curves(spine_physics_constraint_wind_timeline obj) { + if (!obj) return 0; + PhysicsConstraintWindTimeline *_obj = (PhysicsConstraintWindTimeline *) obj; + return (int32_t) _obj->getCurves().size(); +} + +spine_float *spine_physics_constraint_wind_timeline_get_curves(spine_physics_constraint_wind_timeline obj) { + if (!obj) return nullptr; + PhysicsConstraintWindTimeline *_obj = (PhysicsConstraintWindTimeline *) obj; + return (spine_float *) _obj->getCurves().buffer(); +} + +spine_size_t spine_physics_constraint_wind_timeline_get_frame_entries(spine_physics_constraint_wind_timeline obj) { + if (!obj) return nullptr; + PhysicsConstraintWindTimeline *_obj = (PhysicsConstraintWindTimeline *) obj; + return _obj->getFrameEntries(); +} + +spine_size_t spine_physics_constraint_wind_timeline_get_frame_count(spine_physics_constraint_wind_timeline obj) { + if (!obj) return nullptr; + PhysicsConstraintWindTimeline *_obj = (PhysicsConstraintWindTimeline *) obj; + return _obj->getFrameCount(); +} + +void * spine_physics_constraint_wind_timeline_get_frames(spine_physics_constraint_wind_timeline obj) { + if (!obj) return nullptr; + PhysicsConstraintWindTimeline *_obj = (PhysicsConstraintWindTimeline *) obj; + return _obj->getFrames(); +} + +int32_t spine_physics_constraint_wind_timeline_get_num_frames(spine_physics_constraint_wind_timeline obj) { + if (!obj) return 0; + PhysicsConstraintWindTimeline *_obj = (PhysicsConstraintWindTimeline *) obj; + return (int32_t) _obj->getFrames().size(); +} + +spine_float *spine_physics_constraint_wind_timeline_get_frames(spine_physics_constraint_wind_timeline obj) { + if (!obj) return nullptr; + PhysicsConstraintWindTimeline *_obj = (PhysicsConstraintWindTimeline *) obj; + return (spine_float *) _obj->getFrames().buffer(); +} + +float spine_physics_constraint_wind_timeline_get_duration(spine_physics_constraint_wind_timeline obj) { + if (!obj) return 0; + PhysicsConstraintWindTimeline *_obj = (PhysicsConstraintWindTimeline *) obj; + return _obj->getDuration(); +} + +void * spine_physics_constraint_wind_timeline_get_property_ids(spine_physics_constraint_wind_timeline obj) { + if (!obj) return nullptr; + PhysicsConstraintWindTimeline *_obj = (PhysicsConstraintWindTimeline *) obj; + return _obj->getPropertyIds(); +} + +int32_t spine_physics_constraint_wind_timeline_get_num_property_ids(spine_physics_constraint_wind_timeline obj) { + if (!obj) return 0; + PhysicsConstraintWindTimeline *_obj = (PhysicsConstraintWindTimeline *) obj; + return (int32_t) _obj->getPropertyIds().size(); +} + +spine_property_id *spine_physics_constraint_wind_timeline_get_property_ids(spine_physics_constraint_wind_timeline obj) { + if (!obj) return nullptr; + PhysicsConstraintWindTimeline *_obj = (PhysicsConstraintWindTimeline *) obj; + return (spine_property_id *) _obj->getPropertyIds().buffer(); +} + +int32_t spine_physics_constraint_wind_timeline_get_constraint_index(spine_physics_constraint_wind_timeline obj) { + if (!obj) return 0; + PhysicsConstraintWindTimeline *_obj = (PhysicsConstraintWindTimeline *) obj; + return _obj->getConstraintIndex(); +} + +void spine_physics_constraint_wind_timeline_set_constraint_index(spine_physics_constraint_wind_timeline obj, int32_t value) { + if (!obj) return; + PhysicsConstraintWindTimeline *_obj = (PhysicsConstraintWindTimeline *) obj; + _obj->setConstraintIndex(value); +} diff --git a/spine-c-new/src/generated/physics_constraint_wind_timeline.h b/spine-c-new/src/generated/physics_constraint_wind_timeline.h new file mode 100644 index 000000000..b9b7618c8 --- /dev/null +++ b/spine-c-new/src/generated/physics_constraint_wind_timeline.h @@ -0,0 +1,74 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#ifndef SPINE_C_PHYSICSCONSTRAINTWINDTIMELINE_H +#define SPINE_C_PHYSICSCONSTRAINTWINDTIMELINE_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include "../custom.h" + +SPINE_OPAQUE_TYPE(spine_physics_constraint_wind_timeline) + +SPINE_C_EXPORT spine_physics_constraint_wind_timeline spine_physics_constraint_wind_timeline_create(spine_size_t frameCount, spine_size_t bezierCount, int32_t physicsConstraintIndex); +SPINE_C_EXPORT void spine_physics_constraint_wind_timeline_dispose(spine_physics_constraint_wind_timeline obj); +SPINE_C_EXPORT spine_rtti spine_physics_constraint_wind_timeline_get_rtti(spine_physics_constraint_wind_timeline obj); +SPINE_C_EXPORT void spine_physics_constraint_wind_timeline_apply(spine_physics_constraint_wind_timeline obj, spine_skeleton skeleton, float lastTime, float time, void * pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction, spine_bool appliedPose); +SPINE_C_EXPORT void spine_physics_constraint_wind_timeline_set_frame(spine_physics_constraint_wind_timeline obj, spine_size_t frame, float time, float value); +SPINE_C_EXPORT float spine_physics_constraint_wind_timeline_get_curve_value(spine_physics_constraint_wind_timeline obj, float time); +SPINE_C_EXPORT float spine_physics_constraint_wind_timeline_get_relative_value(spine_physics_constraint_wind_timeline obj, float time, float alpha, spine_mix_blend blend, float current, float setup); +SPINE_C_EXPORT float spine_physics_constraint_wind_timeline_get_absolute_value(spine_physics_constraint_wind_timeline obj, float time, float alpha, spine_mix_blend blend, float current, float setup); +SPINE_C_EXPORT float spine_physics_constraint_wind_timeline_get_absolute_value(spine_physics_constraint_wind_timeline obj, float time, float alpha, spine_mix_blend blend, float current, float setup, float value); +SPINE_C_EXPORT float spine_physics_constraint_wind_timeline_get_scale_value(spine_physics_constraint_wind_timeline obj, float time, float alpha, spine_mix_blend blend, spine_mix_direction direction, float current, float setup); +SPINE_C_EXPORT void spine_physics_constraint_wind_timeline_set_linear(spine_physics_constraint_wind_timeline obj, spine_size_t value); +SPINE_C_EXPORT void spine_physics_constraint_wind_timeline_set_stepped(spine_physics_constraint_wind_timeline obj, spine_size_t value); +SPINE_C_EXPORT void spine_physics_constraint_wind_timeline_set_bezier(spine_physics_constraint_wind_timeline obj, spine_size_t bezier, spine_size_t frame, float value, float time1, float value1, float cx1, float cy1, float cx2, float cy2, float time2, float value2); +SPINE_C_EXPORT float spine_physics_constraint_wind_timeline_get_bezier_value(spine_physics_constraint_wind_timeline obj, float time, spine_size_t frame, spine_size_t valueOffset, spine_size_t i); +SPINE_C_EXPORT void * spine_physics_constraint_wind_timeline_get_curves(spine_physics_constraint_wind_timeline obj); +SPINE_C_EXPORT int32_t spine_physics_constraint_wind_timeline_get_num_curves(spine_physics_constraint_wind_timeline obj); +SPINE_C_EXPORT spine_float *spine_physics_constraint_wind_timeline_get_curves(spine_physics_constraint_wind_timeline obj); +SPINE_C_EXPORT spine_size_t spine_physics_constraint_wind_timeline_get_frame_entries(spine_physics_constraint_wind_timeline obj); +SPINE_C_EXPORT spine_size_t spine_physics_constraint_wind_timeline_get_frame_count(spine_physics_constraint_wind_timeline obj); +SPINE_C_EXPORT void * spine_physics_constraint_wind_timeline_get_frames(spine_physics_constraint_wind_timeline obj); +SPINE_C_EXPORT int32_t spine_physics_constraint_wind_timeline_get_num_frames(spine_physics_constraint_wind_timeline obj); +SPINE_C_EXPORT spine_float *spine_physics_constraint_wind_timeline_get_frames(spine_physics_constraint_wind_timeline obj); +SPINE_C_EXPORT float spine_physics_constraint_wind_timeline_get_duration(spine_physics_constraint_wind_timeline obj); +SPINE_C_EXPORT void * spine_physics_constraint_wind_timeline_get_property_ids(spine_physics_constraint_wind_timeline obj); +SPINE_C_EXPORT int32_t spine_physics_constraint_wind_timeline_get_num_property_ids(spine_physics_constraint_wind_timeline obj); +SPINE_C_EXPORT spine_property_id *spine_physics_constraint_wind_timeline_get_property_ids(spine_physics_constraint_wind_timeline obj); +SPINE_C_EXPORT int32_t spine_physics_constraint_wind_timeline_get_constraint_index(spine_physics_constraint_wind_timeline obj); +SPINE_C_EXPORT void spine_physics_constraint_wind_timeline_set_constraint_index(spine_physics_constraint_wind_timeline obj, int32_t value); + +#ifdef __cplusplus +} +#endif + +#endif // SPINE_C_PHYSICSCONSTRAINTWINDTIMELINE_H \ No newline at end of file diff --git a/spine-c-new/src/generated/point_attachment.cpp b/spine-c-new/src/generated/point_attachment.cpp new file mode 100644 index 000000000..e980dbcd3 --- /dev/null +++ b/spine-c-new/src/generated/point_attachment.cpp @@ -0,0 +1,133 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#include "point_attachment.h" +#include + +using namespace spine; + +spine_point_attachment spine_point_attachment_create(const utf8 * name) { + PointAttachment *obj = new (__FILE__, __LINE__) PointAttachment(String(name)); + return (spine_point_attachment) obj; +} + +void spine_point_attachment_dispose(spine_point_attachment obj) { + if (!obj) return; + delete (PointAttachment *) obj; +} + +spine_rtti spine_point_attachment_get_rtti(spine_point_attachment obj) { + if (!obj) return nullptr; + PointAttachment *_obj = (PointAttachment *) obj; + return (spine_rtti) &_obj->getRTTI(); +} + +float spine_point_attachment_get_x(spine_point_attachment obj) { + if (!obj) return 0; + PointAttachment *_obj = (PointAttachment *) obj; + return _obj->getX(); +} + +void spine_point_attachment_set_x(spine_point_attachment obj, float value) { + if (!obj) return; + PointAttachment *_obj = (PointAttachment *) obj; + _obj->setX(value); +} + +float spine_point_attachment_get_y(spine_point_attachment obj) { + if (!obj) return 0; + PointAttachment *_obj = (PointAttachment *) obj; + return _obj->getY(); +} + +void spine_point_attachment_set_y(spine_point_attachment obj, float value) { + if (!obj) return; + PointAttachment *_obj = (PointAttachment *) obj; + _obj->setY(value); +} + +float spine_point_attachment_get_rotation(spine_point_attachment obj) { + if (!obj) return 0; + PointAttachment *_obj = (PointAttachment *) obj; + return _obj->getRotation(); +} + +void spine_point_attachment_set_rotation(spine_point_attachment obj, float value) { + if (!obj) return; + PointAttachment *_obj = (PointAttachment *) obj; + _obj->setRotation(value); +} + +spine_color spine_point_attachment_get_color(spine_point_attachment obj) { + if (!obj) return nullptr; + PointAttachment *_obj = (PointAttachment *) obj; + return (spine_color) &_obj->getColor(); +} + +void spine_point_attachment_compute_world_position(spine_point_attachment obj, spine_bone_pose bone, float ox, float oy) { + if (!obj) return ; + PointAttachment *_obj = (PointAttachment *) obj; + _obj->computeWorldPosition(bone, ox, oy); +} + +float spine_point_attachment_compute_world_rotation(spine_point_attachment obj, spine_bone_pose bone) { + if (!obj) return 0; + PointAttachment *_obj = (PointAttachment *) obj; + return _obj->computeWorldRotation(bone); +} + +spine_attachment spine_point_attachment_copy(spine_point_attachment obj) { + if (!obj) return nullptr; + PointAttachment *_obj = (PointAttachment *) obj; + return (spine_attachment) _obj->copy(); +} + +const utf8 * spine_point_attachment_get_name(spine_point_attachment obj) { + if (!obj) return nullptr; + PointAttachment *_obj = (PointAttachment *) obj; + return (const utf8 *) _obj->getName().buffer(); +} + +int32_t spine_point_attachment_get_ref_count(spine_point_attachment obj) { + if (!obj) return 0; + PointAttachment *_obj = (PointAttachment *) obj; + return _obj->getRefCount(); +} + +void spine_point_attachment_reference(spine_point_attachment obj) { + if (!obj) return ; + PointAttachment *_obj = (PointAttachment *) obj; + _obj->reference(); +} + +void spine_point_attachment_dereference(spine_point_attachment obj) { + if (!obj) return ; + PointAttachment *_obj = (PointAttachment *) obj; + _obj->dereference(); +} diff --git a/spine-c-new/src/generated/point_attachment.h b/spine-c-new/src/generated/point_attachment.h new file mode 100644 index 000000000..32ef68c5d --- /dev/null +++ b/spine-c-new/src/generated/point_attachment.h @@ -0,0 +1,63 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#ifndef SPINE_C_POINTATTACHMENT_H +#define SPINE_C_POINTATTACHMENT_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include "../custom.h" + +SPINE_OPAQUE_TYPE(spine_point_attachment) + +SPINE_C_EXPORT spine_point_attachment spine_point_attachment_create(const utf8 * name); +SPINE_C_EXPORT void spine_point_attachment_dispose(spine_point_attachment obj); +SPINE_C_EXPORT spine_rtti spine_point_attachment_get_rtti(spine_point_attachment obj); +SPINE_C_EXPORT float spine_point_attachment_get_x(spine_point_attachment obj); +SPINE_C_EXPORT void spine_point_attachment_set_x(spine_point_attachment obj, float value); +SPINE_C_EXPORT float spine_point_attachment_get_y(spine_point_attachment obj); +SPINE_C_EXPORT void spine_point_attachment_set_y(spine_point_attachment obj, float value); +SPINE_C_EXPORT float spine_point_attachment_get_rotation(spine_point_attachment obj); +SPINE_C_EXPORT void spine_point_attachment_set_rotation(spine_point_attachment obj, float value); +SPINE_C_EXPORT spine_color spine_point_attachment_get_color(spine_point_attachment obj); +SPINE_C_EXPORT void spine_point_attachment_compute_world_position(spine_point_attachment obj, spine_bone_pose bone, float ox, float oy); +SPINE_C_EXPORT float spine_point_attachment_compute_world_rotation(spine_point_attachment obj, spine_bone_pose bone); +SPINE_C_EXPORT spine_attachment spine_point_attachment_copy(spine_point_attachment obj); +SPINE_C_EXPORT const utf8 * spine_point_attachment_get_name(spine_point_attachment obj); +SPINE_C_EXPORT int32_t spine_point_attachment_get_ref_count(spine_point_attachment obj); +SPINE_C_EXPORT void spine_point_attachment_reference(spine_point_attachment obj); +SPINE_C_EXPORT void spine_point_attachment_dereference(spine_point_attachment obj); + +#ifdef __cplusplus +} +#endif + +#endif // SPINE_C_POINTATTACHMENT_H \ No newline at end of file diff --git a/spine-c-new/src/generated/polygon.cpp b/spine-c-new/src/generated/polygon.cpp new file mode 100644 index 000000000..b3acf250d --- /dev/null +++ b/spine-c-new/src/generated/polygon.cpp @@ -0,0 +1,43 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#include "polygon.h" +#include + +using namespace spine; + +spine_polygon spine_polygon_create(void) { + Polygon *obj = new (__FILE__, __LINE__) Polygon(); + return (spine_polygon) obj; +} + +void spine_polygon_dispose(spine_polygon obj) { + if (!obj) return; + delete (Polygon *) obj; +} diff --git a/spine-c-new/src/generated/polygon.h b/spine-c-new/src/generated/polygon.h new file mode 100644 index 000000000..f26d19e5e --- /dev/null +++ b/spine-c-new/src/generated/polygon.h @@ -0,0 +1,48 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#ifndef SPINE_C_POLYGON_H +#define SPINE_C_POLYGON_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include "../custom.h" + +SPINE_OPAQUE_TYPE(spine_polygon) + +SPINE_C_EXPORT spine_polygon spine_polygon_create(void); +SPINE_C_EXPORT void spine_polygon_dispose(spine_polygon obj); + +#ifdef __cplusplus +} +#endif + +#endif // SPINE_C_POLYGON_H \ No newline at end of file diff --git a/spine-c-new/src/generated/pose.cpp b/spine-c-new/src/generated/pose.cpp new file mode 100644 index 000000000..34a346b9f --- /dev/null +++ b/spine-c-new/src/generated/pose.cpp @@ -0,0 +1,58 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#include "pose.h" +#include + +using namespace spine; + +spine_pose spine_pose_create(void) { + Pose *obj = new (__FILE__, __LINE__) Pose(); + return (spine_pose) obj; +} + +void spine_pose_dispose(spine_pose obj) { + if (!obj) return; + delete (Pose *) obj; +} + +void spine_pose_set(spine_pose obj, spine_p value) { + if (!obj) return; + Pose *_obj = (Pose *) obj; + _obj->set(value); +} + +spine_bool spine_pose_is_type(spine_pose obj, spine_pose_type type) { + if (!obj) return 0; + Pose *_obj = (Pose *) obj; + + switch (type) { + } + return 0; +} diff --git a/spine-c-new/src/generated/pose.h b/spine-c-new/src/generated/pose.h new file mode 100644 index 000000000..8b6495144 --- /dev/null +++ b/spine-c-new/src/generated/pose.h @@ -0,0 +1,54 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#ifndef SPINE_C_POSE_H +#define SPINE_C_POSE_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include "../custom.h" + +SPINE_OPAQUE_TYPE(spine_pose) + +SPINE_C_EXPORT spine_pose spine_pose_create(void); +SPINE_C_EXPORT void spine_pose_dispose(spine_pose obj); +SPINE_C_EXPORT void spine_pose_set(spine_pose obj, spine_p value); + +typedef enum spine_pose_type { +} spine_pose_type; + +SPINE_C_EXPORT spine_bool spine_pose_is_type(spine_pose obj, spine_pose_type type); + +#ifdef __cplusplus +} +#endif + +#endif // SPINE_C_POSE_H \ No newline at end of file diff --git a/spine-c-new/src/generated/posed.cpp b/spine-c-new/src/generated/posed.cpp new file mode 100644 index 000000000..172478ba8 --- /dev/null +++ b/spine-c-new/src/generated/posed.cpp @@ -0,0 +1,91 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#include "posed.h" +#include + +using namespace spine; + +spine_posed spine_posed_create(void) { + Posed *obj = new (__FILE__, __LINE__) Posed(); + return (spine_posed) obj; +} + +void spine_posed_dispose(spine_posed obj) { + if (!obj) return; + delete (Posed *) obj; +} + +void spine_posed_setup_pose(spine_posed obj) { + if (!obj) return ; + Posed *_obj = (Posed *) obj; + _obj->setupPose(); +} + +void spine_posed_pose(spine_posed obj) { + if (!obj) return ; + Posed *_obj = (Posed *) obj; + _obj->pose(); +} + +void spine_posed_constrained(spine_posed obj) { + if (!obj) return ; + Posed *_obj = (Posed *) obj; + _obj->constrained(); +} + +void spine_posed_reset_constrained(spine_posed obj) { + if (!obj) return ; + Posed *_obj = (Posed *) obj; + _obj->resetConstrained(); +} + +spine_bool spine_posed_is_pose_equal_to_applied(spine_posed obj) { + if (!obj) return 0; + Posed *_obj = (Posed *) obj; + return _obj->isPoseEqualToApplied(); +} + +spine_bool spine_posed_is_type(spine_posed obj, spine_posed_type type) { + if (!obj) return 0; + Posed *_obj = (Posed *) obj; + + switch (type) { + case SPINE_TYPE_POSED_POSED_GENERIC: + return _obj->getRTTI().instanceOf(PosedGeneric::rtti); + } + return 0; +} + +spine_posed_generic spine_posed_as_posed_generic(spine_posed obj) { + if (!obj) return nullptr; + Posed *_obj = (Posed *) obj; + if (!_obj->getRTTI().instanceOf(PosedGeneric::rtti)) return nullptr; + return (spine_posed_generic) obj; +} diff --git a/spine-c-new/src/generated/posed.h b/spine-c-new/src/generated/posed.h new file mode 100644 index 000000000..7993be61b --- /dev/null +++ b/spine-c-new/src/generated/posed.h @@ -0,0 +1,62 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#ifndef SPINE_C_POSED_H +#define SPINE_C_POSED_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include "../custom.h" + +SPINE_OPAQUE_TYPE(spine_posed) + +SPINE_C_EXPORT spine_posed spine_posed_create(void); +SPINE_C_EXPORT void spine_posed_dispose(spine_posed obj); +SPINE_C_EXPORT void spine_posed_setup_pose(spine_posed obj); +SPINE_C_EXPORT void spine_posed_pose(spine_posed obj); +SPINE_C_EXPORT void spine_posed_constrained(spine_posed obj); +SPINE_C_EXPORT void spine_posed_reset_constrained(spine_posed obj); +SPINE_C_EXPORT spine_bool spine_posed_is_pose_equal_to_applied(spine_posed obj); +struct spine_posed_generic_wrapper; +typedef struct spine_posed_generic_wrapper *spine_posed_generic; + +typedef enum spine_posed_type { + SPINE_TYPE_POSED_POSED_GENERIC = 0 +} spine_posed_type; + +SPINE_C_EXPORT spine_bool spine_posed_is_type(spine_posed obj, spine_posed_type type); +SPINE_C_EXPORT spine_posed_generic spine_posed_as_posed_generic(spine_posed obj); + +#ifdef __cplusplus +} +#endif + +#endif // SPINE_C_POSED_H \ No newline at end of file diff --git a/spine-c-new/src/generated/posed_active.cpp b/spine-c-new/src/generated/posed_active.cpp new file mode 100644 index 000000000..04785e222 --- /dev/null +++ b/spine-c-new/src/generated/posed_active.cpp @@ -0,0 +1,55 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#include "posed_active.h" +#include + +using namespace spine; + +spine_posed_active spine_posed_active_create(void) { + PosedActive *obj = new (__FILE__, __LINE__) PosedActive(); + return (spine_posed_active) obj; +} + +void spine_posed_active_dispose(spine_posed_active obj) { + if (!obj) return; + delete (PosedActive *) obj; +} + +spine_bool spine_posed_active_is_active(spine_posed_active obj) { + if (!obj) return 0; + PosedActive *_obj = (PosedActive *) obj; + return _obj->isActive(); +} + +void spine_posed_active_set_active(spine_posed_active obj, spine_bool value) { + if (!obj) return; + PosedActive *_obj = (PosedActive *) obj; + _obj->setActive(value); +} diff --git a/spine-c-new/src/generated/posed_active.h b/spine-c-new/src/generated/posed_active.h new file mode 100644 index 000000000..c369e568e --- /dev/null +++ b/spine-c-new/src/generated/posed_active.h @@ -0,0 +1,50 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#ifndef SPINE_C_POSEDACTIVE_H +#define SPINE_C_POSEDACTIVE_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include "../custom.h" + +SPINE_OPAQUE_TYPE(spine_posed_active) + +SPINE_C_EXPORT spine_posed_active spine_posed_active_create(void); +SPINE_C_EXPORT void spine_posed_active_dispose(spine_posed_active obj); +SPINE_C_EXPORT spine_bool spine_posed_active_is_active(spine_posed_active obj); +SPINE_C_EXPORT void spine_posed_active_set_active(spine_posed_active obj, spine_bool value); + +#ifdef __cplusplus +} +#endif + +#endif // SPINE_C_POSEDACTIVE_H \ No newline at end of file diff --git a/spine-c-new/src/generated/posed_data.cpp b/spine-c-new/src/generated/posed_data.cpp new file mode 100644 index 000000000..2b31097b8 --- /dev/null +++ b/spine-c-new/src/generated/posed_data.cpp @@ -0,0 +1,79 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#include "posed_data.h" +#include + +using namespace spine; + +spine_posed_data spine_posed_data_create(spine_spine::string name) { + PosedData *obj = new (__FILE__, __LINE__) PosedData(name); + return (spine_posed_data) obj; +} + +void spine_posed_data_dispose(spine_posed_data obj) { + if (!obj) return; + delete (PosedData *) obj; +} + +spine_spine::string spine_posed_data_get_name(spine_posed_data obj) { + if (!obj) return nullptr; + PosedData *_obj = (PosedData *) obj; + return _obj->getName(); +} + +spine_bool spine_posed_data_is_skin_required(spine_posed_data obj) { + if (!obj) return 0; + PosedData *_obj = (PosedData *) obj; + return _obj->isSkinRequired(); +} + +void spine_posed_data_set_skin_required(spine_posed_data obj, spine_bool value) { + if (!obj) return; + PosedData *_obj = (PosedData *) obj; + _obj->setSkinRequired(value); +} + +spine_bool spine_posed_data_is_type(spine_posed_data obj, spine_posed_data_type type) { + if (!obj) return 0; + PosedData *_obj = (PosedData *) obj; + + switch (type) { + case SPINE_TYPE_POSED_DATA_POSED_DATA_GENERIC: + return _obj->getRTTI().instanceOf(PosedDataGeneric::rtti); + } + return 0; +} + +spine_posed_data_generic spine_posed_data_as_posed_data_generic(spine_posed_data obj) { + if (!obj) return nullptr; + PosedData *_obj = (PosedData *) obj; + if (!_obj->getRTTI().instanceOf(PosedDataGeneric::rtti)) return nullptr; + return (spine_posed_data_generic) obj; +} diff --git a/spine-c-new/src/generated/posed_data.h b/spine-c-new/src/generated/posed_data.h new file mode 100644 index 000000000..e49298613 --- /dev/null +++ b/spine-c-new/src/generated/posed_data.h @@ -0,0 +1,60 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#ifndef SPINE_C_POSEDDATA_H +#define SPINE_C_POSEDDATA_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include "../custom.h" + +SPINE_OPAQUE_TYPE(spine_posed_data) + +SPINE_C_EXPORT spine_posed_data spine_posed_data_create(spine_spine::string name); +SPINE_C_EXPORT void spine_posed_data_dispose(spine_posed_data obj); +SPINE_C_EXPORT spine_spine::string spine_posed_data_get_name(spine_posed_data obj); +SPINE_C_EXPORT spine_bool spine_posed_data_is_skin_required(spine_posed_data obj); +SPINE_C_EXPORT void spine_posed_data_set_skin_required(spine_posed_data obj, spine_bool value); +struct spine_posed_data_generic_wrapper; +typedef struct spine_posed_data_generic_wrapper *spine_posed_data_generic; + +typedef enum spine_posed_data_type { + SPINE_TYPE_POSED_DATA_POSED_DATA_GENERIC = 0 +} spine_posed_data_type; + +SPINE_C_EXPORT spine_bool spine_posed_data_is_type(spine_posed_data obj, spine_posed_data_type type); +SPINE_C_EXPORT spine_posed_data_generic spine_posed_data_as_posed_data_generic(spine_posed_data obj); + +#ifdef __cplusplus +} +#endif + +#endif // SPINE_C_POSEDDATA_H \ No newline at end of file diff --git a/spine-c-new/src/generated/posed_data_generic.cpp b/spine-c-new/src/generated/posed_data_generic.cpp new file mode 100644 index 000000000..c4d5ca248 --- /dev/null +++ b/spine-c-new/src/generated/posed_data_generic.cpp @@ -0,0 +1,73 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#include "posed_data_generic.h" +#include + +using namespace spine; + +spine_posed_data_generic spine_posed_data_generic_create(spine_spine::string name) { + PosedDataGeneric *obj = new (__FILE__, __LINE__) PosedDataGeneric(name); + return (spine_posed_data_generic) obj; +} + +void spine_posed_data_generic_dispose(spine_posed_data_generic obj) { + if (!obj) return; + delete (PosedDataGeneric *) obj; +} + +spine_p spine_posed_data_generic_get_setup_pose(spine_posed_data_generic obj) { + if (!obj) return nullptr; + PosedDataGeneric *_obj = (PosedDataGeneric *) obj; + return _obj->getSetupPose(); +} + +spine_p spine_posed_data_generic_get_setup_pose(spine_posed_data_generic obj) { + if (!obj) return nullptr; + PosedDataGeneric *_obj = (PosedDataGeneric *) obj; + return _obj->getSetupPose(); +} + +spine_spine::string spine_posed_data_generic_get_name(spine_posed_data_generic obj) { + if (!obj) return nullptr; + PosedDataGeneric *_obj = (PosedDataGeneric *) obj; + return _obj->getName(); +} + +spine_bool spine_posed_data_generic_is_skin_required(spine_posed_data_generic obj) { + if (!obj) return 0; + PosedDataGeneric *_obj = (PosedDataGeneric *) obj; + return _obj->isSkinRequired(); +} + +void spine_posed_data_generic_set_skin_required(spine_posed_data_generic obj, spine_bool value) { + if (!obj) return; + PosedDataGeneric *_obj = (PosedDataGeneric *) obj; + _obj->setSkinRequired(value); +} diff --git a/spine-c-new/src/generated/posed_data_generic.h b/spine-c-new/src/generated/posed_data_generic.h new file mode 100644 index 000000000..c1dffc5dc --- /dev/null +++ b/spine-c-new/src/generated/posed_data_generic.h @@ -0,0 +1,53 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#ifndef SPINE_C_POSEDDATAGENERIC_H +#define SPINE_C_POSEDDATAGENERIC_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include "../custom.h" + +SPINE_OPAQUE_TYPE(spine_posed_data_generic) + +SPINE_C_EXPORT spine_posed_data_generic spine_posed_data_generic_create(spine_spine::string name); +SPINE_C_EXPORT void spine_posed_data_generic_dispose(spine_posed_data_generic obj); +SPINE_C_EXPORT spine_p spine_posed_data_generic_get_setup_pose(spine_posed_data_generic obj); +SPINE_C_EXPORT spine_p spine_posed_data_generic_get_setup_pose(spine_posed_data_generic obj); +SPINE_C_EXPORT spine_spine::string spine_posed_data_generic_get_name(spine_posed_data_generic obj); +SPINE_C_EXPORT spine_bool spine_posed_data_generic_is_skin_required(spine_posed_data_generic obj); +SPINE_C_EXPORT void spine_posed_data_generic_set_skin_required(spine_posed_data_generic obj, spine_bool value); + +#ifdef __cplusplus +} +#endif + +#endif // SPINE_C_POSEDDATAGENERIC_H \ No newline at end of file diff --git a/spine-c-new/src/generated/posed_generic.cpp b/spine-c-new/src/generated/posed_generic.cpp new file mode 100644 index 000000000..78cdd0d5a --- /dev/null +++ b/spine-c-new/src/generated/posed_generic.cpp @@ -0,0 +1,91 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#include "posed_generic.h" +#include + +using namespace spine; + +spine_posed_generic spine_posed_generic_create(spine_d data) { + PosedGeneric *obj = new (__FILE__, __LINE__) PosedGeneric(data); + return (spine_posed_generic) obj; +} + +void spine_posed_generic_dispose(spine_posed_generic obj) { + if (!obj) return; + delete (PosedGeneric *) obj; +} + +void spine_posed_generic_setup_pose(spine_posed_generic obj) { + if (!obj) return ; + PosedGeneric *_obj = (PosedGeneric *) obj; + _obj->setupPose(); +} + +spine_d spine_posed_generic_get_data(spine_posed_generic obj) { + if (!obj) return nullptr; + PosedGeneric *_obj = (PosedGeneric *) obj; + return _obj->getData(); +} + +spine_p spine_posed_generic_get_pose(spine_posed_generic obj) { + if (!obj) return nullptr; + PosedGeneric *_obj = (PosedGeneric *) obj; + return _obj->getPose(); +} + +spine_a spine_posed_generic_get_applied_pose(spine_posed_generic obj) { + if (!obj) return nullptr; + PosedGeneric *_obj = (PosedGeneric *) obj; + return _obj->getAppliedPose(); +} + +void spine_posed_generic_reset_constrained(spine_posed_generic obj) { + if (!obj) return ; + PosedGeneric *_obj = (PosedGeneric *) obj; + _obj->resetConstrained(); +} + +void spine_posed_generic_pose(spine_posed_generic obj) { + if (!obj) return ; + PosedGeneric *_obj = (PosedGeneric *) obj; + _obj->pose(); +} + +void spine_posed_generic_constrained(spine_posed_generic obj) { + if (!obj) return ; + PosedGeneric *_obj = (PosedGeneric *) obj; + _obj->constrained(); +} + +spine_bool spine_posed_generic_is_pose_equal_to_applied(spine_posed_generic obj) { + if (!obj) return 0; + PosedGeneric *_obj = (PosedGeneric *) obj; + return _obj->isPoseEqualToApplied(); +} diff --git a/spine-c-new/src/generated/posed_generic.h b/spine-c-new/src/generated/posed_generic.h new file mode 100644 index 000000000..51c530297 --- /dev/null +++ b/spine-c-new/src/generated/posed_generic.h @@ -0,0 +1,56 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#ifndef SPINE_C_POSEDGENERIC_H +#define SPINE_C_POSEDGENERIC_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include "../custom.h" + +SPINE_OPAQUE_TYPE(spine_posed_generic) + +SPINE_C_EXPORT spine_posed_generic spine_posed_generic_create(spine_d data); +SPINE_C_EXPORT void spine_posed_generic_dispose(spine_posed_generic obj); +SPINE_C_EXPORT void spine_posed_generic_setup_pose(spine_posed_generic obj); +SPINE_C_EXPORT spine_d spine_posed_generic_get_data(spine_posed_generic obj); +SPINE_C_EXPORT spine_p spine_posed_generic_get_pose(spine_posed_generic obj); +SPINE_C_EXPORT spine_a spine_posed_generic_get_applied_pose(spine_posed_generic obj); +SPINE_C_EXPORT void spine_posed_generic_reset_constrained(spine_posed_generic obj); +SPINE_C_EXPORT void spine_posed_generic_pose(spine_posed_generic obj); +SPINE_C_EXPORT void spine_posed_generic_constrained(spine_posed_generic obj); +SPINE_C_EXPORT spine_bool spine_posed_generic_is_pose_equal_to_applied(spine_posed_generic obj); + +#ifdef __cplusplus +} +#endif + +#endif // SPINE_C_POSEDGENERIC_H \ No newline at end of file diff --git a/spine-c-new/src/generated/position_mode.h b/spine-c-new/src/generated/position_mode.h new file mode 100644 index 000000000..59fd48ed5 --- /dev/null +++ b/spine-c-new/src/generated/position_mode.h @@ -0,0 +1,48 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#ifndef SPINE_C_POSITIONMODE_H +#define SPINE_C_POSITIONMODE_H + +#include "../../custom.h" + +#ifdef __cplusplus +extern "C" { +#endif + +typedef enum spine_position_mode { + SPINE_POSITION_MODE_POSITION_MODE_FIXED = 0, + SPINE_POSITION_MODE_POSITION_MODE_PERCENT +} spine_position_mode; + +#ifdef __cplusplus +} +#endif + +#endif // SPINE_C_POSITIONMODE_H \ No newline at end of file diff --git a/spine-c-new/src/generated/pow_interpolation.cpp b/spine-c-new/src/generated/pow_interpolation.cpp new file mode 100644 index 000000000..75db044cb --- /dev/null +++ b/spine-c-new/src/generated/pow_interpolation.cpp @@ -0,0 +1,55 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#include "pow_interpolation.h" +#include + +using namespace spine; + +spine_pow_interpolation spine_pow_interpolation_create(int32_t power) { + PowInterpolation *obj = new (__FILE__, __LINE__) PowInterpolation(power); + return (spine_pow_interpolation) obj; +} + +void spine_pow_interpolation_dispose(spine_pow_interpolation obj) { + if (!obj) return; + delete (PowInterpolation *) obj; +} + +float spine_pow_interpolation_apply(spine_pow_interpolation obj, float a) { + if (!obj) return 0; + PowInterpolation *_obj = (PowInterpolation *) obj; + return _obj->apply(a); +} + +float spine_pow_interpolation_interpolate(spine_pow_interpolation obj, float start, float end, float a) { + if (!obj) return 0; + PowInterpolation *_obj = (PowInterpolation *) obj; + return _obj->interpolate(start, end, a); +} diff --git a/spine-c-new/src/generated/pow_interpolation.h b/spine-c-new/src/generated/pow_interpolation.h new file mode 100644 index 000000000..b127d8622 --- /dev/null +++ b/spine-c-new/src/generated/pow_interpolation.h @@ -0,0 +1,50 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#ifndef SPINE_C_POWINTERPOLATION_H +#define SPINE_C_POWINTERPOLATION_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include "../custom.h" + +SPINE_OPAQUE_TYPE(spine_pow_interpolation) + +SPINE_C_EXPORT spine_pow_interpolation spine_pow_interpolation_create(int32_t power); +SPINE_C_EXPORT void spine_pow_interpolation_dispose(spine_pow_interpolation obj); +SPINE_C_EXPORT float spine_pow_interpolation_apply(spine_pow_interpolation obj, float a); +SPINE_C_EXPORT float spine_pow_interpolation_interpolate(spine_pow_interpolation obj, float start, float end, float a); + +#ifdef __cplusplus +} +#endif + +#endif // SPINE_C_POWINTERPOLATION_H \ No newline at end of file diff --git a/spine-c-new/src/generated/pow_out_interpolation.cpp b/spine-c-new/src/generated/pow_out_interpolation.cpp new file mode 100644 index 000000000..0dcdf2321 --- /dev/null +++ b/spine-c-new/src/generated/pow_out_interpolation.cpp @@ -0,0 +1,55 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#include "pow_out_interpolation.h" +#include + +using namespace spine; + +spine_pow_out_interpolation spine_pow_out_interpolation_create(int32_t power) { + PowOutInterpolation *obj = new (__FILE__, __LINE__) PowOutInterpolation(power); + return (spine_pow_out_interpolation) obj; +} + +void spine_pow_out_interpolation_dispose(spine_pow_out_interpolation obj) { + if (!obj) return; + delete (PowOutInterpolation *) obj; +} + +float spine_pow_out_interpolation_apply(spine_pow_out_interpolation obj, float a) { + if (!obj) return 0; + PowOutInterpolation *_obj = (PowOutInterpolation *) obj; + return _obj->apply(a); +} + +float spine_pow_out_interpolation_interpolate(spine_pow_out_interpolation obj, float start, float end, float a) { + if (!obj) return 0; + PowOutInterpolation *_obj = (PowOutInterpolation *) obj; + return _obj->interpolate(start, end, a); +} diff --git a/spine-c-new/src/generated/pow_out_interpolation.h b/spine-c-new/src/generated/pow_out_interpolation.h new file mode 100644 index 000000000..73513946b --- /dev/null +++ b/spine-c-new/src/generated/pow_out_interpolation.h @@ -0,0 +1,50 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#ifndef SPINE_C_POWOUTINTERPOLATION_H +#define SPINE_C_POWOUTINTERPOLATION_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include "../custom.h" + +SPINE_OPAQUE_TYPE(spine_pow_out_interpolation) + +SPINE_C_EXPORT spine_pow_out_interpolation spine_pow_out_interpolation_create(int32_t power); +SPINE_C_EXPORT void spine_pow_out_interpolation_dispose(spine_pow_out_interpolation obj); +SPINE_C_EXPORT float spine_pow_out_interpolation_apply(spine_pow_out_interpolation obj, float a); +SPINE_C_EXPORT float spine_pow_out_interpolation_interpolate(spine_pow_out_interpolation obj, float start, float end, float a); + +#ifdef __cplusplus +} +#endif + +#endif // SPINE_C_POWOUTINTERPOLATION_H \ No newline at end of file diff --git a/spine-c-new/src/generated/property.h b/spine-c-new/src/generated/property.h new file mode 100644 index 000000000..035906825 --- /dev/null +++ b/spine-c-new/src/generated/property.h @@ -0,0 +1,77 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#ifndef SPINE_C_PROPERTY_H +#define SPINE_C_PROPERTY_H + +#include "../../custom.h" + +#ifdef __cplusplus +extern "C" { +#endif + +typedef enum spine_property { + SPINE_PROPERTY_PROPERTY_ROTATE = 1 << 0, + SPINE_PROPERTY_PROPERTY_X = 1 << 1, + SPINE_PROPERTY_PROPERTY_Y = 1 << 2, + SPINE_PROPERTY_PROPERTY_SCALE_X = 1 << 3, + SPINE_PROPERTY_PROPERTY_SCALE_Y = 1 << 4, + SPINE_PROPERTY_PROPERTY_SHEAR_X = 1 << 5, + SPINE_PROPERTY_PROPERTY_SHEAR_Y = 1 << 6, + SPINE_PROPERTY_PROPERTY_INHERIT = 1 << 7, + SPINE_PROPERTY_PROPERTY_RGB = 1 << 8, + SPINE_PROPERTY_PROPERTY_ALPHA = 1 << 9, + SPINE_PROPERTY_PROPERTY_RGB2 = 1 << 10, + SPINE_PROPERTY_PROPERTY_ATTACHMENT = 1 << 11, + SPINE_PROPERTY_PROPERTY_DEFORM = 1 << 12, + SPINE_PROPERTY_PROPERTY_EVENT = 1 << 13, + SPINE_PROPERTY_PROPERTY_DRAW_ORDER = 1 << 14, + SPINE_PROPERTY_PROPERTY_IK_CONSTRAINT = 1 << 15, + SPINE_PROPERTY_PROPERTY_TRANSFORM_CONSTRAINT = 1 << 16, + SPINE_PROPERTY_PROPERTY_PATH_CONSTRAINT_POSITION = 1 << 17, + SPINE_PROPERTY_PROPERTY_PATH_CONSTRAINT_SPACING = 1 << 18, + SPINE_PROPERTY_PROPERTY_PATH_CONSTRAINT_MIX = 1 << 19, + SPINE_PROPERTY_PROPERTY_PHYSICS_CONSTRAINT_INERTIA = 1 << 20, + SPINE_PROPERTY_PROPERTY_PHYSICS_CONSTRAINT_STRENGTH = 1 << 21, + SPINE_PROPERTY_PROPERTY_PHYSICS_CONSTRAINT_DAMPING = 1 << 22, + SPINE_PROPERTY_PROPERTY_PHYSICS_CONSTRAINT_MASS = 1 << 23, + SPINE_PROPERTY_PROPERTY_PHYSICS_CONSTRAINT_WIND = 1 << 24, + SPINE_PROPERTY_PROPERTY_PHYSICS_CONSTRAINT_GRAVITY = 1 << 25, + SPINE_PROPERTY_PROPERTY_PHYSICS_CONSTRAINT_MIX = 1 << 26, + SPINE_PROPERTY_PROPERTY_PHYSICS_CONSTRAINT_RESET = 1 << 27, + SPINE_PROPERTY_PROPERTY_SEQUENCE = 1 << 28, + SPINE_PROPERTY_PROPERTY_SLIDER_TIME = 1 << 29, + SPINE_PROPERTY_PROPERTY_SLIDER_MIX = 1 << 30 +} spine_property; + +#ifdef __cplusplus +} +#endif + +#endif // SPINE_C_PROPERTY_H \ No newline at end of file diff --git a/spine-c-new/src/generated/region_attachment.cpp b/spine-c-new/src/generated/region_attachment.cpp new file mode 100644 index 000000000..483026560 --- /dev/null +++ b/spine-c-new/src/generated/region_attachment.cpp @@ -0,0 +1,259 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#include "region_attachment.h" +#include + +using namespace spine; + +spine_region_attachment spine_region_attachment_create(const utf8 * name) { + RegionAttachment *obj = new (__FILE__, __LINE__) RegionAttachment(String(name)); + return (spine_region_attachment) obj; +} + +void spine_region_attachment_dispose(spine_region_attachment obj) { + if (!obj) return; + delete (RegionAttachment *) obj; +} + +spine_rtti spine_region_attachment_get_rtti(spine_region_attachment obj) { + if (!obj) return nullptr; + RegionAttachment *_obj = (RegionAttachment *) obj; + return (spine_rtti) &_obj->getRTTI(); +} + +void spine_region_attachment_update_region(spine_region_attachment obj) { + if (!obj) return ; + RegionAttachment *_obj = (RegionAttachment *) obj; + _obj->updateRegion(); +} + +void spine_region_attachment_compute_world_vertices(spine_region_attachment obj, spine_slot slot, spine_float worldVertices, spine_size_t offset, spine_size_t stride) { + if (!obj) return ; + RegionAttachment *_obj = (RegionAttachment *) obj; + _obj->computeWorldVertices(slot, (float *) worldVertices, offset, stride); +} + +void spine_region_attachment_compute_world_vertices(spine_region_attachment obj, spine_slot slot, void * worldVertices, spine_size_t offset, spine_size_t stride) { + if (!obj) return ; + RegionAttachment *_obj = (RegionAttachment *) obj; + _obj->computeWorldVertices(slot, (Vector &) worldVertices, offset, stride); +} + +float spine_region_attachment_get_x(spine_region_attachment obj) { + if (!obj) return 0; + RegionAttachment *_obj = (RegionAttachment *) obj; + return _obj->getX(); +} + +void spine_region_attachment_set_x(spine_region_attachment obj, float value) { + if (!obj) return; + RegionAttachment *_obj = (RegionAttachment *) obj; + _obj->setX(value); +} + +float spine_region_attachment_get_y(spine_region_attachment obj) { + if (!obj) return 0; + RegionAttachment *_obj = (RegionAttachment *) obj; + return _obj->getY(); +} + +void spine_region_attachment_set_y(spine_region_attachment obj, float value) { + if (!obj) return; + RegionAttachment *_obj = (RegionAttachment *) obj; + _obj->setY(value); +} + +float spine_region_attachment_get_rotation(spine_region_attachment obj) { + if (!obj) return 0; + RegionAttachment *_obj = (RegionAttachment *) obj; + return _obj->getRotation(); +} + +void spine_region_attachment_set_rotation(spine_region_attachment obj, float value) { + if (!obj) return; + RegionAttachment *_obj = (RegionAttachment *) obj; + _obj->setRotation(value); +} + +float spine_region_attachment_get_scale_x(spine_region_attachment obj) { + if (!obj) return 0; + RegionAttachment *_obj = (RegionAttachment *) obj; + return _obj->getScaleX(); +} + +void spine_region_attachment_set_scale_x(spine_region_attachment obj, float value) { + if (!obj) return; + RegionAttachment *_obj = (RegionAttachment *) obj; + _obj->setScaleX(value); +} + +float spine_region_attachment_get_scale_y(spine_region_attachment obj) { + if (!obj) return 0; + RegionAttachment *_obj = (RegionAttachment *) obj; + return _obj->getScaleY(); +} + +void spine_region_attachment_set_scale_y(spine_region_attachment obj, float value) { + if (!obj) return; + RegionAttachment *_obj = (RegionAttachment *) obj; + _obj->setScaleY(value); +} + +float spine_region_attachment_get_width(spine_region_attachment obj) { + if (!obj) return 0; + RegionAttachment *_obj = (RegionAttachment *) obj; + return _obj->getWidth(); +} + +void spine_region_attachment_set_width(spine_region_attachment obj, float value) { + if (!obj) return; + RegionAttachment *_obj = (RegionAttachment *) obj; + _obj->setWidth(value); +} + +float spine_region_attachment_get_height(spine_region_attachment obj) { + if (!obj) return 0; + RegionAttachment *_obj = (RegionAttachment *) obj; + return _obj->getHeight(); +} + +void spine_region_attachment_set_height(spine_region_attachment obj, float value) { + if (!obj) return; + RegionAttachment *_obj = (RegionAttachment *) obj; + _obj->setHeight(value); +} + +spine_color spine_region_attachment_get_color(spine_region_attachment obj) { + if (!obj) return nullptr; + RegionAttachment *_obj = (RegionAttachment *) obj; + return (spine_color) &_obj->getColor(); +} + +const utf8 * spine_region_attachment_get_path(spine_region_attachment obj) { + if (!obj) return nullptr; + RegionAttachment *_obj = (RegionAttachment *) obj; + return (const utf8 *) _obj->getPath().buffer(); +} + +void spine_region_attachment_set_path(spine_region_attachment obj, const utf8 * value) { + if (!obj) return; + RegionAttachment *_obj = (RegionAttachment *) obj; + _obj->setPath(String(value)); +} + +spine_texture_region spine_region_attachment_get_region(spine_region_attachment obj) { + if (!obj) return nullptr; + RegionAttachment *_obj = (RegionAttachment *) obj; + return (spine_texture_region) _obj->getRegion(); +} + +void spine_region_attachment_set_region(spine_region_attachment obj, spine_texture_region value) { + if (!obj) return; + RegionAttachment *_obj = (RegionAttachment *) obj; + _obj->setRegion((TextureRegion *) value); +} + +spine_sequence spine_region_attachment_get_sequence(spine_region_attachment obj) { + if (!obj) return nullptr; + RegionAttachment *_obj = (RegionAttachment *) obj; + return (spine_sequence) _obj->getSequence(); +} + +void spine_region_attachment_set_sequence(spine_region_attachment obj, spine_sequence value) { + if (!obj) return; + RegionAttachment *_obj = (RegionAttachment *) obj; + _obj->setSequence((Sequence *) value); +} + +void * spine_region_attachment_get_offset(spine_region_attachment obj) { + if (!obj) return nullptr; + RegionAttachment *_obj = (RegionAttachment *) obj; + return _obj->getOffset(); +} + +int32_t spine_region_attachment_get_num_offset(spine_region_attachment obj) { + if (!obj) return 0; + RegionAttachment *_obj = (RegionAttachment *) obj; + return (int32_t) _obj->getOffset().size(); +} + +spine_float *spine_region_attachment_get_offset(spine_region_attachment obj) { + if (!obj) return nullptr; + RegionAttachment *_obj = (RegionAttachment *) obj; + return (spine_float *) _obj->getOffset().buffer(); +} + +void * spine_region_attachment_get_u_vs(spine_region_attachment obj) { + if (!obj) return nullptr; + RegionAttachment *_obj = (RegionAttachment *) obj; + return _obj->getUVs(); +} + +int32_t spine_region_attachment_get_num_u_vs(spine_region_attachment obj) { + if (!obj) return 0; + RegionAttachment *_obj = (RegionAttachment *) obj; + return (int32_t) _obj->getUVs().size(); +} + +spine_float *spine_region_attachment_get_u_vs(spine_region_attachment obj) { + if (!obj) return nullptr; + RegionAttachment *_obj = (RegionAttachment *) obj; + return (spine_float *) _obj->getUVs().buffer(); +} + +spine_attachment spine_region_attachment_copy(spine_region_attachment obj) { + if (!obj) return nullptr; + RegionAttachment *_obj = (RegionAttachment *) obj; + return (spine_attachment) _obj->copy(); +} + +const utf8 * spine_region_attachment_get_name(spine_region_attachment obj) { + if (!obj) return nullptr; + RegionAttachment *_obj = (RegionAttachment *) obj; + return (const utf8 *) _obj->getName().buffer(); +} + +int32_t spine_region_attachment_get_ref_count(spine_region_attachment obj) { + if (!obj) return 0; + RegionAttachment *_obj = (RegionAttachment *) obj; + return _obj->getRefCount(); +} + +void spine_region_attachment_reference(spine_region_attachment obj) { + if (!obj) return ; + RegionAttachment *_obj = (RegionAttachment *) obj; + _obj->reference(); +} + +void spine_region_attachment_dereference(spine_region_attachment obj) { + if (!obj) return ; + RegionAttachment *_obj = (RegionAttachment *) obj; + _obj->dereference(); +} diff --git a/spine-c-new/src/generated/region_attachment.h b/spine-c-new/src/generated/region_attachment.h new file mode 100644 index 000000000..a3664701c --- /dev/null +++ b/spine-c-new/src/generated/region_attachment.h @@ -0,0 +1,84 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#ifndef SPINE_C_REGIONATTACHMENT_H +#define SPINE_C_REGIONATTACHMENT_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include "../custom.h" + +SPINE_OPAQUE_TYPE(spine_region_attachment) + +SPINE_C_EXPORT spine_region_attachment spine_region_attachment_create(const utf8 * name); +SPINE_C_EXPORT void spine_region_attachment_dispose(spine_region_attachment obj); +SPINE_C_EXPORT spine_rtti spine_region_attachment_get_rtti(spine_region_attachment obj); +SPINE_C_EXPORT void spine_region_attachment_update_region(spine_region_attachment obj); +SPINE_C_EXPORT void spine_region_attachment_compute_world_vertices(spine_region_attachment obj, spine_slot slot, spine_float worldVertices, spine_size_t offset, spine_size_t stride); +SPINE_C_EXPORT void spine_region_attachment_compute_world_vertices(spine_region_attachment obj, spine_slot slot, void * worldVertices, spine_size_t offset, spine_size_t stride); +SPINE_C_EXPORT float spine_region_attachment_get_x(spine_region_attachment obj); +SPINE_C_EXPORT void spine_region_attachment_set_x(spine_region_attachment obj, float value); +SPINE_C_EXPORT float spine_region_attachment_get_y(spine_region_attachment obj); +SPINE_C_EXPORT void spine_region_attachment_set_y(spine_region_attachment obj, float value); +SPINE_C_EXPORT float spine_region_attachment_get_rotation(spine_region_attachment obj); +SPINE_C_EXPORT void spine_region_attachment_set_rotation(spine_region_attachment obj, float value); +SPINE_C_EXPORT float spine_region_attachment_get_scale_x(spine_region_attachment obj); +SPINE_C_EXPORT void spine_region_attachment_set_scale_x(spine_region_attachment obj, float value); +SPINE_C_EXPORT float spine_region_attachment_get_scale_y(spine_region_attachment obj); +SPINE_C_EXPORT void spine_region_attachment_set_scale_y(spine_region_attachment obj, float value); +SPINE_C_EXPORT float spine_region_attachment_get_width(spine_region_attachment obj); +SPINE_C_EXPORT void spine_region_attachment_set_width(spine_region_attachment obj, float value); +SPINE_C_EXPORT float spine_region_attachment_get_height(spine_region_attachment obj); +SPINE_C_EXPORT void spine_region_attachment_set_height(spine_region_attachment obj, float value); +SPINE_C_EXPORT spine_color spine_region_attachment_get_color(spine_region_attachment obj); +SPINE_C_EXPORT const utf8 * spine_region_attachment_get_path(spine_region_attachment obj); +SPINE_C_EXPORT void spine_region_attachment_set_path(spine_region_attachment obj, const utf8 * value); +SPINE_C_EXPORT spine_texture_region spine_region_attachment_get_region(spine_region_attachment obj); +SPINE_C_EXPORT void spine_region_attachment_set_region(spine_region_attachment obj, spine_texture_region value); +SPINE_C_EXPORT spine_sequence spine_region_attachment_get_sequence(spine_region_attachment obj); +SPINE_C_EXPORT void spine_region_attachment_set_sequence(spine_region_attachment obj, spine_sequence value); +SPINE_C_EXPORT void * spine_region_attachment_get_offset(spine_region_attachment obj); +SPINE_C_EXPORT int32_t spine_region_attachment_get_num_offset(spine_region_attachment obj); +SPINE_C_EXPORT spine_float *spine_region_attachment_get_offset(spine_region_attachment obj); +SPINE_C_EXPORT void * spine_region_attachment_get_u_vs(spine_region_attachment obj); +SPINE_C_EXPORT int32_t spine_region_attachment_get_num_u_vs(spine_region_attachment obj); +SPINE_C_EXPORT spine_float *spine_region_attachment_get_u_vs(spine_region_attachment obj); +SPINE_C_EXPORT spine_attachment spine_region_attachment_copy(spine_region_attachment obj); +SPINE_C_EXPORT const utf8 * spine_region_attachment_get_name(spine_region_attachment obj); +SPINE_C_EXPORT int32_t spine_region_attachment_get_ref_count(spine_region_attachment obj); +SPINE_C_EXPORT void spine_region_attachment_reference(spine_region_attachment obj); +SPINE_C_EXPORT void spine_region_attachment_dereference(spine_region_attachment obj); + +#ifdef __cplusplus +} +#endif + +#endif // SPINE_C_REGIONATTACHMENT_H \ No newline at end of file diff --git a/spine-c-new/src/generated/render_command.cpp b/spine-c-new/src/generated/render_command.cpp new file mode 100644 index 000000000..b9f918c9c --- /dev/null +++ b/spine-c-new/src/generated/render_command.cpp @@ -0,0 +1,38 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#include "render_command.h" +#include + +using namespace spine; + +void spine_render_command_dispose(spine_render_command obj) { + if (!obj) return; + delete (RenderCommand *) obj; +} diff --git a/spine-c-new/src/generated/render_command.h b/spine-c-new/src/generated/render_command.h new file mode 100644 index 000000000..e8b5e1b08 --- /dev/null +++ b/spine-c-new/src/generated/render_command.h @@ -0,0 +1,47 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#ifndef SPINE_C_RENDERCOMMAND_H +#define SPINE_C_RENDERCOMMAND_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include "../custom.h" + +SPINE_OPAQUE_TYPE(spine_render_command) + +SPINE_C_EXPORT void spine_render_command_dispose(spine_render_command obj); + +#ifdef __cplusplus +} +#endif + +#endif // SPINE_C_RENDERCOMMAND_H \ No newline at end of file diff --git a/spine-c-new/src/generated/rgb2_timeline.cpp b/spine-c-new/src/generated/rgb2_timeline.cpp new file mode 100644 index 000000000..a06ea1c77 --- /dev/null +++ b/spine-c-new/src/generated/rgb2_timeline.cpp @@ -0,0 +1,61 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#include "rgb2_timeline.h" +#include + +using namespace spine; + +spine_rgb2_timeline spine_rgb2_timeline_create(spine_size_t frameCount, spine_size_t bezierCount, int32_t slotIndex) { + RGB2Timeline *obj = new (__FILE__, __LINE__) RGB2Timeline(frameCount, bezierCount, slotIndex); + return (spine_rgb2_timeline) obj; +} + +void spine_rgb2_timeline_dispose(spine_rgb2_timeline obj) { + if (!obj) return; + delete (RGB2Timeline *) obj; +} + +spine_rtti spine_rgb2_timeline_get_rtti(spine_rgb2_timeline obj) { + if (!obj) return nullptr; + RGB2Timeline *_obj = (RGB2Timeline *) obj; + return (spine_rtti) &_obj->getRTTI(); +} + +void spine_rgb2_timeline_set_frame(spine_rgb2_timeline obj, int32_t frame, float time, float r, float g, float b, float r2, float g2, float b2) { + if (!obj) return ; + RGB2Timeline *_obj = (RGB2Timeline *) obj; + _obj->setFrame(frame, time, r, g, b, r2, g2, b2); +} + +void spine_rgb2_timeline_apply(spine_rgb2_timeline obj, spine_skeleton skeleton, float lastTime, float time, void * pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction, spine_bool appliedPose) { + if (!obj) return ; + RGB2Timeline *_obj = (RGB2Timeline *) obj; + _obj->apply(skeleton, lastTime, time, (Vector *) pEvents, alpha, blend, direction, appliedPose); +} diff --git a/spine-c-new/src/generated/rgb2_timeline.h b/spine-c-new/src/generated/rgb2_timeline.h new file mode 100644 index 000000000..37d3312ca --- /dev/null +++ b/spine-c-new/src/generated/rgb2_timeline.h @@ -0,0 +1,51 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#ifndef SPINE_C_RGB2TIMELINE_H +#define SPINE_C_RGB2TIMELINE_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include "../custom.h" + +SPINE_OPAQUE_TYPE(spine_rgb2_timeline) + +SPINE_C_EXPORT spine_rgb2_timeline spine_rgb2_timeline_create(spine_size_t frameCount, spine_size_t bezierCount, int32_t slotIndex); +SPINE_C_EXPORT void spine_rgb2_timeline_dispose(spine_rgb2_timeline obj); +SPINE_C_EXPORT spine_rtti spine_rgb2_timeline_get_rtti(spine_rgb2_timeline obj); +SPINE_C_EXPORT void spine_rgb2_timeline_set_frame(spine_rgb2_timeline obj, int32_t frame, float time, float r, float g, float b, float r2, float g2, float b2); +SPINE_C_EXPORT void spine_rgb2_timeline_apply(spine_rgb2_timeline obj, spine_skeleton skeleton, float lastTime, float time, void * pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction, spine_bool appliedPose); + +#ifdef __cplusplus +} +#endif + +#endif // SPINE_C_RGB2TIMELINE_H \ No newline at end of file diff --git a/spine-c-new/src/generated/rgb_timeline.cpp b/spine-c-new/src/generated/rgb_timeline.cpp new file mode 100644 index 000000000..e7307c705 --- /dev/null +++ b/spine-c-new/src/generated/rgb_timeline.cpp @@ -0,0 +1,61 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#include "rgb_timeline.h" +#include + +using namespace spine; + +spine_rgb_timeline spine_rgb_timeline_create(spine_size_t frameCount, spine_size_t bezierCount, int32_t slotIndex) { + RGBTimeline *obj = new (__FILE__, __LINE__) RGBTimeline(frameCount, bezierCount, slotIndex); + return (spine_rgb_timeline) obj; +} + +void spine_rgb_timeline_dispose(spine_rgb_timeline obj) { + if (!obj) return; + delete (RGBTimeline *) obj; +} + +spine_rtti spine_rgb_timeline_get_rtti(spine_rgb_timeline obj) { + if (!obj) return nullptr; + RGBTimeline *_obj = (RGBTimeline *) obj; + return (spine_rtti) &_obj->getRTTI(); +} + +void spine_rgb_timeline_set_frame(spine_rgb_timeline obj, int32_t frame, float time, float r, float g, float b) { + if (!obj) return ; + RGBTimeline *_obj = (RGBTimeline *) obj; + _obj->setFrame(frame, time, r, g, b); +} + +void spine_rgb_timeline_apply(spine_rgb_timeline obj, spine_skeleton skeleton, float lastTime, float time, void * pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction, spine_bool appliedPose) { + if (!obj) return ; + RGBTimeline *_obj = (RGBTimeline *) obj; + _obj->apply(skeleton, lastTime, time, (Vector *) pEvents, alpha, blend, direction, appliedPose); +} diff --git a/spine-c-new/src/generated/rgb_timeline.h b/spine-c-new/src/generated/rgb_timeline.h new file mode 100644 index 000000000..b8ab5946e --- /dev/null +++ b/spine-c-new/src/generated/rgb_timeline.h @@ -0,0 +1,51 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#ifndef SPINE_C_RGBTIMELINE_H +#define SPINE_C_RGBTIMELINE_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include "../custom.h" + +SPINE_OPAQUE_TYPE(spine_rgb_timeline) + +SPINE_C_EXPORT spine_rgb_timeline spine_rgb_timeline_create(spine_size_t frameCount, spine_size_t bezierCount, int32_t slotIndex); +SPINE_C_EXPORT void spine_rgb_timeline_dispose(spine_rgb_timeline obj); +SPINE_C_EXPORT spine_rtti spine_rgb_timeline_get_rtti(spine_rgb_timeline obj); +SPINE_C_EXPORT void spine_rgb_timeline_set_frame(spine_rgb_timeline obj, int32_t frame, float time, float r, float g, float b); +SPINE_C_EXPORT void spine_rgb_timeline_apply(spine_rgb_timeline obj, spine_skeleton skeleton, float lastTime, float time, void * pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction, spine_bool appliedPose); + +#ifdef __cplusplus +} +#endif + +#endif // SPINE_C_RGBTIMELINE_H \ No newline at end of file diff --git a/spine-c-new/src/generated/rgba2_timeline.cpp b/spine-c-new/src/generated/rgba2_timeline.cpp new file mode 100644 index 000000000..0ea35bf9c --- /dev/null +++ b/spine-c-new/src/generated/rgba2_timeline.cpp @@ -0,0 +1,61 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#include "rgba2_timeline.h" +#include + +using namespace spine; + +spine_rgba2_timeline spine_rgba2_timeline_create(spine_size_t frameCount, spine_size_t bezierCount, int32_t slotIndex) { + RGBA2Timeline *obj = new (__FILE__, __LINE__) RGBA2Timeline(frameCount, bezierCount, slotIndex); + return (spine_rgba2_timeline) obj; +} + +void spine_rgba2_timeline_dispose(spine_rgba2_timeline obj) { + if (!obj) return; + delete (RGBA2Timeline *) obj; +} + +spine_rtti spine_rgba2_timeline_get_rtti(spine_rgba2_timeline obj) { + if (!obj) return nullptr; + RGBA2Timeline *_obj = (RGBA2Timeline *) obj; + return (spine_rtti) &_obj->getRTTI(); +} + +void spine_rgba2_timeline_set_frame(spine_rgba2_timeline obj, int32_t frame, float time, float r, float g, float b, float a, float r2, float g2, float b2) { + if (!obj) return ; + RGBA2Timeline *_obj = (RGBA2Timeline *) obj; + _obj->setFrame(frame, time, r, g, b, a, r2, g2, b2); +} + +void spine_rgba2_timeline_apply(spine_rgba2_timeline obj, spine_skeleton skeleton, float lastTime, float time, void * pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction, spine_bool appliedPose) { + if (!obj) return ; + RGBA2Timeline *_obj = (RGBA2Timeline *) obj; + _obj->apply(skeleton, lastTime, time, (Vector *) pEvents, alpha, blend, direction, appliedPose); +} diff --git a/spine-c-new/src/generated/rgba2_timeline.h b/spine-c-new/src/generated/rgba2_timeline.h new file mode 100644 index 000000000..7d5a0ce96 --- /dev/null +++ b/spine-c-new/src/generated/rgba2_timeline.h @@ -0,0 +1,51 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#ifndef SPINE_C_RGBA2TIMELINE_H +#define SPINE_C_RGBA2TIMELINE_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include "../custom.h" + +SPINE_OPAQUE_TYPE(spine_rgba2_timeline) + +SPINE_C_EXPORT spine_rgba2_timeline spine_rgba2_timeline_create(spine_size_t frameCount, spine_size_t bezierCount, int32_t slotIndex); +SPINE_C_EXPORT void spine_rgba2_timeline_dispose(spine_rgba2_timeline obj); +SPINE_C_EXPORT spine_rtti spine_rgba2_timeline_get_rtti(spine_rgba2_timeline obj); +SPINE_C_EXPORT void spine_rgba2_timeline_set_frame(spine_rgba2_timeline obj, int32_t frame, float time, float r, float g, float b, float a, float r2, float g2, float b2); +SPINE_C_EXPORT void spine_rgba2_timeline_apply(spine_rgba2_timeline obj, spine_skeleton skeleton, float lastTime, float time, void * pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction, spine_bool appliedPose); + +#ifdef __cplusplus +} +#endif + +#endif // SPINE_C_RGBA2TIMELINE_H \ No newline at end of file diff --git a/spine-c-new/src/generated/rgba_timeline.cpp b/spine-c-new/src/generated/rgba_timeline.cpp new file mode 100644 index 000000000..4383e5b75 --- /dev/null +++ b/spine-c-new/src/generated/rgba_timeline.cpp @@ -0,0 +1,61 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#include "rgba_timeline.h" +#include + +using namespace spine; + +spine_rgba_timeline spine_rgba_timeline_create(spine_size_t frameCount, spine_size_t bezierCount, int32_t slotIndex) { + RGBATimeline *obj = new (__FILE__, __LINE__) RGBATimeline(frameCount, bezierCount, slotIndex); + return (spine_rgba_timeline) obj; +} + +void spine_rgba_timeline_dispose(spine_rgba_timeline obj) { + if (!obj) return; + delete (RGBATimeline *) obj; +} + +spine_rtti spine_rgba_timeline_get_rtti(spine_rgba_timeline obj) { + if (!obj) return nullptr; + RGBATimeline *_obj = (RGBATimeline *) obj; + return (spine_rtti) &_obj->getRTTI(); +} + +void spine_rgba_timeline_set_frame(spine_rgba_timeline obj, int32_t frame, float time, float r, float g, float b, float a) { + if (!obj) return ; + RGBATimeline *_obj = (RGBATimeline *) obj; + _obj->setFrame(frame, time, r, g, b, a); +} + +void spine_rgba_timeline_apply(spine_rgba_timeline obj, spine_skeleton skeleton, float lastTime, float time, void * pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction, spine_bool appliedPose) { + if (!obj) return ; + RGBATimeline *_obj = (RGBATimeline *) obj; + _obj->apply(skeleton, lastTime, time, (Vector *) pEvents, alpha, blend, direction, appliedPose); +} diff --git a/spine-c-new/src/generated/rgba_timeline.h b/spine-c-new/src/generated/rgba_timeline.h new file mode 100644 index 000000000..a94b340f5 --- /dev/null +++ b/spine-c-new/src/generated/rgba_timeline.h @@ -0,0 +1,51 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#ifndef SPINE_C_RGBATIMELINE_H +#define SPINE_C_RGBATIMELINE_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include "../custom.h" + +SPINE_OPAQUE_TYPE(spine_rgba_timeline) + +SPINE_C_EXPORT spine_rgba_timeline spine_rgba_timeline_create(spine_size_t frameCount, spine_size_t bezierCount, int32_t slotIndex); +SPINE_C_EXPORT void spine_rgba_timeline_dispose(spine_rgba_timeline obj); +SPINE_C_EXPORT spine_rtti spine_rgba_timeline_get_rtti(spine_rgba_timeline obj); +SPINE_C_EXPORT void spine_rgba_timeline_set_frame(spine_rgba_timeline obj, int32_t frame, float time, float r, float g, float b, float a); +SPINE_C_EXPORT void spine_rgba_timeline_apply(spine_rgba_timeline obj, spine_skeleton skeleton, float lastTime, float time, void * pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction, spine_bool appliedPose); + +#ifdef __cplusplus +} +#endif + +#endif // SPINE_C_RGBATIMELINE_H \ No newline at end of file diff --git a/spine-c-new/src/generated/rotate_mode.h b/spine-c-new/src/generated/rotate_mode.h new file mode 100644 index 000000000..9588361dd --- /dev/null +++ b/spine-c-new/src/generated/rotate_mode.h @@ -0,0 +1,49 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#ifndef SPINE_C_ROTATEMODE_H +#define SPINE_C_ROTATEMODE_H + +#include "../../custom.h" + +#ifdef __cplusplus +extern "C" { +#endif + +typedef enum spine_rotate_mode { + SPINE_ROTATE_MODE_ROTATE_MODE_TANGENT = 0, + SPINE_ROTATE_MODE_ROTATE_MODE_CHAIN, + SPINE_ROTATE_MODE_ROTATE_MODE_CHAIN_SCALE +} spine_rotate_mode; + +#ifdef __cplusplus +} +#endif + +#endif // SPINE_C_ROTATEMODE_H \ No newline at end of file diff --git a/spine-c-new/src/generated/rotate_timeline.cpp b/spine-c-new/src/generated/rotate_timeline.cpp new file mode 100644 index 000000000..a5625fe73 --- /dev/null +++ b/spine-c-new/src/generated/rotate_timeline.cpp @@ -0,0 +1,103 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#include "rotate_timeline.h" +#include + +using namespace spine; + +spine_rotate_timeline spine_rotate_timeline_create(spine_size_t frameCount, spine_size_t bezierCount, int32_t boneIndex) { + RotateTimeline *obj = new (__FILE__, __LINE__) RotateTimeline(frameCount, bezierCount, boneIndex); + return (spine_rotate_timeline) obj; +} + +void spine_rotate_timeline_dispose(spine_rotate_timeline obj) { + if (!obj) return; + delete (RotateTimeline *) obj; +} + +spine_rtti spine_rotate_timeline_get_rtti(spine_rotate_timeline obj) { + if (!obj) return nullptr; + RotateTimeline *_obj = (RotateTimeline *) obj; + return (spine_rtti) &_obj->getRTTI(); +} + +void spine_rotate_timeline_apply(spine_rotate_timeline obj, spine_skeleton skeleton, float lastTime, float time, void * pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction, spine_bool appliedPose) { + if (!obj) return ; + RotateTimeline *_obj = (RotateTimeline *) obj; + _obj->apply(skeleton, lastTime, time, (Vector *) pEvents, alpha, blend, direction, appliedPose); +} + +void spine_rotate_timeline_set_frame(spine_rotate_timeline obj, spine_size_t frame, float time, float value) { + if (!obj) return ; + RotateTimeline *_obj = (RotateTimeline *) obj; + _obj->setFrame(frame, time, value); +} + +float spine_rotate_timeline_get_curve_value(spine_rotate_timeline obj, float time) { + if (!obj) return 0; + RotateTimeline *_obj = (RotateTimeline *) obj; + return _obj->getCurveValue(time); +} + +float spine_rotate_timeline_get_relative_value(spine_rotate_timeline obj, float time, float alpha, spine_mix_blend blend, float current, float setup) { + if (!obj) return 0; + RotateTimeline *_obj = (RotateTimeline *) obj; + return _obj->getRelativeValue(time, alpha, blend, current, setup); +} + +float spine_rotate_timeline_get_absolute_value(spine_rotate_timeline obj, float time, float alpha, spine_mix_blend blend, float current, float setup) { + if (!obj) return 0; + RotateTimeline *_obj = (RotateTimeline *) obj; + return _obj->getAbsoluteValue(time, alpha, blend, current, setup); +} + +float spine_rotate_timeline_get_absolute_value(spine_rotate_timeline obj, float time, float alpha, spine_mix_blend blend, float current, float setup, float value) { + if (!obj) return 0; + RotateTimeline *_obj = (RotateTimeline *) obj; + return _obj->getAbsoluteValue(time, alpha, blend, current, setup, value); +} + +float spine_rotate_timeline_get_scale_value(spine_rotate_timeline obj, float time, float alpha, spine_mix_blend blend, spine_mix_direction direction, float current, float setup) { + if (!obj) return 0; + RotateTimeline *_obj = (RotateTimeline *) obj; + return _obj->getScaleValue(time, alpha, blend, direction, current, setup); +} + +int32_t spine_rotate_timeline_get_bone_index(spine_rotate_timeline obj) { + if (!obj) return 0; + RotateTimeline *_obj = (RotateTimeline *) obj; + return _obj->getBoneIndex(); +} + +void spine_rotate_timeline_set_bone_index(spine_rotate_timeline obj, int32_t value) { + if (!obj) return; + RotateTimeline *_obj = (RotateTimeline *) obj; + _obj->setBoneIndex(value); +} diff --git a/spine-c-new/src/generated/rotate_timeline.h b/spine-c-new/src/generated/rotate_timeline.h new file mode 100644 index 000000000..d00116467 --- /dev/null +++ b/spine-c-new/src/generated/rotate_timeline.h @@ -0,0 +1,58 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#ifndef SPINE_C_ROTATETIMELINE_H +#define SPINE_C_ROTATETIMELINE_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include "../custom.h" + +SPINE_OPAQUE_TYPE(spine_rotate_timeline) + +SPINE_C_EXPORT spine_rotate_timeline spine_rotate_timeline_create(spine_size_t frameCount, spine_size_t bezierCount, int32_t boneIndex); +SPINE_C_EXPORT void spine_rotate_timeline_dispose(spine_rotate_timeline obj); +SPINE_C_EXPORT spine_rtti spine_rotate_timeline_get_rtti(spine_rotate_timeline obj); +SPINE_C_EXPORT void spine_rotate_timeline_apply(spine_rotate_timeline obj, spine_skeleton skeleton, float lastTime, float time, void * pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction, spine_bool appliedPose); +SPINE_C_EXPORT void spine_rotate_timeline_set_frame(spine_rotate_timeline obj, spine_size_t frame, float time, float value); +SPINE_C_EXPORT float spine_rotate_timeline_get_curve_value(spine_rotate_timeline obj, float time); +SPINE_C_EXPORT float spine_rotate_timeline_get_relative_value(spine_rotate_timeline obj, float time, float alpha, spine_mix_blend blend, float current, float setup); +SPINE_C_EXPORT float spine_rotate_timeline_get_absolute_value(spine_rotate_timeline obj, float time, float alpha, spine_mix_blend blend, float current, float setup); +SPINE_C_EXPORT float spine_rotate_timeline_get_absolute_value(spine_rotate_timeline obj, float time, float alpha, spine_mix_blend blend, float current, float setup, float value); +SPINE_C_EXPORT float spine_rotate_timeline_get_scale_value(spine_rotate_timeline obj, float time, float alpha, spine_mix_blend blend, spine_mix_direction direction, float current, float setup); +SPINE_C_EXPORT int32_t spine_rotate_timeline_get_bone_index(spine_rotate_timeline obj); +SPINE_C_EXPORT void spine_rotate_timeline_set_bone_index(spine_rotate_timeline obj, int32_t value); + +#ifdef __cplusplus +} +#endif + +#endif // SPINE_C_ROTATETIMELINE_H \ No newline at end of file diff --git a/spine-c-new/src/generated/rtti.cpp b/spine-c-new/src/generated/rtti.cpp new file mode 100644 index 000000000..53130818b --- /dev/null +++ b/spine-c-new/src/generated/rtti.cpp @@ -0,0 +1,71 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#include "rtti.h" +#include + +using namespace spine; + +spine_rtti spine_rtti_create(const utf8 * className) { + RTTI *obj = new (__FILE__, __LINE__) RTTI((const char *) className); + return (spine_rtti) obj; +} + +spine_rtti spine_rtti_create_with_string_rtti(const utf8 * className, spine_rtti baseRTTI) { + RTTI *obj = new (__FILE__, __LINE__) RTTI((const char *) className, baseRTTI); + return (spine_rtti) obj; +} + +spine_rtti spine_rtti_create_with_string_rtti_rtti_rtti_rtti(const utf8 * className, spine_rtti baseRTTI, spine_const rtti interface1, spine_const rtti interface2, spine_const rtti interface3) { + RTTI *obj = new (__FILE__, __LINE__) RTTI((const char *) className, baseRTTI, (const RTTI *) interface1, (const RTTI *) interface2, (const RTTI *) interface3); + return (spine_rtti) obj; +} + +void spine_rtti_dispose(spine_rtti obj) { + if (!obj) return; + delete (RTTI *) obj; +} + +const utf8 * spine_rtti_get_class_name(spine_rtti obj) { + if (!obj) return nullptr; + RTTI *_obj = (RTTI *) obj; + return (const utf8 *) _obj->getClassName(); +} + +spine_bool spine_rtti_is_exactly(spine_rtti obj, spine_rtti rtti) { + if (!obj) return 0; + RTTI *_obj = (RTTI *) obj; + return _obj->isExactly(rtti); +} + +spine_bool spine_rtti_instance_of(spine_rtti obj, spine_rtti rtti) { + if (!obj) return 0; + RTTI *_obj = (RTTI *) obj; + return _obj->instanceOf(rtti); +} diff --git a/spine-c-new/src/generated/rtti.h b/spine-c-new/src/generated/rtti.h new file mode 100644 index 000000000..27cc38481 --- /dev/null +++ b/spine-c-new/src/generated/rtti.h @@ -0,0 +1,53 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#ifndef SPINE_C_RTTI_H +#define SPINE_C_RTTI_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include "../custom.h" + +SPINE_OPAQUE_TYPE(spine_rtti) + +SPINE_C_EXPORT spine_rtti spine_rtti_create(const utf8 * className); +SPINE_C_EXPORT spine_rtti spine_rtti_create_with_string_rtti(const utf8 * className, spine_rtti baseRTTI); +SPINE_C_EXPORT spine_rtti spine_rtti_create_with_string_rtti_rtti_rtti_rtti(const utf8 * className, spine_rtti baseRTTI, spine_const rtti interface1, spine_const rtti interface2, spine_const rtti interface3); +SPINE_C_EXPORT void spine_rtti_dispose(spine_rtti obj); +SPINE_C_EXPORT const utf8 * spine_rtti_get_class_name(spine_rtti obj); +SPINE_C_EXPORT spine_bool spine_rtti_is_exactly(spine_rtti obj, spine_rtti rtti); +SPINE_C_EXPORT spine_bool spine_rtti_instance_of(spine_rtti obj, spine_rtti rtti); + +#ifdef __cplusplus +} +#endif + +#endif // SPINE_C_RTTI_H \ No newline at end of file diff --git a/spine-c-new/src/generated/scale_timeline.cpp b/spine-c-new/src/generated/scale_timeline.cpp new file mode 100644 index 000000000..d85ac76db --- /dev/null +++ b/spine-c-new/src/generated/scale_timeline.cpp @@ -0,0 +1,79 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#include "scale_timeline.h" +#include + +using namespace spine; + +spine_scale_timeline spine_scale_timeline_create(spine_size_t frameCount, spine_size_t bezierCount, int32_t boneIndex) { + ScaleTimeline *obj = new (__FILE__, __LINE__) ScaleTimeline(frameCount, bezierCount, boneIndex); + return (spine_scale_timeline) obj; +} + +void spine_scale_timeline_dispose(spine_scale_timeline obj) { + if (!obj) return; + delete (ScaleTimeline *) obj; +} + +spine_rtti spine_scale_timeline_get_rtti(spine_scale_timeline obj) { + if (!obj) return nullptr; + ScaleTimeline *_obj = (ScaleTimeline *) obj; + return (spine_rtti) &_obj->getRTTI(); +} + +void spine_scale_timeline_apply(spine_scale_timeline obj, spine_skeleton skeleton, float lastTime, float time, void * pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction, spine_bool appliedPose) { + if (!obj) return ; + ScaleTimeline *_obj = (ScaleTimeline *) obj; + _obj->apply(skeleton, lastTime, time, (Vector *) pEvents, alpha, blend, direction, appliedPose); +} + +void spine_scale_timeline_set_frame(spine_scale_timeline obj, spine_size_t frame, float time, float value1, float value2) { + if (!obj) return ; + ScaleTimeline *_obj = (ScaleTimeline *) obj; + _obj->setFrame(frame, time, value1, value2); +} + +float spine_scale_timeline_get_curve_value(spine_scale_timeline obj, float time) { + if (!obj) return 0; + ScaleTimeline *_obj = (ScaleTimeline *) obj; + return _obj->getCurveValue(time); +} + +int32_t spine_scale_timeline_get_bone_index(spine_scale_timeline obj) { + if (!obj) return 0; + ScaleTimeline *_obj = (ScaleTimeline *) obj; + return _obj->getBoneIndex(); +} + +void spine_scale_timeline_set_bone_index(spine_scale_timeline obj, int32_t value) { + if (!obj) return; + ScaleTimeline *_obj = (ScaleTimeline *) obj; + _obj->setBoneIndex(value); +} diff --git a/spine-c-new/src/generated/scale_timeline.h b/spine-c-new/src/generated/scale_timeline.h new file mode 100644 index 000000000..946875414 --- /dev/null +++ b/spine-c-new/src/generated/scale_timeline.h @@ -0,0 +1,54 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#ifndef SPINE_C_SCALETIMELINE_H +#define SPINE_C_SCALETIMELINE_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include "../custom.h" + +SPINE_OPAQUE_TYPE(spine_scale_timeline) + +SPINE_C_EXPORT spine_scale_timeline spine_scale_timeline_create(spine_size_t frameCount, spine_size_t bezierCount, int32_t boneIndex); +SPINE_C_EXPORT void spine_scale_timeline_dispose(spine_scale_timeline obj); +SPINE_C_EXPORT spine_rtti spine_scale_timeline_get_rtti(spine_scale_timeline obj); +SPINE_C_EXPORT void spine_scale_timeline_apply(spine_scale_timeline obj, spine_skeleton skeleton, float lastTime, float time, void * pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction, spine_bool appliedPose); +SPINE_C_EXPORT void spine_scale_timeline_set_frame(spine_scale_timeline obj, spine_size_t frame, float time, float value1, float value2); +SPINE_C_EXPORT float spine_scale_timeline_get_curve_value(spine_scale_timeline obj, float time); +SPINE_C_EXPORT int32_t spine_scale_timeline_get_bone_index(spine_scale_timeline obj); +SPINE_C_EXPORT void spine_scale_timeline_set_bone_index(spine_scale_timeline obj, int32_t value); + +#ifdef __cplusplus +} +#endif + +#endif // SPINE_C_SCALETIMELINE_H \ No newline at end of file diff --git a/spine-c-new/src/generated/scale_x_timeline.cpp b/spine-c-new/src/generated/scale_x_timeline.cpp new file mode 100644 index 000000000..cbe43d6d7 --- /dev/null +++ b/spine-c-new/src/generated/scale_x_timeline.cpp @@ -0,0 +1,103 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#include "scale_x_timeline.h" +#include + +using namespace spine; + +spine_scale_x_timeline spine_scale_x_timeline_create(spine_size_t frameCount, spine_size_t bezierCount, int32_t boneIndex) { + ScaleXTimeline *obj = new (__FILE__, __LINE__) ScaleXTimeline(frameCount, bezierCount, boneIndex); + return (spine_scale_x_timeline) obj; +} + +void spine_scale_x_timeline_dispose(spine_scale_x_timeline obj) { + if (!obj) return; + delete (ScaleXTimeline *) obj; +} + +spine_rtti spine_scale_x_timeline_get_rtti(spine_scale_x_timeline obj) { + if (!obj) return nullptr; + ScaleXTimeline *_obj = (ScaleXTimeline *) obj; + return (spine_rtti) &_obj->getRTTI(); +} + +void spine_scale_x_timeline_apply(spine_scale_x_timeline obj, spine_skeleton skeleton, float lastTime, float time, void * pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction, spine_bool appliedPose) { + if (!obj) return ; + ScaleXTimeline *_obj = (ScaleXTimeline *) obj; + _obj->apply(skeleton, lastTime, time, (Vector *) pEvents, alpha, blend, direction, appliedPose); +} + +void spine_scale_x_timeline_set_frame(spine_scale_x_timeline obj, spine_size_t frame, float time, float value) { + if (!obj) return ; + ScaleXTimeline *_obj = (ScaleXTimeline *) obj; + _obj->setFrame(frame, time, value); +} + +float spine_scale_x_timeline_get_curve_value(spine_scale_x_timeline obj, float time) { + if (!obj) return 0; + ScaleXTimeline *_obj = (ScaleXTimeline *) obj; + return _obj->getCurveValue(time); +} + +float spine_scale_x_timeline_get_relative_value(spine_scale_x_timeline obj, float time, float alpha, spine_mix_blend blend, float current, float setup) { + if (!obj) return 0; + ScaleXTimeline *_obj = (ScaleXTimeline *) obj; + return _obj->getRelativeValue(time, alpha, blend, current, setup); +} + +float spine_scale_x_timeline_get_absolute_value(spine_scale_x_timeline obj, float time, float alpha, spine_mix_blend blend, float current, float setup) { + if (!obj) return 0; + ScaleXTimeline *_obj = (ScaleXTimeline *) obj; + return _obj->getAbsoluteValue(time, alpha, blend, current, setup); +} + +float spine_scale_x_timeline_get_absolute_value(spine_scale_x_timeline obj, float time, float alpha, spine_mix_blend blend, float current, float setup, float value) { + if (!obj) return 0; + ScaleXTimeline *_obj = (ScaleXTimeline *) obj; + return _obj->getAbsoluteValue(time, alpha, blend, current, setup, value); +} + +float spine_scale_x_timeline_get_scale_value(spine_scale_x_timeline obj, float time, float alpha, spine_mix_blend blend, spine_mix_direction direction, float current, float setup) { + if (!obj) return 0; + ScaleXTimeline *_obj = (ScaleXTimeline *) obj; + return _obj->getScaleValue(time, alpha, blend, direction, current, setup); +} + +int32_t spine_scale_x_timeline_get_bone_index(spine_scale_x_timeline obj) { + if (!obj) return 0; + ScaleXTimeline *_obj = (ScaleXTimeline *) obj; + return _obj->getBoneIndex(); +} + +void spine_scale_x_timeline_set_bone_index(spine_scale_x_timeline obj, int32_t value) { + if (!obj) return; + ScaleXTimeline *_obj = (ScaleXTimeline *) obj; + _obj->setBoneIndex(value); +} diff --git a/spine-c-new/src/generated/scale_x_timeline.h b/spine-c-new/src/generated/scale_x_timeline.h new file mode 100644 index 000000000..813db9d20 --- /dev/null +++ b/spine-c-new/src/generated/scale_x_timeline.h @@ -0,0 +1,58 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#ifndef SPINE_C_SCALEXTIMELINE_H +#define SPINE_C_SCALEXTIMELINE_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include "../custom.h" + +SPINE_OPAQUE_TYPE(spine_scale_x_timeline) + +SPINE_C_EXPORT spine_scale_x_timeline spine_scale_x_timeline_create(spine_size_t frameCount, spine_size_t bezierCount, int32_t boneIndex); +SPINE_C_EXPORT void spine_scale_x_timeline_dispose(spine_scale_x_timeline obj); +SPINE_C_EXPORT spine_rtti spine_scale_x_timeline_get_rtti(spine_scale_x_timeline obj); +SPINE_C_EXPORT void spine_scale_x_timeline_apply(spine_scale_x_timeline obj, spine_skeleton skeleton, float lastTime, float time, void * pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction, spine_bool appliedPose); +SPINE_C_EXPORT void spine_scale_x_timeline_set_frame(spine_scale_x_timeline obj, spine_size_t frame, float time, float value); +SPINE_C_EXPORT float spine_scale_x_timeline_get_curve_value(spine_scale_x_timeline obj, float time); +SPINE_C_EXPORT float spine_scale_x_timeline_get_relative_value(spine_scale_x_timeline obj, float time, float alpha, spine_mix_blend blend, float current, float setup); +SPINE_C_EXPORT float spine_scale_x_timeline_get_absolute_value(spine_scale_x_timeline obj, float time, float alpha, spine_mix_blend blend, float current, float setup); +SPINE_C_EXPORT float spine_scale_x_timeline_get_absolute_value(spine_scale_x_timeline obj, float time, float alpha, spine_mix_blend blend, float current, float setup, float value); +SPINE_C_EXPORT float spine_scale_x_timeline_get_scale_value(spine_scale_x_timeline obj, float time, float alpha, spine_mix_blend blend, spine_mix_direction direction, float current, float setup); +SPINE_C_EXPORT int32_t spine_scale_x_timeline_get_bone_index(spine_scale_x_timeline obj); +SPINE_C_EXPORT void spine_scale_x_timeline_set_bone_index(spine_scale_x_timeline obj, int32_t value); + +#ifdef __cplusplus +} +#endif + +#endif // SPINE_C_SCALEXTIMELINE_H \ No newline at end of file diff --git a/spine-c-new/src/generated/scale_y_timeline.cpp b/spine-c-new/src/generated/scale_y_timeline.cpp new file mode 100644 index 000000000..45e747438 --- /dev/null +++ b/spine-c-new/src/generated/scale_y_timeline.cpp @@ -0,0 +1,103 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#include "scale_y_timeline.h" +#include + +using namespace spine; + +spine_scale_y_timeline spine_scale_y_timeline_create(spine_size_t frameCount, spine_size_t bezierCount, int32_t boneIndex) { + ScaleYTimeline *obj = new (__FILE__, __LINE__) ScaleYTimeline(frameCount, bezierCount, boneIndex); + return (spine_scale_y_timeline) obj; +} + +void spine_scale_y_timeline_dispose(spine_scale_y_timeline obj) { + if (!obj) return; + delete (ScaleYTimeline *) obj; +} + +spine_rtti spine_scale_y_timeline_get_rtti(spine_scale_y_timeline obj) { + if (!obj) return nullptr; + ScaleYTimeline *_obj = (ScaleYTimeline *) obj; + return (spine_rtti) &_obj->getRTTI(); +} + +void spine_scale_y_timeline_apply(spine_scale_y_timeline obj, spine_skeleton skeleton, float lastTime, float time, void * pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction, spine_bool appliedPose) { + if (!obj) return ; + ScaleYTimeline *_obj = (ScaleYTimeline *) obj; + _obj->apply(skeleton, lastTime, time, (Vector *) pEvents, alpha, blend, direction, appliedPose); +} + +void spine_scale_y_timeline_set_frame(spine_scale_y_timeline obj, spine_size_t frame, float time, float value) { + if (!obj) return ; + ScaleYTimeline *_obj = (ScaleYTimeline *) obj; + _obj->setFrame(frame, time, value); +} + +float spine_scale_y_timeline_get_curve_value(spine_scale_y_timeline obj, float time) { + if (!obj) return 0; + ScaleYTimeline *_obj = (ScaleYTimeline *) obj; + return _obj->getCurveValue(time); +} + +float spine_scale_y_timeline_get_relative_value(spine_scale_y_timeline obj, float time, float alpha, spine_mix_blend blend, float current, float setup) { + if (!obj) return 0; + ScaleYTimeline *_obj = (ScaleYTimeline *) obj; + return _obj->getRelativeValue(time, alpha, blend, current, setup); +} + +float spine_scale_y_timeline_get_absolute_value(spine_scale_y_timeline obj, float time, float alpha, spine_mix_blend blend, float current, float setup) { + if (!obj) return 0; + ScaleYTimeline *_obj = (ScaleYTimeline *) obj; + return _obj->getAbsoluteValue(time, alpha, blend, current, setup); +} + +float spine_scale_y_timeline_get_absolute_value(spine_scale_y_timeline obj, float time, float alpha, spine_mix_blend blend, float current, float setup, float value) { + if (!obj) return 0; + ScaleYTimeline *_obj = (ScaleYTimeline *) obj; + return _obj->getAbsoluteValue(time, alpha, blend, current, setup, value); +} + +float spine_scale_y_timeline_get_scale_value(spine_scale_y_timeline obj, float time, float alpha, spine_mix_blend blend, spine_mix_direction direction, float current, float setup) { + if (!obj) return 0; + ScaleYTimeline *_obj = (ScaleYTimeline *) obj; + return _obj->getScaleValue(time, alpha, blend, direction, current, setup); +} + +int32_t spine_scale_y_timeline_get_bone_index(spine_scale_y_timeline obj) { + if (!obj) return 0; + ScaleYTimeline *_obj = (ScaleYTimeline *) obj; + return _obj->getBoneIndex(); +} + +void spine_scale_y_timeline_set_bone_index(spine_scale_y_timeline obj, int32_t value) { + if (!obj) return; + ScaleYTimeline *_obj = (ScaleYTimeline *) obj; + _obj->setBoneIndex(value); +} diff --git a/spine-c-new/src/generated/scale_y_timeline.h b/spine-c-new/src/generated/scale_y_timeline.h new file mode 100644 index 000000000..2d57d5ca2 --- /dev/null +++ b/spine-c-new/src/generated/scale_y_timeline.h @@ -0,0 +1,58 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#ifndef SPINE_C_SCALEYTIMELINE_H +#define SPINE_C_SCALEYTIMELINE_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include "../custom.h" + +SPINE_OPAQUE_TYPE(spine_scale_y_timeline) + +SPINE_C_EXPORT spine_scale_y_timeline spine_scale_y_timeline_create(spine_size_t frameCount, spine_size_t bezierCount, int32_t boneIndex); +SPINE_C_EXPORT void spine_scale_y_timeline_dispose(spine_scale_y_timeline obj); +SPINE_C_EXPORT spine_rtti spine_scale_y_timeline_get_rtti(spine_scale_y_timeline obj); +SPINE_C_EXPORT void spine_scale_y_timeline_apply(spine_scale_y_timeline obj, spine_skeleton skeleton, float lastTime, float time, void * pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction, spine_bool appliedPose); +SPINE_C_EXPORT void spine_scale_y_timeline_set_frame(spine_scale_y_timeline obj, spine_size_t frame, float time, float value); +SPINE_C_EXPORT float spine_scale_y_timeline_get_curve_value(spine_scale_y_timeline obj, float time); +SPINE_C_EXPORT float spine_scale_y_timeline_get_relative_value(spine_scale_y_timeline obj, float time, float alpha, spine_mix_blend blend, float current, float setup); +SPINE_C_EXPORT float spine_scale_y_timeline_get_absolute_value(spine_scale_y_timeline obj, float time, float alpha, spine_mix_blend blend, float current, float setup); +SPINE_C_EXPORT float spine_scale_y_timeline_get_absolute_value(spine_scale_y_timeline obj, float time, float alpha, spine_mix_blend blend, float current, float setup, float value); +SPINE_C_EXPORT float spine_scale_y_timeline_get_scale_value(spine_scale_y_timeline obj, float time, float alpha, spine_mix_blend blend, spine_mix_direction direction, float current, float setup); +SPINE_C_EXPORT int32_t spine_scale_y_timeline_get_bone_index(spine_scale_y_timeline obj); +SPINE_C_EXPORT void spine_scale_y_timeline_set_bone_index(spine_scale_y_timeline obj, int32_t value); + +#ifdef __cplusplus +} +#endif + +#endif // SPINE_C_SCALEYTIMELINE_H \ No newline at end of file diff --git a/spine-c-new/src/generated/sequence.cpp b/spine-c-new/src/generated/sequence.cpp new file mode 100644 index 000000000..7a5fc2459 --- /dev/null +++ b/spine-c-new/src/generated/sequence.cpp @@ -0,0 +1,127 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#include "sequence.h" +#include + +using namespace spine; + +spine_sequence spine_sequence_create(int32_t count) { + Sequence *obj = new (__FILE__, __LINE__) Sequence(count); + return (spine_sequence) obj; +} + +void spine_sequence_dispose(spine_sequence obj) { + if (!obj) return; + delete (Sequence *) obj; +} + +spine_sequence spine_sequence_copy(spine_sequence obj) { + if (!obj) return nullptr; + Sequence *_obj = (Sequence *) obj; + return (spine_sequence) _obj->copy(); +} + +void spine_sequence_apply(spine_sequence obj, spine_slot_pose slot, spine_attachment attachment) { + if (!obj) return ; + Sequence *_obj = (Sequence *) obj; + _obj->apply((SlotPose *) slot, (Attachment *) attachment); +} + +const utf8 * spine_sequence_get_path(spine_sequence obj, const utf8 * basePath, int32_t index) { + if (!obj) return nullptr; + Sequence *_obj = (Sequence *) obj; + return (const utf8 *) _obj->getPath(String(basePath), index).buffer(); +} + +int32_t spine_sequence_get_id(spine_sequence obj) { + if (!obj) return 0; + Sequence *_obj = (Sequence *) obj; + return _obj->getId(); +} + +void spine_sequence_set_id(spine_sequence obj, int32_t value) { + if (!obj) return; + Sequence *_obj = (Sequence *) obj; + _obj->setId(value); +} + +int32_t spine_sequence_get_start(spine_sequence obj) { + if (!obj) return 0; + Sequence *_obj = (Sequence *) obj; + return _obj->getStart(); +} + +void spine_sequence_set_start(spine_sequence obj, int32_t value) { + if (!obj) return; + Sequence *_obj = (Sequence *) obj; + _obj->setStart(value); +} + +int32_t spine_sequence_get_digits(spine_sequence obj) { + if (!obj) return 0; + Sequence *_obj = (Sequence *) obj; + return _obj->getDigits(); +} + +void spine_sequence_set_digits(spine_sequence obj, int32_t value) { + if (!obj) return; + Sequence *_obj = (Sequence *) obj; + _obj->setDigits(value); +} + +int32_t spine_sequence_get_setup_index(spine_sequence obj) { + if (!obj) return 0; + Sequence *_obj = (Sequence *) obj; + return _obj->getSetupIndex(); +} + +void spine_sequence_set_setup_index(spine_sequence obj, int32_t value) { + if (!obj) return; + Sequence *_obj = (Sequence *) obj; + _obj->setSetupIndex(value); +} + +void * spine_sequence_get_regions(spine_sequence obj) { + if (!obj) return nullptr; + Sequence *_obj = (Sequence *) obj; + return (void *) _obj->getRegions(); +} + +int32_t spine_sequence_get_num_regions(spine_sequence obj) { + if (!obj) return 0; + Sequence *_obj = (Sequence *) obj; + return (int32_t) _obj->getRegions().size(); +} + +spine_texture_region *spine_sequence_get_regions(spine_sequence obj) { + if (!obj) return nullptr; + Sequence *_obj = (Sequence *) obj; + return (spine_texture_region *) _obj->getRegions().buffer(); +} diff --git a/spine-c-new/src/generated/sequence.h b/spine-c-new/src/generated/sequence.h new file mode 100644 index 000000000..7f6e63337 --- /dev/null +++ b/spine-c-new/src/generated/sequence.h @@ -0,0 +1,62 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#ifndef SPINE_C_SEQUENCE_H +#define SPINE_C_SEQUENCE_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include "../custom.h" + +SPINE_OPAQUE_TYPE(spine_sequence) + +SPINE_C_EXPORT spine_sequence spine_sequence_create(int32_t count); +SPINE_C_EXPORT void spine_sequence_dispose(spine_sequence obj); +SPINE_C_EXPORT spine_sequence spine_sequence_copy(spine_sequence obj); +SPINE_C_EXPORT void spine_sequence_apply(spine_sequence obj, spine_slot_pose slot, spine_attachment attachment); +SPINE_C_EXPORT const utf8 * spine_sequence_get_path(spine_sequence obj, const utf8 * basePath, int32_t index); +SPINE_C_EXPORT int32_t spine_sequence_get_id(spine_sequence obj); +SPINE_C_EXPORT void spine_sequence_set_id(spine_sequence obj, int32_t value); +SPINE_C_EXPORT int32_t spine_sequence_get_start(spine_sequence obj); +SPINE_C_EXPORT void spine_sequence_set_start(spine_sequence obj, int32_t value); +SPINE_C_EXPORT int32_t spine_sequence_get_digits(spine_sequence obj); +SPINE_C_EXPORT void spine_sequence_set_digits(spine_sequence obj, int32_t value); +SPINE_C_EXPORT int32_t spine_sequence_get_setup_index(spine_sequence obj); +SPINE_C_EXPORT void spine_sequence_set_setup_index(spine_sequence obj, int32_t value); +SPINE_C_EXPORT void * spine_sequence_get_regions(spine_sequence obj); +SPINE_C_EXPORT int32_t spine_sequence_get_num_regions(spine_sequence obj); +SPINE_C_EXPORT spine_texture_region *spine_sequence_get_regions(spine_sequence obj); + +#ifdef __cplusplus +} +#endif + +#endif // SPINE_C_SEQUENCE_H \ No newline at end of file diff --git a/spine-c-new/src/generated/sequence_mode.h b/spine-c-new/src/generated/sequence_mode.h new file mode 100644 index 000000000..ae01e6192 --- /dev/null +++ b/spine-c-new/src/generated/sequence_mode.h @@ -0,0 +1,53 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#ifndef SPINE_C_SEQUENCEMODE_H +#define SPINE_C_SEQUENCEMODE_H + +#include "../../custom.h" + +#ifdef __cplusplus +extern "C" { +#endif + +typedef enum spine_sequence_mode { + SPINE_SEQUENCE_MODE_SEQUENCE_MODE_HOLD = 0, + SPINE_SEQUENCE_MODE_SEQUENCE_MODE_ONCE = 1, + SPINE_SEQUENCE_MODE_SEQUENCE_MODE_LOOP = 2, + SPINE_SEQUENCE_MODE_SEQUENCE_MODE_PINGPONG = 3, + SPINE_SEQUENCE_MODE_SEQUENCE_MODE_ONCE_REVERSE = 4, + SPINE_SEQUENCE_MODE_SEQUENCE_MODE_LOOP_REVERSE = 5, + SPINE_SEQUENCE_MODE_SEQUENCE_MODE_PINGPONG_REVERSE = 6 +} spine_sequence_mode; + +#ifdef __cplusplus +} +#endif + +#endif // SPINE_C_SEQUENCEMODE_H \ No newline at end of file diff --git a/spine-c-new/src/generated/sequence_timeline.cpp b/spine-c-new/src/generated/sequence_timeline.cpp new file mode 100644 index 000000000..ae827f027 --- /dev/null +++ b/spine-c-new/src/generated/sequence_timeline.cpp @@ -0,0 +1,133 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#include "sequence_timeline.h" +#include + +using namespace spine; + +spine_sequence_timeline spine_sequence_timeline_create(spine_size_t frameCount, int32_t slotIndex, spine_spine::attachment attachment) { + SequenceTimeline *obj = new (__FILE__, __LINE__) SequenceTimeline(frameCount, slotIndex, (spine::Attachment *) attachment); + return (spine_sequence_timeline) obj; +} + +void spine_sequence_timeline_dispose(spine_sequence_timeline obj) { + if (!obj) return; + delete (SequenceTimeline *) obj; +} + +spine_rtti spine_sequence_timeline_get_rtti(spine_sequence_timeline obj) { + if (!obj) return nullptr; + SequenceTimeline *_obj = (SequenceTimeline *) obj; + return (spine_rtti) &_obj->getRTTI(); +} + +void spine_sequence_timeline_apply(spine_sequence_timeline obj, spine_skeleton skeleton, float lastTime, float time, void * pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction, spine_bool appliedPose) { + if (!obj) return ; + SequenceTimeline *_obj = (SequenceTimeline *) obj; + _obj->apply(skeleton, lastTime, time, (Vector *) pEvents, alpha, blend, direction, appliedPose); +} + +void spine_sequence_timeline_set_frame(spine_sequence_timeline obj, int32_t frame, float time, spine_sequence_mode mode, int32_t index, float delay) { + if (!obj) return ; + SequenceTimeline *_obj = (SequenceTimeline *) obj; + _obj->setFrame(frame, time, mode, index, delay); +} + +spine_attachment spine_sequence_timeline_get_attachment(spine_sequence_timeline obj) { + if (!obj) return nullptr; + SequenceTimeline *_obj = (SequenceTimeline *) obj; + return (spine_attachment) _obj->getAttachment(); +} + +spine_size_t spine_sequence_timeline_get_frame_entries(spine_sequence_timeline obj) { + if (!obj) return nullptr; + SequenceTimeline *_obj = (SequenceTimeline *) obj; + return _obj->getFrameEntries(); +} + +spine_size_t spine_sequence_timeline_get_frame_count(spine_sequence_timeline obj) { + if (!obj) return nullptr; + SequenceTimeline *_obj = (SequenceTimeline *) obj; + return _obj->getFrameCount(); +} + +void * spine_sequence_timeline_get_frames(spine_sequence_timeline obj) { + if (!obj) return nullptr; + SequenceTimeline *_obj = (SequenceTimeline *) obj; + return _obj->getFrames(); +} + +int32_t spine_sequence_timeline_get_num_frames(spine_sequence_timeline obj) { + if (!obj) return 0; + SequenceTimeline *_obj = (SequenceTimeline *) obj; + return (int32_t) _obj->getFrames().size(); +} + +spine_float *spine_sequence_timeline_get_frames(spine_sequence_timeline obj) { + if (!obj) return nullptr; + SequenceTimeline *_obj = (SequenceTimeline *) obj; + return (spine_float *) _obj->getFrames().buffer(); +} + +float spine_sequence_timeline_get_duration(spine_sequence_timeline obj) { + if (!obj) return 0; + SequenceTimeline *_obj = (SequenceTimeline *) obj; + return _obj->getDuration(); +} + +void * spine_sequence_timeline_get_property_ids(spine_sequence_timeline obj) { + if (!obj) return nullptr; + SequenceTimeline *_obj = (SequenceTimeline *) obj; + return _obj->getPropertyIds(); +} + +int32_t spine_sequence_timeline_get_num_property_ids(spine_sequence_timeline obj) { + if (!obj) return 0; + SequenceTimeline *_obj = (SequenceTimeline *) obj; + return (int32_t) _obj->getPropertyIds().size(); +} + +spine_property_id *spine_sequence_timeline_get_property_ids(spine_sequence_timeline obj) { + if (!obj) return nullptr; + SequenceTimeline *_obj = (SequenceTimeline *) obj; + return (spine_property_id *) _obj->getPropertyIds().buffer(); +} + +int32_t spine_sequence_timeline_get_slot_index(spine_sequence_timeline obj) { + if (!obj) return 0; + SequenceTimeline *_obj = (SequenceTimeline *) obj; + return _obj->getSlotIndex(); +} + +void spine_sequence_timeline_set_slot_index(spine_sequence_timeline obj, int32_t value) { + if (!obj) return; + SequenceTimeline *_obj = (SequenceTimeline *) obj; + _obj->setSlotIndex(value); +} diff --git a/spine-c-new/src/generated/sequence_timeline.h b/spine-c-new/src/generated/sequence_timeline.h new file mode 100644 index 000000000..4c730de7d --- /dev/null +++ b/spine-c-new/src/generated/sequence_timeline.h @@ -0,0 +1,63 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#ifndef SPINE_C_SEQUENCETIMELINE_H +#define SPINE_C_SEQUENCETIMELINE_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include "../custom.h" + +SPINE_OPAQUE_TYPE(spine_sequence_timeline) + +SPINE_C_EXPORT spine_sequence_timeline spine_sequence_timeline_create(spine_size_t frameCount, int32_t slotIndex, spine_spine::attachment attachment); +SPINE_C_EXPORT void spine_sequence_timeline_dispose(spine_sequence_timeline obj); +SPINE_C_EXPORT spine_rtti spine_sequence_timeline_get_rtti(spine_sequence_timeline obj); +SPINE_C_EXPORT void spine_sequence_timeline_apply(spine_sequence_timeline obj, spine_skeleton skeleton, float lastTime, float time, void * pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction, spine_bool appliedPose); +SPINE_C_EXPORT void spine_sequence_timeline_set_frame(spine_sequence_timeline obj, int32_t frame, float time, spine_sequence_mode mode, int32_t index, float delay); +SPINE_C_EXPORT spine_attachment spine_sequence_timeline_get_attachment(spine_sequence_timeline obj); +SPINE_C_EXPORT spine_size_t spine_sequence_timeline_get_frame_entries(spine_sequence_timeline obj); +SPINE_C_EXPORT spine_size_t spine_sequence_timeline_get_frame_count(spine_sequence_timeline obj); +SPINE_C_EXPORT void * spine_sequence_timeline_get_frames(spine_sequence_timeline obj); +SPINE_C_EXPORT int32_t spine_sequence_timeline_get_num_frames(spine_sequence_timeline obj); +SPINE_C_EXPORT spine_float *spine_sequence_timeline_get_frames(spine_sequence_timeline obj); +SPINE_C_EXPORT float spine_sequence_timeline_get_duration(spine_sequence_timeline obj); +SPINE_C_EXPORT void * spine_sequence_timeline_get_property_ids(spine_sequence_timeline obj); +SPINE_C_EXPORT int32_t spine_sequence_timeline_get_num_property_ids(spine_sequence_timeline obj); +SPINE_C_EXPORT spine_property_id *spine_sequence_timeline_get_property_ids(spine_sequence_timeline obj); +SPINE_C_EXPORT int32_t spine_sequence_timeline_get_slot_index(spine_sequence_timeline obj); +SPINE_C_EXPORT void spine_sequence_timeline_set_slot_index(spine_sequence_timeline obj, int32_t value); + +#ifdef __cplusplus +} +#endif + +#endif // SPINE_C_SEQUENCETIMELINE_H \ No newline at end of file diff --git a/spine-c-new/src/generated/shear_timeline.cpp b/spine-c-new/src/generated/shear_timeline.cpp new file mode 100644 index 000000000..59ef5c996 --- /dev/null +++ b/spine-c-new/src/generated/shear_timeline.cpp @@ -0,0 +1,79 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#include "shear_timeline.h" +#include + +using namespace spine; + +spine_shear_timeline spine_shear_timeline_create(spine_size_t frameCount, spine_size_t bezierCount, int32_t boneIndex) { + ShearTimeline *obj = new (__FILE__, __LINE__) ShearTimeline(frameCount, bezierCount, boneIndex); + return (spine_shear_timeline) obj; +} + +void spine_shear_timeline_dispose(spine_shear_timeline obj) { + if (!obj) return; + delete (ShearTimeline *) obj; +} + +spine_rtti spine_shear_timeline_get_rtti(spine_shear_timeline obj) { + if (!obj) return nullptr; + ShearTimeline *_obj = (ShearTimeline *) obj; + return (spine_rtti) &_obj->getRTTI(); +} + +void spine_shear_timeline_apply(spine_shear_timeline obj, spine_skeleton skeleton, float lastTime, float time, void * pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction, spine_bool appliedPose) { + if (!obj) return ; + ShearTimeline *_obj = (ShearTimeline *) obj; + _obj->apply(skeleton, lastTime, time, (Vector *) pEvents, alpha, blend, direction, appliedPose); +} + +void spine_shear_timeline_set_frame(spine_shear_timeline obj, spine_size_t frame, float time, float value1, float value2) { + if (!obj) return ; + ShearTimeline *_obj = (ShearTimeline *) obj; + _obj->setFrame(frame, time, value1, value2); +} + +float spine_shear_timeline_get_curve_value(spine_shear_timeline obj, float time) { + if (!obj) return 0; + ShearTimeline *_obj = (ShearTimeline *) obj; + return _obj->getCurveValue(time); +} + +int32_t spine_shear_timeline_get_bone_index(spine_shear_timeline obj) { + if (!obj) return 0; + ShearTimeline *_obj = (ShearTimeline *) obj; + return _obj->getBoneIndex(); +} + +void spine_shear_timeline_set_bone_index(spine_shear_timeline obj, int32_t value) { + if (!obj) return; + ShearTimeline *_obj = (ShearTimeline *) obj; + _obj->setBoneIndex(value); +} diff --git a/spine-c-new/src/generated/shear_timeline.h b/spine-c-new/src/generated/shear_timeline.h new file mode 100644 index 000000000..92a386125 --- /dev/null +++ b/spine-c-new/src/generated/shear_timeline.h @@ -0,0 +1,54 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#ifndef SPINE_C_SHEARTIMELINE_H +#define SPINE_C_SHEARTIMELINE_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include "../custom.h" + +SPINE_OPAQUE_TYPE(spine_shear_timeline) + +SPINE_C_EXPORT spine_shear_timeline spine_shear_timeline_create(spine_size_t frameCount, spine_size_t bezierCount, int32_t boneIndex); +SPINE_C_EXPORT void spine_shear_timeline_dispose(spine_shear_timeline obj); +SPINE_C_EXPORT spine_rtti spine_shear_timeline_get_rtti(spine_shear_timeline obj); +SPINE_C_EXPORT void spine_shear_timeline_apply(spine_shear_timeline obj, spine_skeleton skeleton, float lastTime, float time, void * pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction, spine_bool appliedPose); +SPINE_C_EXPORT void spine_shear_timeline_set_frame(spine_shear_timeline obj, spine_size_t frame, float time, float value1, float value2); +SPINE_C_EXPORT float spine_shear_timeline_get_curve_value(spine_shear_timeline obj, float time); +SPINE_C_EXPORT int32_t spine_shear_timeline_get_bone_index(spine_shear_timeline obj); +SPINE_C_EXPORT void spine_shear_timeline_set_bone_index(spine_shear_timeline obj, int32_t value); + +#ifdef __cplusplus +} +#endif + +#endif // SPINE_C_SHEARTIMELINE_H \ No newline at end of file diff --git a/spine-c-new/src/generated/shear_x_timeline.cpp b/spine-c-new/src/generated/shear_x_timeline.cpp new file mode 100644 index 000000000..b196a6e2f --- /dev/null +++ b/spine-c-new/src/generated/shear_x_timeline.cpp @@ -0,0 +1,103 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#include "shear_x_timeline.h" +#include + +using namespace spine; + +spine_shear_x_timeline spine_shear_x_timeline_create(spine_size_t frameCount, spine_size_t bezierCount, int32_t boneIndex) { + ShearXTimeline *obj = new (__FILE__, __LINE__) ShearXTimeline(frameCount, bezierCount, boneIndex); + return (spine_shear_x_timeline) obj; +} + +void spine_shear_x_timeline_dispose(spine_shear_x_timeline obj) { + if (!obj) return; + delete (ShearXTimeline *) obj; +} + +spine_rtti spine_shear_x_timeline_get_rtti(spine_shear_x_timeline obj) { + if (!obj) return nullptr; + ShearXTimeline *_obj = (ShearXTimeline *) obj; + return (spine_rtti) &_obj->getRTTI(); +} + +void spine_shear_x_timeline_apply(spine_shear_x_timeline obj, spine_skeleton skeleton, float lastTime, float time, void * pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction, spine_bool appliedPose) { + if (!obj) return ; + ShearXTimeline *_obj = (ShearXTimeline *) obj; + _obj->apply(skeleton, lastTime, time, (Vector *) pEvents, alpha, blend, direction, appliedPose); +} + +void spine_shear_x_timeline_set_frame(spine_shear_x_timeline obj, spine_size_t frame, float time, float value) { + if (!obj) return ; + ShearXTimeline *_obj = (ShearXTimeline *) obj; + _obj->setFrame(frame, time, value); +} + +float spine_shear_x_timeline_get_curve_value(spine_shear_x_timeline obj, float time) { + if (!obj) return 0; + ShearXTimeline *_obj = (ShearXTimeline *) obj; + return _obj->getCurveValue(time); +} + +float spine_shear_x_timeline_get_relative_value(spine_shear_x_timeline obj, float time, float alpha, spine_mix_blend blend, float current, float setup) { + if (!obj) return 0; + ShearXTimeline *_obj = (ShearXTimeline *) obj; + return _obj->getRelativeValue(time, alpha, blend, current, setup); +} + +float spine_shear_x_timeline_get_absolute_value(spine_shear_x_timeline obj, float time, float alpha, spine_mix_blend blend, float current, float setup) { + if (!obj) return 0; + ShearXTimeline *_obj = (ShearXTimeline *) obj; + return _obj->getAbsoluteValue(time, alpha, blend, current, setup); +} + +float spine_shear_x_timeline_get_absolute_value(spine_shear_x_timeline obj, float time, float alpha, spine_mix_blend blend, float current, float setup, float value) { + if (!obj) return 0; + ShearXTimeline *_obj = (ShearXTimeline *) obj; + return _obj->getAbsoluteValue(time, alpha, blend, current, setup, value); +} + +float spine_shear_x_timeline_get_scale_value(spine_shear_x_timeline obj, float time, float alpha, spine_mix_blend blend, spine_mix_direction direction, float current, float setup) { + if (!obj) return 0; + ShearXTimeline *_obj = (ShearXTimeline *) obj; + return _obj->getScaleValue(time, alpha, blend, direction, current, setup); +} + +int32_t spine_shear_x_timeline_get_bone_index(spine_shear_x_timeline obj) { + if (!obj) return 0; + ShearXTimeline *_obj = (ShearXTimeline *) obj; + return _obj->getBoneIndex(); +} + +void spine_shear_x_timeline_set_bone_index(spine_shear_x_timeline obj, int32_t value) { + if (!obj) return; + ShearXTimeline *_obj = (ShearXTimeline *) obj; + _obj->setBoneIndex(value); +} diff --git a/spine-c-new/src/generated/shear_x_timeline.h b/spine-c-new/src/generated/shear_x_timeline.h new file mode 100644 index 000000000..6eaaa75e2 --- /dev/null +++ b/spine-c-new/src/generated/shear_x_timeline.h @@ -0,0 +1,58 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#ifndef SPINE_C_SHEARXTIMELINE_H +#define SPINE_C_SHEARXTIMELINE_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include "../custom.h" + +SPINE_OPAQUE_TYPE(spine_shear_x_timeline) + +SPINE_C_EXPORT spine_shear_x_timeline spine_shear_x_timeline_create(spine_size_t frameCount, spine_size_t bezierCount, int32_t boneIndex); +SPINE_C_EXPORT void spine_shear_x_timeline_dispose(spine_shear_x_timeline obj); +SPINE_C_EXPORT spine_rtti spine_shear_x_timeline_get_rtti(spine_shear_x_timeline obj); +SPINE_C_EXPORT void spine_shear_x_timeline_apply(spine_shear_x_timeline obj, spine_skeleton skeleton, float lastTime, float time, void * pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction, spine_bool appliedPose); +SPINE_C_EXPORT void spine_shear_x_timeline_set_frame(spine_shear_x_timeline obj, spine_size_t frame, float time, float value); +SPINE_C_EXPORT float spine_shear_x_timeline_get_curve_value(spine_shear_x_timeline obj, float time); +SPINE_C_EXPORT float spine_shear_x_timeline_get_relative_value(spine_shear_x_timeline obj, float time, float alpha, spine_mix_blend blend, float current, float setup); +SPINE_C_EXPORT float spine_shear_x_timeline_get_absolute_value(spine_shear_x_timeline obj, float time, float alpha, spine_mix_blend blend, float current, float setup); +SPINE_C_EXPORT float spine_shear_x_timeline_get_absolute_value(spine_shear_x_timeline obj, float time, float alpha, spine_mix_blend blend, float current, float setup, float value); +SPINE_C_EXPORT float spine_shear_x_timeline_get_scale_value(spine_shear_x_timeline obj, float time, float alpha, spine_mix_blend blend, spine_mix_direction direction, float current, float setup); +SPINE_C_EXPORT int32_t spine_shear_x_timeline_get_bone_index(spine_shear_x_timeline obj); +SPINE_C_EXPORT void spine_shear_x_timeline_set_bone_index(spine_shear_x_timeline obj, int32_t value); + +#ifdef __cplusplus +} +#endif + +#endif // SPINE_C_SHEARXTIMELINE_H \ No newline at end of file diff --git a/spine-c-new/src/generated/shear_y_timeline.cpp b/spine-c-new/src/generated/shear_y_timeline.cpp new file mode 100644 index 000000000..374dc995f --- /dev/null +++ b/spine-c-new/src/generated/shear_y_timeline.cpp @@ -0,0 +1,103 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#include "shear_y_timeline.h" +#include + +using namespace spine; + +spine_shear_y_timeline spine_shear_y_timeline_create(spine_size_t frameCount, spine_size_t bezierCount, int32_t boneIndex) { + ShearYTimeline *obj = new (__FILE__, __LINE__) ShearYTimeline(frameCount, bezierCount, boneIndex); + return (spine_shear_y_timeline) obj; +} + +void spine_shear_y_timeline_dispose(spine_shear_y_timeline obj) { + if (!obj) return; + delete (ShearYTimeline *) obj; +} + +spine_rtti spine_shear_y_timeline_get_rtti(spine_shear_y_timeline obj) { + if (!obj) return nullptr; + ShearYTimeline *_obj = (ShearYTimeline *) obj; + return (spine_rtti) &_obj->getRTTI(); +} + +void spine_shear_y_timeline_apply(spine_shear_y_timeline obj, spine_skeleton skeleton, float lastTime, float time, void * pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction, spine_bool appliedPose) { + if (!obj) return ; + ShearYTimeline *_obj = (ShearYTimeline *) obj; + _obj->apply(skeleton, lastTime, time, (Vector *) pEvents, alpha, blend, direction, appliedPose); +} + +void spine_shear_y_timeline_set_frame(spine_shear_y_timeline obj, spine_size_t frame, float time, float value) { + if (!obj) return ; + ShearYTimeline *_obj = (ShearYTimeline *) obj; + _obj->setFrame(frame, time, value); +} + +float spine_shear_y_timeline_get_curve_value(spine_shear_y_timeline obj, float time) { + if (!obj) return 0; + ShearYTimeline *_obj = (ShearYTimeline *) obj; + return _obj->getCurveValue(time); +} + +float spine_shear_y_timeline_get_relative_value(spine_shear_y_timeline obj, float time, float alpha, spine_mix_blend blend, float current, float setup) { + if (!obj) return 0; + ShearYTimeline *_obj = (ShearYTimeline *) obj; + return _obj->getRelativeValue(time, alpha, blend, current, setup); +} + +float spine_shear_y_timeline_get_absolute_value(spine_shear_y_timeline obj, float time, float alpha, spine_mix_blend blend, float current, float setup) { + if (!obj) return 0; + ShearYTimeline *_obj = (ShearYTimeline *) obj; + return _obj->getAbsoluteValue(time, alpha, blend, current, setup); +} + +float spine_shear_y_timeline_get_absolute_value(spine_shear_y_timeline obj, float time, float alpha, spine_mix_blend blend, float current, float setup, float value) { + if (!obj) return 0; + ShearYTimeline *_obj = (ShearYTimeline *) obj; + return _obj->getAbsoluteValue(time, alpha, blend, current, setup, value); +} + +float spine_shear_y_timeline_get_scale_value(spine_shear_y_timeline obj, float time, float alpha, spine_mix_blend blend, spine_mix_direction direction, float current, float setup) { + if (!obj) return 0; + ShearYTimeline *_obj = (ShearYTimeline *) obj; + return _obj->getScaleValue(time, alpha, blend, direction, current, setup); +} + +int32_t spine_shear_y_timeline_get_bone_index(spine_shear_y_timeline obj) { + if (!obj) return 0; + ShearYTimeline *_obj = (ShearYTimeline *) obj; + return _obj->getBoneIndex(); +} + +void spine_shear_y_timeline_set_bone_index(spine_shear_y_timeline obj, int32_t value) { + if (!obj) return; + ShearYTimeline *_obj = (ShearYTimeline *) obj; + _obj->setBoneIndex(value); +} diff --git a/spine-c-new/src/generated/shear_y_timeline.h b/spine-c-new/src/generated/shear_y_timeline.h new file mode 100644 index 000000000..8d63d9a2a --- /dev/null +++ b/spine-c-new/src/generated/shear_y_timeline.h @@ -0,0 +1,58 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#ifndef SPINE_C_SHEARYTIMELINE_H +#define SPINE_C_SHEARYTIMELINE_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include "../custom.h" + +SPINE_OPAQUE_TYPE(spine_shear_y_timeline) + +SPINE_C_EXPORT spine_shear_y_timeline spine_shear_y_timeline_create(spine_size_t frameCount, spine_size_t bezierCount, int32_t boneIndex); +SPINE_C_EXPORT void spine_shear_y_timeline_dispose(spine_shear_y_timeline obj); +SPINE_C_EXPORT spine_rtti spine_shear_y_timeline_get_rtti(spine_shear_y_timeline obj); +SPINE_C_EXPORT void spine_shear_y_timeline_apply(spine_shear_y_timeline obj, spine_skeleton skeleton, float lastTime, float time, void * pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction, spine_bool appliedPose); +SPINE_C_EXPORT void spine_shear_y_timeline_set_frame(spine_shear_y_timeline obj, spine_size_t frame, float time, float value); +SPINE_C_EXPORT float spine_shear_y_timeline_get_curve_value(spine_shear_y_timeline obj, float time); +SPINE_C_EXPORT float spine_shear_y_timeline_get_relative_value(spine_shear_y_timeline obj, float time, float alpha, spine_mix_blend blend, float current, float setup); +SPINE_C_EXPORT float spine_shear_y_timeline_get_absolute_value(spine_shear_y_timeline obj, float time, float alpha, spine_mix_blend blend, float current, float setup); +SPINE_C_EXPORT float spine_shear_y_timeline_get_absolute_value(spine_shear_y_timeline obj, float time, float alpha, spine_mix_blend blend, float current, float setup, float value); +SPINE_C_EXPORT float spine_shear_y_timeline_get_scale_value(spine_shear_y_timeline obj, float time, float alpha, spine_mix_blend blend, spine_mix_direction direction, float current, float setup); +SPINE_C_EXPORT int32_t spine_shear_y_timeline_get_bone_index(spine_shear_y_timeline obj); +SPINE_C_EXPORT void spine_shear_y_timeline_set_bone_index(spine_shear_y_timeline obj, int32_t value); + +#ifdef __cplusplus +} +#endif + +#endif // SPINE_C_SHEARYTIMELINE_H \ No newline at end of file diff --git a/spine-c-new/src/generated/skeleton.cpp b/spine-c-new/src/generated/skeleton.cpp new file mode 100644 index 000000000..7b8e1230b --- /dev/null +++ b/spine-c-new/src/generated/skeleton.cpp @@ -0,0 +1,421 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#include "skeleton.h" +#include + +using namespace spine; + +spine_skeleton spine_skeleton_create(spine_skeleton_data skeletonData) { + Skeleton *obj = new (__FILE__, __LINE__) Skeleton(skeletonData); + return (spine_skeleton) obj; +} + +void spine_skeleton_dispose(spine_skeleton obj) { + if (!obj) return; + delete (Skeleton *) obj; +} + +void spine_skeleton_constrained(spine_skeleton obj, spine_posed object) { + if (!obj) return ; + Skeleton *_obj = (Skeleton *) obj; + _obj->constrained(object); +} + +void spine_skeleton_sort_bone(spine_skeleton obj, spine_bone bone) { + if (!obj) return ; + Skeleton *_obj = (Skeleton *) obj; + _obj->sortBone((Bone *) bone); +} + +void spine_skeleton_update_world_transform(spine_skeleton obj, spine_physics physics) { + if (!obj) return ; + Skeleton *_obj = (Skeleton *) obj; + _obj->updateWorldTransform(physics); +} + +void spine_skeleton_update_world_transform(spine_skeleton obj, spine_physics physics, spine_bone_pose parent) { + if (!obj) return ; + Skeleton *_obj = (Skeleton *) obj; + _obj->updateWorldTransform(physics, (BonePose *) parent); +} + +void spine_skeleton_setup_pose(spine_skeleton obj) { + if (!obj) return ; + Skeleton *_obj = (Skeleton *) obj; + _obj->setupPose(); +} + +void spine_skeleton_setup_pose_bones(spine_skeleton obj) { + if (!obj) return ; + Skeleton *_obj = (Skeleton *) obj; + _obj->setupPoseBones(); +} + +void spine_skeleton_setup_pose_slots(spine_skeleton obj) { + if (!obj) return ; + Skeleton *_obj = (Skeleton *) obj; + _obj->setupPoseSlots(); +} + +spine_skeleton_data spine_skeleton_get_data(spine_skeleton obj) { + if (!obj) return nullptr; + Skeleton *_obj = (Skeleton *) obj; + return (spine_skeleton_data) _obj->getData(); +} + +void * spine_skeleton_get_bones(spine_skeleton obj) { + if (!obj) return nullptr; + Skeleton *_obj = (Skeleton *) obj; + return (void *) _obj->getBones(); +} + +int32_t spine_skeleton_get_num_bones(spine_skeleton obj) { + if (!obj) return 0; + Skeleton *_obj = (Skeleton *) obj; + return (int32_t) _obj->getBones().size(); +} + +spine_bone *spine_skeleton_get_bones(spine_skeleton obj) { + if (!obj) return nullptr; + Skeleton *_obj = (Skeleton *) obj; + return (spine_bone *) _obj->getBones().buffer(); +} + +void * spine_skeleton_get_update_cache(spine_skeleton obj) { + if (!obj) return nullptr; + Skeleton *_obj = (Skeleton *) obj; + return (void *) _obj->getUpdateCache(); +} + +int32_t spine_skeleton_get_num_update_cache(spine_skeleton obj) { + if (!obj) return 0; + Skeleton *_obj = (Skeleton *) obj; + return (int32_t) _obj->getUpdateCache().size(); +} + +spine_update *spine_skeleton_get_update_cache(spine_skeleton obj) { + if (!obj) return nullptr; + Skeleton *_obj = (Skeleton *) obj; + return (spine_update *) _obj->getUpdateCache().buffer(); +} + +spine_bone spine_skeleton_get_root_bone(spine_skeleton obj) { + if (!obj) return nullptr; + Skeleton *_obj = (Skeleton *) obj; + return (spine_bone) _obj->getRootBone(); +} + +spine_bone spine_skeleton_find_bone(spine_skeleton obj, const utf8 * boneName) { + if (!obj) return nullptr; + Skeleton *_obj = (Skeleton *) obj; + return (spine_bone) _obj->findBone(String(boneName)); +} + +void * spine_skeleton_get_slots(spine_skeleton obj) { + if (!obj) return nullptr; + Skeleton *_obj = (Skeleton *) obj; + return (void *) _obj->getSlots(); +} + +int32_t spine_skeleton_get_num_slots(spine_skeleton obj) { + if (!obj) return 0; + Skeleton *_obj = (Skeleton *) obj; + return (int32_t) _obj->getSlots().size(); +} + +spine_slot *spine_skeleton_get_slots(spine_skeleton obj) { + if (!obj) return nullptr; + Skeleton *_obj = (Skeleton *) obj; + return (spine_slot *) _obj->getSlots().buffer(); +} + +spine_slot spine_skeleton_find_slot(spine_skeleton obj, const utf8 * slotName) { + if (!obj) return nullptr; + Skeleton *_obj = (Skeleton *) obj; + return (spine_slot) _obj->findSlot(String(slotName)); +} + +void * spine_skeleton_get_draw_order(spine_skeleton obj) { + if (!obj) return nullptr; + Skeleton *_obj = (Skeleton *) obj; + return (void *) _obj->getDrawOrder(); +} + +int32_t spine_skeleton_get_num_draw_order(spine_skeleton obj) { + if (!obj) return 0; + Skeleton *_obj = (Skeleton *) obj; + return (int32_t) _obj->getDrawOrder().size(); +} + +spine_slot *spine_skeleton_get_draw_order(spine_skeleton obj) { + if (!obj) return nullptr; + Skeleton *_obj = (Skeleton *) obj; + return (spine_slot *) _obj->getDrawOrder().buffer(); +} + +spine_skin spine_skeleton_get_skin(spine_skeleton obj) { + if (!obj) return nullptr; + Skeleton *_obj = (Skeleton *) obj; + return (spine_skin) _obj->getSkin(); +} + +void spine_skeleton_set_skin(spine_skeleton obj, const utf8 * value) { + if (!obj) return; + Skeleton *_obj = (Skeleton *) obj; + _obj->setSkin(String(value)); +} + +void spine_skeleton_set_skin(spine_skeleton obj, spine_skin value) { + if (!obj) return; + Skeleton *_obj = (Skeleton *) obj; + _obj->setSkin((Skin *) value); +} + +spine_attachment spine_skeleton_get_attachment(spine_skeleton obj, const utf8 * slotName, const utf8 * attachmentName) { + if (!obj) return nullptr; + Skeleton *_obj = (Skeleton *) obj; + return (spine_attachment) _obj->getAttachment(String(slotName), String(attachmentName)); +} + +spine_attachment spine_skeleton_get_attachment(spine_skeleton obj, int32_t slotIndex, const utf8 * attachmentName) { + if (!obj) return nullptr; + Skeleton *_obj = (Skeleton *) obj; + return (spine_attachment) _obj->getAttachment(slotIndex, String(attachmentName)); +} + +void spine_skeleton_set_attachment(spine_skeleton obj, const utf8 * slotName, const utf8 * attachmentName) { + if (!obj) return ; + Skeleton *_obj = (Skeleton *) obj; + _obj->setAttachment(String(slotName), String(attachmentName)); +} + +void * spine_skeleton_get_constraints(spine_skeleton obj) { + if (!obj) return nullptr; + Skeleton *_obj = (Skeleton *) obj; + return (void *) _obj->getConstraints(); +} + +int32_t spine_skeleton_get_num_constraints(spine_skeleton obj) { + if (!obj) return 0; + Skeleton *_obj = (Skeleton *) obj; + return (int32_t) _obj->getConstraints().size(); +} + +spine_constraint *spine_skeleton_get_constraints(spine_skeleton obj) { + if (!obj) return nullptr; + Skeleton *_obj = (Skeleton *) obj; + return (spine_constraint *) _obj->getConstraints().buffer(); +} + +void * spine_skeleton_get_physics_constraints(spine_skeleton obj) { + if (!obj) return nullptr; + Skeleton *_obj = (Skeleton *) obj; + return (void *) _obj->getPhysicsConstraints(); +} + +int32_t spine_skeleton_get_num_physics_constraints(spine_skeleton obj) { + if (!obj) return 0; + Skeleton *_obj = (Skeleton *) obj; + return (int32_t) _obj->getPhysicsConstraints().size(); +} + +spine_physics_constraint *spine_skeleton_get_physics_constraints(spine_skeleton obj) { + if (!obj) return nullptr; + Skeleton *_obj = (Skeleton *) obj; + return (spine_physics_constraint *) _obj->getPhysicsConstraints().buffer(); +} + +void spine_skeleton_get_bounds(spine_skeleton obj, float outX, float outY, float outWidth, float outHeight, void * outVertexBuffer) { + if (!obj) return ; + Skeleton *_obj = (Skeleton *) obj; + _obj->getBounds(outX, outY, outWidth, outHeight, (Vector &) outVertexBuffer); +} + +void spine_skeleton_get_bounds(spine_skeleton obj, float outX, float outY, float outWidth, float outHeight, void * outVertexBuffer, spine_skeleton_clipping clipper) { + if (!obj) return ; + Skeleton *_obj = (Skeleton *) obj; + _obj->getBounds(outX, outY, outWidth, outHeight, (Vector &) outVertexBuffer, (SkeletonClipping *) clipper); +} + +spine_color spine_skeleton_get_color(spine_skeleton obj) { + if (!obj) return nullptr; + Skeleton *_obj = (Skeleton *) obj; + return (spine_color) &_obj->getColor(); +} + +void spine_skeleton_set_color(spine_skeleton obj, spine_color value) { + if (!obj) return; + Skeleton *_obj = (Skeleton *) obj; + _obj->setColor(value); +} + +void spine_skeleton_set_color(spine_skeleton obj, float r, float g, float b, float a) { + if (!obj) return ; + Skeleton *_obj = (Skeleton *) obj; + _obj->setColor(r, g, b, a); +} + +float spine_skeleton_get_scale_x(spine_skeleton obj) { + if (!obj) return 0; + Skeleton *_obj = (Skeleton *) obj; + return _obj->getScaleX(); +} + +void spine_skeleton_set_scale_x(spine_skeleton obj, float value) { + if (!obj) return; + Skeleton *_obj = (Skeleton *) obj; + _obj->setScaleX(value); +} + +float spine_skeleton_get_scale_y(spine_skeleton obj) { + if (!obj) return 0; + Skeleton *_obj = (Skeleton *) obj; + return _obj->getScaleY(); +} + +void spine_skeleton_set_scale_y(spine_skeleton obj, float value) { + if (!obj) return; + Skeleton *_obj = (Skeleton *) obj; + _obj->setScaleY(value); +} + +void spine_skeleton_set_scale(spine_skeleton obj, float scaleX, float scaleY) { + if (!obj) return ; + Skeleton *_obj = (Skeleton *) obj; + _obj->setScale(scaleX, scaleY); +} + +float spine_skeleton_get_x(spine_skeleton obj) { + if (!obj) return 0; + Skeleton *_obj = (Skeleton *) obj; + return _obj->getX(); +} + +void spine_skeleton_set_x(spine_skeleton obj, float value) { + if (!obj) return; + Skeleton *_obj = (Skeleton *) obj; + _obj->setX(value); +} + +float spine_skeleton_get_y(spine_skeleton obj) { + if (!obj) return 0; + Skeleton *_obj = (Skeleton *) obj; + return _obj->getY(); +} + +void spine_skeleton_set_y(spine_skeleton obj, float value) { + if (!obj) return; + Skeleton *_obj = (Skeleton *) obj; + _obj->setY(value); +} + +void spine_skeleton_set_position(spine_skeleton obj, float x, float y) { + if (!obj) return ; + Skeleton *_obj = (Skeleton *) obj; + _obj->setPosition(x, y); +} + +float spine_skeleton_get_wind_x(spine_skeleton obj) { + if (!obj) return 0; + Skeleton *_obj = (Skeleton *) obj; + return _obj->getWindX(); +} + +void spine_skeleton_set_wind_x(spine_skeleton obj, float value) { + if (!obj) return; + Skeleton *_obj = (Skeleton *) obj; + _obj->setWindX(value); +} + +float spine_skeleton_get_wind_y(spine_skeleton obj) { + if (!obj) return 0; + Skeleton *_obj = (Skeleton *) obj; + return _obj->getWindY(); +} + +void spine_skeleton_set_wind_y(spine_skeleton obj, float value) { + if (!obj) return; + Skeleton *_obj = (Skeleton *) obj; + _obj->setWindY(value); +} + +float spine_skeleton_get_gravity_x(spine_skeleton obj) { + if (!obj) return 0; + Skeleton *_obj = (Skeleton *) obj; + return _obj->getGravityX(); +} + +void spine_skeleton_set_gravity_x(spine_skeleton obj, float value) { + if (!obj) return; + Skeleton *_obj = (Skeleton *) obj; + _obj->setGravityX(value); +} + +float spine_skeleton_get_gravity_y(spine_skeleton obj) { + if (!obj) return 0; + Skeleton *_obj = (Skeleton *) obj; + return _obj->getGravityY(); +} + +void spine_skeleton_set_gravity_y(spine_skeleton obj, float value) { + if (!obj) return; + Skeleton *_obj = (Skeleton *) obj; + _obj->setGravityY(value); +} + +void spine_skeleton_physics_translate(spine_skeleton obj, float x, float y) { + if (!obj) return ; + Skeleton *_obj = (Skeleton *) obj; + _obj->physicsTranslate(x, y); +} + +void spine_skeleton_physics_rotate(spine_skeleton obj, float x, float y, float degrees) { + if (!obj) return ; + Skeleton *_obj = (Skeleton *) obj; + _obj->physicsRotate(x, y, degrees); +} + +float spine_skeleton_get_time(spine_skeleton obj) { + if (!obj) return 0; + Skeleton *_obj = (Skeleton *) obj; + return _obj->getTime(); +} + +void spine_skeleton_set_time(spine_skeleton obj, float value) { + if (!obj) return; + Skeleton *_obj = (Skeleton *) obj; + _obj->setTime(value); +} + +void spine_skeleton_update(spine_skeleton obj, float delta) { + if (!obj) return ; + Skeleton *_obj = (Skeleton *) obj; + _obj->update(delta); +} diff --git a/spine-c-new/src/generated/skeleton.h b/spine-c-new/src/generated/skeleton.h new file mode 100644 index 000000000..d61de4c9a --- /dev/null +++ b/spine-c-new/src/generated/skeleton.h @@ -0,0 +1,111 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#ifndef SPINE_C_SKELETON_H +#define SPINE_C_SKELETON_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include "../custom.h" + +SPINE_OPAQUE_TYPE(spine_skeleton) + +SPINE_C_EXPORT spine_skeleton spine_skeleton_create(spine_skeleton_data skeletonData); +SPINE_C_EXPORT void spine_skeleton_dispose(spine_skeleton obj); +SPINE_C_EXPORT void spine_skeleton_constrained(spine_skeleton obj, spine_posed object); +SPINE_C_EXPORT void spine_skeleton_sort_bone(spine_skeleton obj, spine_bone bone); +SPINE_C_EXPORT void spine_skeleton_update_world_transform(spine_skeleton obj, spine_physics physics); +SPINE_C_EXPORT void spine_skeleton_update_world_transform(spine_skeleton obj, spine_physics physics, spine_bone_pose parent); +SPINE_C_EXPORT void spine_skeleton_setup_pose(spine_skeleton obj); +SPINE_C_EXPORT void spine_skeleton_setup_pose_bones(spine_skeleton obj); +SPINE_C_EXPORT void spine_skeleton_setup_pose_slots(spine_skeleton obj); +SPINE_C_EXPORT spine_skeleton_data spine_skeleton_get_data(spine_skeleton obj); +SPINE_C_EXPORT void * spine_skeleton_get_bones(spine_skeleton obj); +SPINE_C_EXPORT int32_t spine_skeleton_get_num_bones(spine_skeleton obj); +SPINE_C_EXPORT spine_bone *spine_skeleton_get_bones(spine_skeleton obj); +SPINE_C_EXPORT void * spine_skeleton_get_update_cache(spine_skeleton obj); +SPINE_C_EXPORT int32_t spine_skeleton_get_num_update_cache(spine_skeleton obj); +SPINE_C_EXPORT spine_update *spine_skeleton_get_update_cache(spine_skeleton obj); +SPINE_C_EXPORT spine_bone spine_skeleton_get_root_bone(spine_skeleton obj); +SPINE_C_EXPORT spine_bone spine_skeleton_find_bone(spine_skeleton obj, const utf8 * boneName); +SPINE_C_EXPORT void * spine_skeleton_get_slots(spine_skeleton obj); +SPINE_C_EXPORT int32_t spine_skeleton_get_num_slots(spine_skeleton obj); +SPINE_C_EXPORT spine_slot *spine_skeleton_get_slots(spine_skeleton obj); +SPINE_C_EXPORT spine_slot spine_skeleton_find_slot(spine_skeleton obj, const utf8 * slotName); +SPINE_C_EXPORT void * spine_skeleton_get_draw_order(spine_skeleton obj); +SPINE_C_EXPORT int32_t spine_skeleton_get_num_draw_order(spine_skeleton obj); +SPINE_C_EXPORT spine_slot *spine_skeleton_get_draw_order(spine_skeleton obj); +SPINE_C_EXPORT spine_skin spine_skeleton_get_skin(spine_skeleton obj); +SPINE_C_EXPORT void spine_skeleton_set_skin(spine_skeleton obj, const utf8 * value); +SPINE_C_EXPORT void spine_skeleton_set_skin(spine_skeleton obj, spine_skin value); +SPINE_C_EXPORT spine_attachment spine_skeleton_get_attachment(spine_skeleton obj, const utf8 * slotName, const utf8 * attachmentName); +SPINE_C_EXPORT spine_attachment spine_skeleton_get_attachment(spine_skeleton obj, int32_t slotIndex, const utf8 * attachmentName); +SPINE_C_EXPORT void spine_skeleton_set_attachment(spine_skeleton obj, const utf8 * slotName, const utf8 * attachmentName); +SPINE_C_EXPORT void * spine_skeleton_get_constraints(spine_skeleton obj); +SPINE_C_EXPORT int32_t spine_skeleton_get_num_constraints(spine_skeleton obj); +SPINE_C_EXPORT spine_constraint *spine_skeleton_get_constraints(spine_skeleton obj); +SPINE_C_EXPORT void * spine_skeleton_get_physics_constraints(spine_skeleton obj); +SPINE_C_EXPORT int32_t spine_skeleton_get_num_physics_constraints(spine_skeleton obj); +SPINE_C_EXPORT spine_physics_constraint *spine_skeleton_get_physics_constraints(spine_skeleton obj); +SPINE_C_EXPORT void spine_skeleton_get_bounds(spine_skeleton obj, float outX, float outY, float outWidth, float outHeight, void * outVertexBuffer); +SPINE_C_EXPORT void spine_skeleton_get_bounds(spine_skeleton obj, float outX, float outY, float outWidth, float outHeight, void * outVertexBuffer, spine_skeleton_clipping clipper); +SPINE_C_EXPORT spine_color spine_skeleton_get_color(spine_skeleton obj); +SPINE_C_EXPORT void spine_skeleton_set_color(spine_skeleton obj, spine_color value); +SPINE_C_EXPORT void spine_skeleton_set_color(spine_skeleton obj, float r, float g, float b, float a); +SPINE_C_EXPORT float spine_skeleton_get_scale_x(spine_skeleton obj); +SPINE_C_EXPORT void spine_skeleton_set_scale_x(spine_skeleton obj, float value); +SPINE_C_EXPORT float spine_skeleton_get_scale_y(spine_skeleton obj); +SPINE_C_EXPORT void spine_skeleton_set_scale_y(spine_skeleton obj, float value); +SPINE_C_EXPORT void spine_skeleton_set_scale(spine_skeleton obj, float scaleX, float scaleY); +SPINE_C_EXPORT float spine_skeleton_get_x(spine_skeleton obj); +SPINE_C_EXPORT void spine_skeleton_set_x(spine_skeleton obj, float value); +SPINE_C_EXPORT float spine_skeleton_get_y(spine_skeleton obj); +SPINE_C_EXPORT void spine_skeleton_set_y(spine_skeleton obj, float value); +SPINE_C_EXPORT void spine_skeleton_set_position(spine_skeleton obj, float x, float y); +SPINE_C_EXPORT float spine_skeleton_get_wind_x(spine_skeleton obj); +SPINE_C_EXPORT void spine_skeleton_set_wind_x(spine_skeleton obj, float value); +SPINE_C_EXPORT float spine_skeleton_get_wind_y(spine_skeleton obj); +SPINE_C_EXPORT void spine_skeleton_set_wind_y(spine_skeleton obj, float value); +SPINE_C_EXPORT float spine_skeleton_get_gravity_x(spine_skeleton obj); +SPINE_C_EXPORT void spine_skeleton_set_gravity_x(spine_skeleton obj, float value); +SPINE_C_EXPORT float spine_skeleton_get_gravity_y(spine_skeleton obj); +SPINE_C_EXPORT void spine_skeleton_set_gravity_y(spine_skeleton obj, float value); +SPINE_C_EXPORT void spine_skeleton_physics_translate(spine_skeleton obj, float x, float y); +SPINE_C_EXPORT void spine_skeleton_physics_rotate(spine_skeleton obj, float x, float y, float degrees); +SPINE_C_EXPORT float spine_skeleton_get_time(spine_skeleton obj); +SPINE_C_EXPORT void spine_skeleton_set_time(spine_skeleton obj, float value); +SPINE_C_EXPORT void spine_skeleton_update(spine_skeleton obj, float delta); + +#ifdef __cplusplus +} +#endif + +#endif // SPINE_C_SKELETON_H \ No newline at end of file diff --git a/spine-c-new/src/generated/skeleton_binary.cpp b/spine-c-new/src/generated/skeleton_binary.cpp new file mode 100644 index 000000000..49d5aeaa1 --- /dev/null +++ b/spine-c-new/src/generated/skeleton_binary.cpp @@ -0,0 +1,72 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#include "skeleton_binary.h" +#include + +using namespace spine; + +spine_skeleton_binary spine_skeleton_binary_create(spine_atlas atlas) { + SkeletonBinary *obj = new (__FILE__, __LINE__) SkeletonBinary((Atlas *) atlas); + return (spine_skeleton_binary) obj; +} + +spine_skeleton_binary spine_skeleton_binary_create_with_attachment_loader_bool(spine_attachment_loader attachmentLoader, spine_bool ownsLoader) { + SkeletonBinary *obj = new (__FILE__, __LINE__) SkeletonBinary((AttachmentLoader *) attachmentLoader, ownsLoader); + return (spine_skeleton_binary) obj; +} + +void spine_skeleton_binary_dispose(spine_skeleton_binary obj) { + if (!obj) return; + delete (SkeletonBinary *) obj; +} + +spine_skeleton_data spine_skeleton_binary_read_skeleton_data(spine_skeleton_binary obj, spine_const unsigned char binary, int32_t length) { + if (!obj) return nullptr; + SkeletonBinary *_obj = (SkeletonBinary *) obj; + return (spine_skeleton_data) _obj->readSkeletonData((const unsigned char *) binary, length); +} + +spine_skeleton_data spine_skeleton_binary_read_skeleton_data_file(spine_skeleton_binary obj, const utf8 * path) { + if (!obj) return nullptr; + SkeletonBinary *_obj = (SkeletonBinary *) obj; + return (spine_skeleton_data) _obj->readSkeletonDataFile(String(path)); +} + +void spine_skeleton_binary_set_scale(spine_skeleton_binary obj, float value) { + if (!obj) return; + SkeletonBinary *_obj = (SkeletonBinary *) obj; + _obj->setScale(value); +} + +const utf8 * spine_skeleton_binary_get_error(spine_skeleton_binary obj) { + if (!obj) return nullptr; + SkeletonBinary *_obj = (SkeletonBinary *) obj; + return (const utf8 *) _obj->getError().buffer(); +} diff --git a/spine-c-new/src/generated/skeleton_binary.h b/spine-c-new/src/generated/skeleton_binary.h new file mode 100644 index 000000000..fadd2e4c8 --- /dev/null +++ b/spine-c-new/src/generated/skeleton_binary.h @@ -0,0 +1,53 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#ifndef SPINE_C_SKELETONBINARY_H +#define SPINE_C_SKELETONBINARY_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include "../custom.h" + +SPINE_OPAQUE_TYPE(spine_skeleton_binary) + +SPINE_C_EXPORT spine_skeleton_binary spine_skeleton_binary_create(spine_atlas atlas); +SPINE_C_EXPORT spine_skeleton_binary spine_skeleton_binary_create_with_attachment_loader_bool(spine_attachment_loader attachmentLoader, spine_bool ownsLoader); +SPINE_C_EXPORT void spine_skeleton_binary_dispose(spine_skeleton_binary obj); +SPINE_C_EXPORT spine_skeleton_data spine_skeleton_binary_read_skeleton_data(spine_skeleton_binary obj, spine_const unsigned char binary, int32_t length); +SPINE_C_EXPORT spine_skeleton_data spine_skeleton_binary_read_skeleton_data_file(spine_skeleton_binary obj, const utf8 * path); +SPINE_C_EXPORT void spine_skeleton_binary_set_scale(spine_skeleton_binary obj, float value); +SPINE_C_EXPORT const utf8 * spine_skeleton_binary_get_error(spine_skeleton_binary obj); + +#ifdef __cplusplus +} +#endif + +#endif // SPINE_C_SKELETONBINARY_H \ No newline at end of file diff --git a/spine-c-new/src/generated/skeleton_bounds.cpp b/spine-c-new/src/generated/skeleton_bounds.cpp new file mode 100644 index 000000000..619a09994 --- /dev/null +++ b/spine-c-new/src/generated/skeleton_bounds.cpp @@ -0,0 +1,175 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#include "skeleton_bounds.h" +#include + +using namespace spine; + +spine_skeleton_bounds spine_skeleton_bounds_create(void) { + SkeletonBounds *obj = new (__FILE__, __LINE__) SkeletonBounds(); + return (spine_skeleton_bounds) obj; +} + +void spine_skeleton_bounds_dispose(spine_skeleton_bounds obj) { + if (!obj) return; + delete (SkeletonBounds *) obj; +} + +void spine_skeleton_bounds_update(spine_skeleton_bounds obj, spine_skeleton skeleton, spine_bool updateAabb) { + if (!obj) return ; + SkeletonBounds *_obj = (SkeletonBounds *) obj; + _obj->update(skeleton, updateAabb); +} + +spine_bool spine_skeleton_bounds_aabb_contains_point(spine_skeleton_bounds obj, float x, float y) { + if (!obj) return 0; + SkeletonBounds *_obj = (SkeletonBounds *) obj; + return _obj->aabbContainsPoint(x, y); +} + +spine_bool spine_skeleton_bounds_aabb_intersects_segment(spine_skeleton_bounds obj, float x1, float y1, float x2, float y2) { + if (!obj) return 0; + SkeletonBounds *_obj = (SkeletonBounds *) obj; + return _obj->aabbIntersectsSegment(x1, y1, x2, y2); +} + +spine_bool spine_skeleton_bounds_aabb_intersects_skeleton(spine_skeleton_bounds obj, spine_skeleton_bounds bounds) { + if (!obj) return 0; + SkeletonBounds *_obj = (SkeletonBounds *) obj; + return _obj->aabbIntersectsSkeleton(bounds); +} + +spine_bool spine_skeleton_bounds_contains_point(spine_skeleton_bounds obj, spine_polygon polygon, float x, float y) { + if (!obj) return 0; + SkeletonBounds *_obj = (SkeletonBounds *) obj; + return _obj->containsPoint((Polygon *) polygon, x, y); +} + +spine_bounding_box_attachment spine_skeleton_bounds_contains_point(spine_skeleton_bounds obj, float x, float y) { + if (!obj) return nullptr; + SkeletonBounds *_obj = (SkeletonBounds *) obj; + return (spine_bounding_box_attachment) _obj->containsPoint(x, y); +} + +spine_bounding_box_attachment spine_skeleton_bounds_intersects_segment(spine_skeleton_bounds obj, float x1, float y1, float x2, float y2) { + if (!obj) return nullptr; + SkeletonBounds *_obj = (SkeletonBounds *) obj; + return (spine_bounding_box_attachment) _obj->intersectsSegment(x1, y1, x2, y2); +} + +spine_bool spine_skeleton_bounds_intersects_segment(spine_skeleton_bounds obj, spine_polygon polygon, float x1, float y1, float x2, float y2) { + if (!obj) return 0; + SkeletonBounds *_obj = (SkeletonBounds *) obj; + return _obj->intersectsSegment((Polygon *) polygon, x1, y1, x2, y2); +} + +spine_polygon spine_skeleton_bounds_get_polygon(spine_skeleton_bounds obj, spine_bounding_box_attachment attachment) { + if (!obj) return nullptr; + SkeletonBounds *_obj = (SkeletonBounds *) obj; + return (spine_polygon) _obj->getPolygon((BoundingBoxAttachment *) attachment); +} + +spine_bounding_box_attachment spine_skeleton_bounds_get_bounding_box(spine_skeleton_bounds obj, spine_polygon polygon) { + if (!obj) return nullptr; + SkeletonBounds *_obj = (SkeletonBounds *) obj; + return (spine_bounding_box_attachment) _obj->getBoundingBox((Polygon *) polygon); +} + +void * spine_skeleton_bounds_get_polygons(spine_skeleton_bounds obj) { + if (!obj) return nullptr; + SkeletonBounds *_obj = (SkeletonBounds *) obj; + return (void *) _obj->getPolygons(); +} + +int32_t spine_skeleton_bounds_get_num_polygons(spine_skeleton_bounds obj) { + if (!obj) return 0; + SkeletonBounds *_obj = (SkeletonBounds *) obj; + return (int32_t) _obj->getPolygons().size(); +} + +spine_polygon *spine_skeleton_bounds_get_polygons(spine_skeleton_bounds obj) { + if (!obj) return nullptr; + SkeletonBounds *_obj = (SkeletonBounds *) obj; + return (spine_polygon *) _obj->getPolygons().buffer(); +} + +void * spine_skeleton_bounds_get_bounding_boxes(spine_skeleton_bounds obj) { + if (!obj) return nullptr; + SkeletonBounds *_obj = (SkeletonBounds *) obj; + return (void *) _obj->getBoundingBoxes(); +} + +int32_t spine_skeleton_bounds_get_num_bounding_boxes(spine_skeleton_bounds obj) { + if (!obj) return 0; + SkeletonBounds *_obj = (SkeletonBounds *) obj; + return (int32_t) _obj->getBoundingBoxes().size(); +} + +spine_bounding_box_attachment *spine_skeleton_bounds_get_bounding_boxes(spine_skeleton_bounds obj) { + if (!obj) return nullptr; + SkeletonBounds *_obj = (SkeletonBounds *) obj; + return (spine_bounding_box_attachment *) _obj->getBoundingBoxes().buffer(); +} + +float spine_skeleton_bounds_get_min_x(spine_skeleton_bounds obj) { + if (!obj) return 0; + SkeletonBounds *_obj = (SkeletonBounds *) obj; + return _obj->getMinX(); +} + +float spine_skeleton_bounds_get_min_y(spine_skeleton_bounds obj) { + if (!obj) return 0; + SkeletonBounds *_obj = (SkeletonBounds *) obj; + return _obj->getMinY(); +} + +float spine_skeleton_bounds_get_max_x(spine_skeleton_bounds obj) { + if (!obj) return 0; + SkeletonBounds *_obj = (SkeletonBounds *) obj; + return _obj->getMaxX(); +} + +float spine_skeleton_bounds_get_max_y(spine_skeleton_bounds obj) { + if (!obj) return 0; + SkeletonBounds *_obj = (SkeletonBounds *) obj; + return _obj->getMaxY(); +} + +float spine_skeleton_bounds_get_width(spine_skeleton_bounds obj) { + if (!obj) return 0; + SkeletonBounds *_obj = (SkeletonBounds *) obj; + return _obj->getWidth(); +} + +float spine_skeleton_bounds_get_height(spine_skeleton_bounds obj) { + if (!obj) return 0; + SkeletonBounds *_obj = (SkeletonBounds *) obj; + return _obj->getHeight(); +} diff --git a/spine-c-new/src/generated/skeleton_bounds.h b/spine-c-new/src/generated/skeleton_bounds.h new file mode 100644 index 000000000..719ff2037 --- /dev/null +++ b/spine-c-new/src/generated/skeleton_bounds.h @@ -0,0 +1,70 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#ifndef SPINE_C_SKELETONBOUNDS_H +#define SPINE_C_SKELETONBOUNDS_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include "../custom.h" + +SPINE_OPAQUE_TYPE(spine_skeleton_bounds) + +SPINE_C_EXPORT spine_skeleton_bounds spine_skeleton_bounds_create(void); +SPINE_C_EXPORT void spine_skeleton_bounds_dispose(spine_skeleton_bounds obj); +SPINE_C_EXPORT void spine_skeleton_bounds_update(spine_skeleton_bounds obj, spine_skeleton skeleton, spine_bool updateAabb); +SPINE_C_EXPORT spine_bool spine_skeleton_bounds_aabb_contains_point(spine_skeleton_bounds obj, float x, float y); +SPINE_C_EXPORT spine_bool spine_skeleton_bounds_aabb_intersects_segment(spine_skeleton_bounds obj, float x1, float y1, float x2, float y2); +SPINE_C_EXPORT spine_bool spine_skeleton_bounds_aabb_intersects_skeleton(spine_skeleton_bounds obj, spine_skeleton_bounds bounds); +SPINE_C_EXPORT spine_bool spine_skeleton_bounds_contains_point(spine_skeleton_bounds obj, spine_polygon polygon, float x, float y); +SPINE_C_EXPORT spine_bounding_box_attachment spine_skeleton_bounds_contains_point(spine_skeleton_bounds obj, float x, float y); +SPINE_C_EXPORT spine_bounding_box_attachment spine_skeleton_bounds_intersects_segment(spine_skeleton_bounds obj, float x1, float y1, float x2, float y2); +SPINE_C_EXPORT spine_bool spine_skeleton_bounds_intersects_segment(spine_skeleton_bounds obj, spine_polygon polygon, float x1, float y1, float x2, float y2); +SPINE_C_EXPORT spine_polygon spine_skeleton_bounds_get_polygon(spine_skeleton_bounds obj, spine_bounding_box_attachment attachment); +SPINE_C_EXPORT spine_bounding_box_attachment spine_skeleton_bounds_get_bounding_box(spine_skeleton_bounds obj, spine_polygon polygon); +SPINE_C_EXPORT void * spine_skeleton_bounds_get_polygons(spine_skeleton_bounds obj); +SPINE_C_EXPORT int32_t spine_skeleton_bounds_get_num_polygons(spine_skeleton_bounds obj); +SPINE_C_EXPORT spine_polygon *spine_skeleton_bounds_get_polygons(spine_skeleton_bounds obj); +SPINE_C_EXPORT void * spine_skeleton_bounds_get_bounding_boxes(spine_skeleton_bounds obj); +SPINE_C_EXPORT int32_t spine_skeleton_bounds_get_num_bounding_boxes(spine_skeleton_bounds obj); +SPINE_C_EXPORT spine_bounding_box_attachment *spine_skeleton_bounds_get_bounding_boxes(spine_skeleton_bounds obj); +SPINE_C_EXPORT float spine_skeleton_bounds_get_min_x(spine_skeleton_bounds obj); +SPINE_C_EXPORT float spine_skeleton_bounds_get_min_y(spine_skeleton_bounds obj); +SPINE_C_EXPORT float spine_skeleton_bounds_get_max_x(spine_skeleton_bounds obj); +SPINE_C_EXPORT float spine_skeleton_bounds_get_max_y(spine_skeleton_bounds obj); +SPINE_C_EXPORT float spine_skeleton_bounds_get_width(spine_skeleton_bounds obj); +SPINE_C_EXPORT float spine_skeleton_bounds_get_height(spine_skeleton_bounds obj); + +#ifdef __cplusplus +} +#endif + +#endif // SPINE_C_SKELETONBOUNDS_H \ No newline at end of file diff --git a/spine-c-new/src/generated/skeleton_data.cpp b/spine-c-new/src/generated/skeleton_data.cpp new file mode 100644 index 000000000..f6508efa6 --- /dev/null +++ b/spine-c-new/src/generated/skeleton_data.cpp @@ -0,0 +1,385 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#include "skeleton_data.h" +#include + +using namespace spine; + +spine_skeleton_data spine_skeleton_data_create(void) { + SkeletonData *obj = new (__FILE__, __LINE__) SkeletonData(); + return (spine_skeleton_data) obj; +} + +void spine_skeleton_data_dispose(spine_skeleton_data obj) { + if (!obj) return; + delete (SkeletonData *) obj; +} + +spine_bone_data spine_skeleton_data_find_bone(spine_skeleton_data obj, const utf8 * boneName) { + if (!obj) return nullptr; + SkeletonData *_obj = (SkeletonData *) obj; + return (spine_bone_data) _obj->findBone(String(boneName)); +} + +spine_slot_data spine_skeleton_data_find_slot(spine_skeleton_data obj, const utf8 * slotName) { + if (!obj) return nullptr; + SkeletonData *_obj = (SkeletonData *) obj; + return (spine_slot_data) _obj->findSlot(String(slotName)); +} + +spine_skin spine_skeleton_data_find_skin(spine_skeleton_data obj, const utf8 * skinName) { + if (!obj) return nullptr; + SkeletonData *_obj = (SkeletonData *) obj; + return (spine_skin) _obj->findSkin(String(skinName)); +} + +spine_spine::event_data spine_skeleton_data_find_event(spine_skeleton_data obj, const utf8 * eventDataName) { + if (!obj) return nullptr; + SkeletonData *_obj = (SkeletonData *) obj; + return (spine_spine::event_data) _obj->findEvent(String(eventDataName)); +} + +spine_animation spine_skeleton_data_find_animation(spine_skeleton_data obj, const utf8 * animationName) { + if (!obj) return nullptr; + SkeletonData *_obj = (SkeletonData *) obj; + return (spine_animation) _obj->findAnimation(String(animationName)); +} + +spine_ik_constraint_data spine_skeleton_data_find_ik_constraint(spine_skeleton_data obj, const utf8 * constraintName) { + if (!obj) return 0; + SkeletonData *_obj = (SkeletonData *) obj; + return (spine_ik_constraint_data) _obj->findIkConstraint(String(constraintName)); +} + +spine_transform_constraint_data spine_skeleton_data_find_transform_constraint(spine_skeleton_data obj, const utf8 * constraintName) { + if (!obj) return 0; + SkeletonData *_obj = (SkeletonData *) obj; + return (spine_transform_constraint_data) _obj->findTransformConstraint(String(constraintName)); +} + +spine_path_constraint_data spine_skeleton_data_find_path_constraint(spine_skeleton_data obj, const utf8 * constraintName) { + if (!obj) return 0; + SkeletonData *_obj = (SkeletonData *) obj; + return (spine_path_constraint_data) _obj->findPathConstraint(String(constraintName)); +} + +spine_physics_constraint_data spine_skeleton_data_find_physics_constraint(spine_skeleton_data obj, const utf8 * constraintName) { + if (!obj) return 0; + SkeletonData *_obj = (SkeletonData *) obj; + return (spine_physics_constraint_data) _obj->findPhysicsConstraint(String(constraintName)); +} + +const utf8 * spine_skeleton_data_get_name(spine_skeleton_data obj) { + if (!obj) return nullptr; + SkeletonData *_obj = (SkeletonData *) obj; + return (const utf8 *) _obj->getName().buffer(); +} + +void * spine_skeleton_data_get_bones(spine_skeleton_data obj) { + if (!obj) return nullptr; + SkeletonData *_obj = (SkeletonData *) obj; + return (void *) _obj->getBones(); +} + +int32_t spine_skeleton_data_get_num_bones(spine_skeleton_data obj) { + if (!obj) return 0; + SkeletonData *_obj = (SkeletonData *) obj; + return (int32_t) _obj->getBones().size(); +} + +spine_bone_data *spine_skeleton_data_get_bones(spine_skeleton_data obj) { + if (!obj) return nullptr; + SkeletonData *_obj = (SkeletonData *) obj; + return (spine_bone_data *) _obj->getBones().buffer(); +} + +void * spine_skeleton_data_get_slots(spine_skeleton_data obj) { + if (!obj) return nullptr; + SkeletonData *_obj = (SkeletonData *) obj; + return (void *) _obj->getSlots(); +} + +int32_t spine_skeleton_data_get_num_slots(spine_skeleton_data obj) { + if (!obj) return 0; + SkeletonData *_obj = (SkeletonData *) obj; + return (int32_t) _obj->getSlots().size(); +} + +spine_slot_data *spine_skeleton_data_get_slots(spine_skeleton_data obj) { + if (!obj) return nullptr; + SkeletonData *_obj = (SkeletonData *) obj; + return (spine_slot_data *) _obj->getSlots().buffer(); +} + +void * spine_skeleton_data_get_skins(spine_skeleton_data obj) { + if (!obj) return nullptr; + SkeletonData *_obj = (SkeletonData *) obj; + return (void *) _obj->getSkins(); +} + +int32_t spine_skeleton_data_get_num_skins(spine_skeleton_data obj) { + if (!obj) return 0; + SkeletonData *_obj = (SkeletonData *) obj; + return (int32_t) _obj->getSkins().size(); +} + +spine_skin *spine_skeleton_data_get_skins(spine_skeleton_data obj) { + if (!obj) return nullptr; + SkeletonData *_obj = (SkeletonData *) obj; + return (spine_skin *) _obj->getSkins().buffer(); +} + +spine_skin spine_skeleton_data_get_default_skin(spine_skeleton_data obj) { + if (!obj) return nullptr; + SkeletonData *_obj = (SkeletonData *) obj; + return (spine_skin) _obj->getDefaultSkin(); +} + +void spine_skeleton_data_set_default_skin(spine_skeleton_data obj, spine_skin value) { + if (!obj) return; + SkeletonData *_obj = (SkeletonData *) obj; + _obj->setDefaultSkin((Skin *) value); +} + +void * spine_skeleton_data_get_events(spine_skeleton_data obj) { + if (!obj) return nullptr; + SkeletonData *_obj = (SkeletonData *) obj; + return (void *) _obj->getEvents(); +} + +int32_t spine_skeleton_data_get_num_events(spine_skeleton_data obj) { + if (!obj) return 0; + SkeletonData *_obj = (SkeletonData *) obj; + return (int32_t) _obj->getEvents().size(); +} + +spine_spine::event_data *spine_skeleton_data_get_events(spine_skeleton_data obj) { + if (!obj) return nullptr; + SkeletonData *_obj = (SkeletonData *) obj; + return (spine_spine::event_data *) _obj->getEvents().buffer(); +} + +void * spine_skeleton_data_get_animations(spine_skeleton_data obj) { + if (!obj) return nullptr; + SkeletonData *_obj = (SkeletonData *) obj; + return (void *) _obj->getAnimations(); +} + +int32_t spine_skeleton_data_get_num_animations(spine_skeleton_data obj) { + if (!obj) return 0; + SkeletonData *_obj = (SkeletonData *) obj; + return (int32_t) _obj->getAnimations().size(); +} + +spine_animation *spine_skeleton_data_get_animations(spine_skeleton_data obj) { + if (!obj) return nullptr; + SkeletonData *_obj = (SkeletonData *) obj; + return (spine_animation *) _obj->getAnimations().buffer(); +} + +void * spine_skeleton_data_get_ik_constraints(spine_skeleton_data obj) { + if (!obj) return nullptr; + SkeletonData *_obj = (SkeletonData *) obj; + return (void *) _obj->getIkConstraints(); +} + +int32_t spine_skeleton_data_get_num_ik_constraints(spine_skeleton_data obj) { + if (!obj) return 0; + SkeletonData *_obj = (SkeletonData *) obj; + return (int32_t) _obj->getIkConstraints().size(); +} + +spine_ik_constraint_data *spine_skeleton_data_get_ik_constraints(spine_skeleton_data obj) { + if (!obj) return nullptr; + SkeletonData *_obj = (SkeletonData *) obj; + return (spine_ik_constraint_data *) _obj->getIkConstraints().buffer(); +} + +void * spine_skeleton_data_get_transform_constraints(spine_skeleton_data obj) { + if (!obj) return nullptr; + SkeletonData *_obj = (SkeletonData *) obj; + return (void *) _obj->getTransformConstraints(); +} + +int32_t spine_skeleton_data_get_num_transform_constraints(spine_skeleton_data obj) { + if (!obj) return 0; + SkeletonData *_obj = (SkeletonData *) obj; + return (int32_t) _obj->getTransformConstraints().size(); +} + +spine_transform_constraint_data *spine_skeleton_data_get_transform_constraints(spine_skeleton_data obj) { + if (!obj) return nullptr; + SkeletonData *_obj = (SkeletonData *) obj; + return (spine_transform_constraint_data *) _obj->getTransformConstraints().buffer(); +} + +void * spine_skeleton_data_get_path_constraints(spine_skeleton_data obj) { + if (!obj) return nullptr; + SkeletonData *_obj = (SkeletonData *) obj; + return (void *) _obj->getPathConstraints(); +} + +int32_t spine_skeleton_data_get_num_path_constraints(spine_skeleton_data obj) { + if (!obj) return 0; + SkeletonData *_obj = (SkeletonData *) obj; + return (int32_t) _obj->getPathConstraints().size(); +} + +spine_path_constraint_data *spine_skeleton_data_get_path_constraints(spine_skeleton_data obj) { + if (!obj) return nullptr; + SkeletonData *_obj = (SkeletonData *) obj; + return (spine_path_constraint_data *) _obj->getPathConstraints().buffer(); +} + +void * spine_skeleton_data_get_physics_constraints(spine_skeleton_data obj) { + if (!obj) return nullptr; + SkeletonData *_obj = (SkeletonData *) obj; + return (void *) _obj->getPhysicsConstraints(); +} + +int32_t spine_skeleton_data_get_num_physics_constraints(spine_skeleton_data obj) { + if (!obj) return 0; + SkeletonData *_obj = (SkeletonData *) obj; + return (int32_t) _obj->getPhysicsConstraints().size(); +} + +spine_physics_constraint_data *spine_skeleton_data_get_physics_constraints(spine_skeleton_data obj) { + if (!obj) return nullptr; + SkeletonData *_obj = (SkeletonData *) obj; + return (spine_physics_constraint_data *) _obj->getPhysicsConstraints().buffer(); +} + +void * spine_skeleton_data_get_constraints(spine_skeleton_data obj) { + if (!obj) return nullptr; + SkeletonData *_obj = (SkeletonData *) obj; + return (void *) _obj->getConstraints(); +} + +int32_t spine_skeleton_data_get_num_constraints(spine_skeleton_data obj) { + if (!obj) return 0; + SkeletonData *_obj = (SkeletonData *) obj; + return (int32_t) _obj->getConstraints().size(); +} + +spine_constraint_data *spine_skeleton_data_get_constraints(spine_skeleton_data obj) { + if (!obj) return nullptr; + SkeletonData *_obj = (SkeletonData *) obj; + return (spine_constraint_data *) _obj->getConstraints().buffer(); +} + +float spine_skeleton_data_get_x(spine_skeleton_data obj) { + if (!obj) return 0; + SkeletonData *_obj = (SkeletonData *) obj; + return _obj->getX(); +} + +void spine_skeleton_data_set_x(spine_skeleton_data obj, float value) { + if (!obj) return; + SkeletonData *_obj = (SkeletonData *) obj; + _obj->setX(value); +} + +float spine_skeleton_data_get_y(spine_skeleton_data obj) { + if (!obj) return 0; + SkeletonData *_obj = (SkeletonData *) obj; + return _obj->getY(); +} + +void spine_skeleton_data_set_y(spine_skeleton_data obj, float value) { + if (!obj) return; + SkeletonData *_obj = (SkeletonData *) obj; + _obj->setY(value); +} + +float spine_skeleton_data_get_width(spine_skeleton_data obj) { + if (!obj) return 0; + SkeletonData *_obj = (SkeletonData *) obj; + return _obj->getWidth(); +} + +void spine_skeleton_data_set_width(spine_skeleton_data obj, float value) { + if (!obj) return; + SkeletonData *_obj = (SkeletonData *) obj; + _obj->setWidth(value); +} + +float spine_skeleton_data_get_height(spine_skeleton_data obj) { + if (!obj) return 0; + SkeletonData *_obj = (SkeletonData *) obj; + return _obj->getHeight(); +} + +void spine_skeleton_data_set_height(spine_skeleton_data obj, float value) { + if (!obj) return; + SkeletonData *_obj = (SkeletonData *) obj; + _obj->setHeight(value); +} + +float spine_skeleton_data_get_reference_scale(spine_skeleton_data obj) { + if (!obj) return 0; + SkeletonData *_obj = (SkeletonData *) obj; + return _obj->getReferenceScale(); +} + +void spine_skeleton_data_set_reference_scale(spine_skeleton_data obj, float value) { + if (!obj) return; + SkeletonData *_obj = (SkeletonData *) obj; + _obj->setReferenceScale(value); +} + +const utf8 * spine_skeleton_data_get_version(spine_skeleton_data obj) { + if (!obj) return nullptr; + SkeletonData *_obj = (SkeletonData *) obj; + return (const utf8 *) _obj->getVersion().buffer(); +} + +const utf8 * spine_skeleton_data_get_hash(spine_skeleton_data obj) { + if (!obj) return nullptr; + SkeletonData *_obj = (SkeletonData *) obj; + return (const utf8 *) _obj->getHash().buffer(); +} + +const utf8 * spine_skeleton_data_get_images_path(spine_skeleton_data obj) { + if (!obj) return nullptr; + SkeletonData *_obj = (SkeletonData *) obj; + return (const utf8 *) _obj->getImagesPath().buffer(); +} + +const utf8 * spine_skeleton_data_get_audio_path(spine_skeleton_data obj) { + if (!obj) return nullptr; + SkeletonData *_obj = (SkeletonData *) obj; + return (const utf8 *) _obj->getAudioPath().buffer(); +} + +float spine_skeleton_data_get_fps(spine_skeleton_data obj) { + if (!obj) return 0; + SkeletonData *_obj = (SkeletonData *) obj; + return _obj->getFps(); +} diff --git a/spine-c-new/src/generated/skeleton_data.h b/spine-c-new/src/generated/skeleton_data.h new file mode 100644 index 000000000..367051a83 --- /dev/null +++ b/spine-c-new/src/generated/skeleton_data.h @@ -0,0 +1,105 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#ifndef SPINE_C_SKELETONDATA_H +#define SPINE_C_SKELETONDATA_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include "../custom.h" + +SPINE_OPAQUE_TYPE(spine_skeleton_data) + +SPINE_C_EXPORT spine_skeleton_data spine_skeleton_data_create(void); +SPINE_C_EXPORT void spine_skeleton_data_dispose(spine_skeleton_data obj); +SPINE_C_EXPORT spine_bone_data spine_skeleton_data_find_bone(spine_skeleton_data obj, const utf8 * boneName); +SPINE_C_EXPORT spine_slot_data spine_skeleton_data_find_slot(spine_skeleton_data obj, const utf8 * slotName); +SPINE_C_EXPORT spine_skin spine_skeleton_data_find_skin(spine_skeleton_data obj, const utf8 * skinName); +SPINE_C_EXPORT spine_spine::event_data spine_skeleton_data_find_event(spine_skeleton_data obj, const utf8 * eventDataName); +SPINE_C_EXPORT spine_animation spine_skeleton_data_find_animation(spine_skeleton_data obj, const utf8 * animationName); +SPINE_C_EXPORT spine_ik_constraint_data spine_skeleton_data_find_ik_constraint(spine_skeleton_data obj, const utf8 * constraintName); +SPINE_C_EXPORT spine_transform_constraint_data spine_skeleton_data_find_transform_constraint(spine_skeleton_data obj, const utf8 * constraintName); +SPINE_C_EXPORT spine_path_constraint_data spine_skeleton_data_find_path_constraint(spine_skeleton_data obj, const utf8 * constraintName); +SPINE_C_EXPORT spine_physics_constraint_data spine_skeleton_data_find_physics_constraint(spine_skeleton_data obj, const utf8 * constraintName); +SPINE_C_EXPORT const utf8 * spine_skeleton_data_get_name(spine_skeleton_data obj); +SPINE_C_EXPORT void * spine_skeleton_data_get_bones(spine_skeleton_data obj); +SPINE_C_EXPORT int32_t spine_skeleton_data_get_num_bones(spine_skeleton_data obj); +SPINE_C_EXPORT spine_bone_data *spine_skeleton_data_get_bones(spine_skeleton_data obj); +SPINE_C_EXPORT void * spine_skeleton_data_get_slots(spine_skeleton_data obj); +SPINE_C_EXPORT int32_t spine_skeleton_data_get_num_slots(spine_skeleton_data obj); +SPINE_C_EXPORT spine_slot_data *spine_skeleton_data_get_slots(spine_skeleton_data obj); +SPINE_C_EXPORT void * spine_skeleton_data_get_skins(spine_skeleton_data obj); +SPINE_C_EXPORT int32_t spine_skeleton_data_get_num_skins(spine_skeleton_data obj); +SPINE_C_EXPORT spine_skin *spine_skeleton_data_get_skins(spine_skeleton_data obj); +SPINE_C_EXPORT spine_skin spine_skeleton_data_get_default_skin(spine_skeleton_data obj); +SPINE_C_EXPORT void spine_skeleton_data_set_default_skin(spine_skeleton_data obj, spine_skin value); +SPINE_C_EXPORT void * spine_skeleton_data_get_events(spine_skeleton_data obj); +SPINE_C_EXPORT int32_t spine_skeleton_data_get_num_events(spine_skeleton_data obj); +SPINE_C_EXPORT spine_spine::event_data *spine_skeleton_data_get_events(spine_skeleton_data obj); +SPINE_C_EXPORT void * spine_skeleton_data_get_animations(spine_skeleton_data obj); +SPINE_C_EXPORT int32_t spine_skeleton_data_get_num_animations(spine_skeleton_data obj); +SPINE_C_EXPORT spine_animation *spine_skeleton_data_get_animations(spine_skeleton_data obj); +SPINE_C_EXPORT void * spine_skeleton_data_get_ik_constraints(spine_skeleton_data obj); +SPINE_C_EXPORT int32_t spine_skeleton_data_get_num_ik_constraints(spine_skeleton_data obj); +SPINE_C_EXPORT spine_ik_constraint_data *spine_skeleton_data_get_ik_constraints(spine_skeleton_data obj); +SPINE_C_EXPORT void * spine_skeleton_data_get_transform_constraints(spine_skeleton_data obj); +SPINE_C_EXPORT int32_t spine_skeleton_data_get_num_transform_constraints(spine_skeleton_data obj); +SPINE_C_EXPORT spine_transform_constraint_data *spine_skeleton_data_get_transform_constraints(spine_skeleton_data obj); +SPINE_C_EXPORT void * spine_skeleton_data_get_path_constraints(spine_skeleton_data obj); +SPINE_C_EXPORT int32_t spine_skeleton_data_get_num_path_constraints(spine_skeleton_data obj); +SPINE_C_EXPORT spine_path_constraint_data *spine_skeleton_data_get_path_constraints(spine_skeleton_data obj); +SPINE_C_EXPORT void * spine_skeleton_data_get_physics_constraints(spine_skeleton_data obj); +SPINE_C_EXPORT int32_t spine_skeleton_data_get_num_physics_constraints(spine_skeleton_data obj); +SPINE_C_EXPORT spine_physics_constraint_data *spine_skeleton_data_get_physics_constraints(spine_skeleton_data obj); +SPINE_C_EXPORT void * spine_skeleton_data_get_constraints(spine_skeleton_data obj); +SPINE_C_EXPORT int32_t spine_skeleton_data_get_num_constraints(spine_skeleton_data obj); +SPINE_C_EXPORT spine_constraint_data *spine_skeleton_data_get_constraints(spine_skeleton_data obj); +SPINE_C_EXPORT float spine_skeleton_data_get_x(spine_skeleton_data obj); +SPINE_C_EXPORT void spine_skeleton_data_set_x(spine_skeleton_data obj, float value); +SPINE_C_EXPORT float spine_skeleton_data_get_y(spine_skeleton_data obj); +SPINE_C_EXPORT void spine_skeleton_data_set_y(spine_skeleton_data obj, float value); +SPINE_C_EXPORT float spine_skeleton_data_get_width(spine_skeleton_data obj); +SPINE_C_EXPORT void spine_skeleton_data_set_width(spine_skeleton_data obj, float value); +SPINE_C_EXPORT float spine_skeleton_data_get_height(spine_skeleton_data obj); +SPINE_C_EXPORT void spine_skeleton_data_set_height(spine_skeleton_data obj, float value); +SPINE_C_EXPORT float spine_skeleton_data_get_reference_scale(spine_skeleton_data obj); +SPINE_C_EXPORT void spine_skeleton_data_set_reference_scale(spine_skeleton_data obj, float value); +SPINE_C_EXPORT const utf8 * spine_skeleton_data_get_version(spine_skeleton_data obj); +SPINE_C_EXPORT const utf8 * spine_skeleton_data_get_hash(spine_skeleton_data obj); +SPINE_C_EXPORT const utf8 * spine_skeleton_data_get_images_path(spine_skeleton_data obj); +SPINE_C_EXPORT const utf8 * spine_skeleton_data_get_audio_path(spine_skeleton_data obj); +SPINE_C_EXPORT float spine_skeleton_data_get_fps(spine_skeleton_data obj); + +#ifdef __cplusplus +} +#endif + +#endif // SPINE_C_SKELETONDATA_H \ No newline at end of file diff --git a/spine-c-new/src/generated/skeleton_json.cpp b/spine-c-new/src/generated/skeleton_json.cpp new file mode 100644 index 000000000..96a0e1402 --- /dev/null +++ b/spine-c-new/src/generated/skeleton_json.cpp @@ -0,0 +1,72 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#include "skeleton_json.h" +#include + +using namespace spine; + +spine_skeleton_json spine_skeleton_json_create(spine_atlas atlas) { + SkeletonJson *obj = new (__FILE__, __LINE__) SkeletonJson((Atlas *) atlas); + return (spine_skeleton_json) obj; +} + +spine_skeleton_json spine_skeleton_json_create_with_attachment_loader_bool(spine_attachment_loader attachmentLoader, spine_bool ownsLoader) { + SkeletonJson *obj = new (__FILE__, __LINE__) SkeletonJson((AttachmentLoader *) attachmentLoader, ownsLoader); + return (spine_skeleton_json) obj; +} + +void spine_skeleton_json_dispose(spine_skeleton_json obj) { + if (!obj) return; + delete (SkeletonJson *) obj; +} + +spine_skeleton_data spine_skeleton_json_read_skeleton_data_file(spine_skeleton_json obj, const utf8 * path) { + if (!obj) return nullptr; + SkeletonJson *_obj = (SkeletonJson *) obj; + return (spine_skeleton_data) _obj->readSkeletonDataFile(String(path)); +} + +spine_skeleton_data spine_skeleton_json_read_skeleton_data(spine_skeleton_json obj, const utf8 * json) { + if (!obj) return nullptr; + SkeletonJson *_obj = (SkeletonJson *) obj; + return (spine_skeleton_data) _obj->readSkeletonData((const char *) json); +} + +void spine_skeleton_json_set_scale(spine_skeleton_json obj, float value) { + if (!obj) return; + SkeletonJson *_obj = (SkeletonJson *) obj; + _obj->setScale(value); +} + +const utf8 * spine_skeleton_json_get_error(spine_skeleton_json obj) { + if (!obj) return nullptr; + SkeletonJson *_obj = (SkeletonJson *) obj; + return (const utf8 *) _obj->getError().buffer(); +} diff --git a/spine-c-new/src/generated/skeleton_json.h b/spine-c-new/src/generated/skeleton_json.h new file mode 100644 index 000000000..59783b324 --- /dev/null +++ b/spine-c-new/src/generated/skeleton_json.h @@ -0,0 +1,53 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#ifndef SPINE_C_SKELETONJSON_H +#define SPINE_C_SKELETONJSON_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include "../custom.h" + +SPINE_OPAQUE_TYPE(spine_skeleton_json) + +SPINE_C_EXPORT spine_skeleton_json spine_skeleton_json_create(spine_atlas atlas); +SPINE_C_EXPORT spine_skeleton_json spine_skeleton_json_create_with_attachment_loader_bool(spine_attachment_loader attachmentLoader, spine_bool ownsLoader); +SPINE_C_EXPORT void spine_skeleton_json_dispose(spine_skeleton_json obj); +SPINE_C_EXPORT spine_skeleton_data spine_skeleton_json_read_skeleton_data_file(spine_skeleton_json obj, const utf8 * path); +SPINE_C_EXPORT spine_skeleton_data spine_skeleton_json_read_skeleton_data(spine_skeleton_json obj, const utf8 * json); +SPINE_C_EXPORT void spine_skeleton_json_set_scale(spine_skeleton_json obj, float value); +SPINE_C_EXPORT const utf8 * spine_skeleton_json_get_error(spine_skeleton_json obj); + +#ifdef __cplusplus +} +#endif + +#endif // SPINE_C_SKELETONJSON_H \ No newline at end of file diff --git a/spine-c-new/src/generated/skeleton_renderer.cpp b/spine-c-new/src/generated/skeleton_renderer.cpp new file mode 100644 index 000000000..1f9844b79 --- /dev/null +++ b/spine-c-new/src/generated/skeleton_renderer.cpp @@ -0,0 +1,49 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#include "skeleton_renderer.h" +#include + +using namespace spine; + +spine_skeleton_renderer spine_skeleton_renderer_create(void) { + SkeletonRenderer *obj = new (__FILE__, __LINE__) SkeletonRenderer(); + return (spine_skeleton_renderer) obj; +} + +void spine_skeleton_renderer_dispose(spine_skeleton_renderer obj) { + if (!obj) return; + delete (SkeletonRenderer *) obj; +} + +spine_render_command spine_skeleton_renderer_render(spine_skeleton_renderer obj, spine_skeleton skeleton) { + if (!obj) return nullptr; + SkeletonRenderer *_obj = (SkeletonRenderer *) obj; + return (spine_render_command) _obj->render(skeleton); +} diff --git a/spine-c-new/src/generated/skeleton_renderer.h b/spine-c-new/src/generated/skeleton_renderer.h new file mode 100644 index 000000000..8289796d3 --- /dev/null +++ b/spine-c-new/src/generated/skeleton_renderer.h @@ -0,0 +1,49 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#ifndef SPINE_C_SKELETONRENDERER_H +#define SPINE_C_SKELETONRENDERER_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include "../custom.h" + +SPINE_OPAQUE_TYPE(spine_skeleton_renderer) + +SPINE_C_EXPORT spine_skeleton_renderer spine_skeleton_renderer_create(void); +SPINE_C_EXPORT void spine_skeleton_renderer_dispose(spine_skeleton_renderer obj); +SPINE_C_EXPORT spine_render_command spine_skeleton_renderer_render(spine_skeleton_renderer obj, spine_skeleton skeleton); + +#ifdef __cplusplus +} +#endif + +#endif // SPINE_C_SKELETONRENDERER_H \ No newline at end of file diff --git a/spine-c-new/src/generated/skin.cpp b/spine-c-new/src/generated/skin.cpp new file mode 100644 index 000000000..ca6e614e2 --- /dev/null +++ b/spine-c-new/src/generated/skin.cpp @@ -0,0 +1,139 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#include "skin.h" +#include + +using namespace spine; + +spine_skin spine_skin_create(const utf8 * name) { + Skin *obj = new (__FILE__, __LINE__) Skin(String(name)); + return (spine_skin) obj; +} + +void spine_skin_dispose(spine_skin obj) { + if (!obj) return; + delete (Skin *) obj; +} + +void spine_skin_set_attachment(spine_skin obj, spine_size_t slotIndex, const utf8 * name, spine_attachment attachment) { + if (!obj) return ; + Skin *_obj = (Skin *) obj; + _obj->setAttachment(slotIndex, String(name), (Attachment *) attachment); +} + +spine_attachment spine_skin_get_attachment(spine_skin obj, spine_size_t slotIndex, const utf8 * name) { + if (!obj) return nullptr; + Skin *_obj = (Skin *) obj; + return (spine_attachment) _obj->getAttachment(slotIndex, String(name)); +} + +void spine_skin_remove_attachment(spine_skin obj, spine_size_t slotIndex, const utf8 * name) { + if (!obj) return ; + Skin *_obj = (Skin *) obj; + _obj->removeAttachment(slotIndex, String(name)); +} + +void spine_skin_find_names_for_slot(spine_skin obj, spine_size_t slotIndex, void * names) { + if (!obj) return ; + Skin *_obj = (Skin *) obj; + _obj->findNamesForSlot(slotIndex, (Vector &) names); +} + +void spine_skin_find_attachments_for_slot(spine_skin obj, spine_size_t slotIndex, void * attachments) { + if (!obj) return ; + Skin *_obj = (Skin *) obj; + _obj->findAttachmentsForSlot(slotIndex, (Vector &) attachments); +} + +const utf8 * spine_skin_get_name(spine_skin obj) { + if (!obj) return nullptr; + Skin *_obj = (Skin *) obj; + return (const utf8 *) _obj->getName().buffer(); +} + +void spine_skin_add_skin(spine_skin obj, spine_skin other) { + if (!obj) return ; + Skin *_obj = (Skin *) obj; + _obj->addSkin((Skin *) other); +} + +void spine_skin_copy_skin(spine_skin obj, spine_skin other) { + if (!obj) return ; + Skin *_obj = (Skin *) obj; + _obj->copySkin((Skin *) other); +} + +spine_attachment_map::entries spine_skin_get_attachments(spine_skin obj) { + if (!obj) return nullptr; + Skin *_obj = (Skin *) obj; + return _obj->getAttachments(); +} + +void * spine_skin_get_bones(spine_skin obj) { + if (!obj) return nullptr; + Skin *_obj = (Skin *) obj; + return (void *) _obj->getBones(); +} + +int32_t spine_skin_get_num_bones(spine_skin obj) { + if (!obj) return 0; + Skin *_obj = (Skin *) obj; + return (int32_t) _obj->getBones().size(); +} + +spine_bone_data *spine_skin_get_bones(spine_skin obj) { + if (!obj) return nullptr; + Skin *_obj = (Skin *) obj; + return (spine_bone_data *) _obj->getBones().buffer(); +} + +void * spine_skin_get_constraints(spine_skin obj) { + if (!obj) return nullptr; + Skin *_obj = (Skin *) obj; + return (void *) _obj->getConstraints(); +} + +int32_t spine_skin_get_num_constraints(spine_skin obj) { + if (!obj) return 0; + Skin *_obj = (Skin *) obj; + return (int32_t) _obj->getConstraints().size(); +} + +spine_constraint_data *spine_skin_get_constraints(spine_skin obj) { + if (!obj) return nullptr; + Skin *_obj = (Skin *) obj; + return (spine_constraint_data *) _obj->getConstraints().buffer(); +} + +spine_color spine_skin_get_color(spine_skin obj) { + if (!obj) return nullptr; + Skin *_obj = (Skin *) obj; + return (spine_color) &_obj->getColor(); +} diff --git a/spine-c-new/src/generated/skin.h b/spine-c-new/src/generated/skin.h new file mode 100644 index 000000000..803411efa --- /dev/null +++ b/spine-c-new/src/generated/skin.h @@ -0,0 +1,64 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#ifndef SPINE_C_SKIN_H +#define SPINE_C_SKIN_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include "../custom.h" + +SPINE_OPAQUE_TYPE(spine_skin) + +SPINE_C_EXPORT spine_skin spine_skin_create(const utf8 * name); +SPINE_C_EXPORT void spine_skin_dispose(spine_skin obj); +SPINE_C_EXPORT void spine_skin_set_attachment(spine_skin obj, spine_size_t slotIndex, const utf8 * name, spine_attachment attachment); +SPINE_C_EXPORT spine_attachment spine_skin_get_attachment(spine_skin obj, spine_size_t slotIndex, const utf8 * name); +SPINE_C_EXPORT void spine_skin_remove_attachment(spine_skin obj, spine_size_t slotIndex, const utf8 * name); +SPINE_C_EXPORT void spine_skin_find_names_for_slot(spine_skin obj, spine_size_t slotIndex, void * names); +SPINE_C_EXPORT void spine_skin_find_attachments_for_slot(spine_skin obj, spine_size_t slotIndex, void * attachments); +SPINE_C_EXPORT const utf8 * spine_skin_get_name(spine_skin obj); +SPINE_C_EXPORT void spine_skin_add_skin(spine_skin obj, spine_skin other); +SPINE_C_EXPORT void spine_skin_copy_skin(spine_skin obj, spine_skin other); +SPINE_C_EXPORT spine_attachment_map::entries spine_skin_get_attachments(spine_skin obj); +SPINE_C_EXPORT void * spine_skin_get_bones(spine_skin obj); +SPINE_C_EXPORT int32_t spine_skin_get_num_bones(spine_skin obj); +SPINE_C_EXPORT spine_bone_data *spine_skin_get_bones(spine_skin obj); +SPINE_C_EXPORT void * spine_skin_get_constraints(spine_skin obj); +SPINE_C_EXPORT int32_t spine_skin_get_num_constraints(spine_skin obj); +SPINE_C_EXPORT spine_constraint_data *spine_skin_get_constraints(spine_skin obj); +SPINE_C_EXPORT spine_color spine_skin_get_color(spine_skin obj); + +#ifdef __cplusplus +} +#endif + +#endif // SPINE_C_SKIN_H \ No newline at end of file diff --git a/spine-c-new/src/generated/slider.cpp b/spine-c-new/src/generated/slider.cpp new file mode 100644 index 000000000..dd8c51c04 --- /dev/null +++ b/spine-c-new/src/generated/slider.cpp @@ -0,0 +1,145 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#include "slider.h" +#include + +using namespace spine; + +spine_slider spine_slider_create(spine_slider_data data, spine_skeleton skeleton) { + Slider *obj = new (__FILE__, __LINE__) Slider(data, skeleton); + return (spine_slider) obj; +} + +void spine_slider_dispose(spine_slider obj) { + if (!obj) return; + delete (Slider *) obj; +} + +spine_rtti spine_slider_get_rtti(spine_slider obj) { + if (!obj) return nullptr; + Slider *_obj = (Slider *) obj; + return (spine_rtti) &_obj->getRTTI(); +} + +spine_slider spine_slider_copy(spine_slider obj, spine_skeleton skeleton) { + if (!obj) return nullptr; + Slider *_obj = (Slider *) obj; + return (spine_slider) _obj->copy(skeleton); +} + +void spine_slider_update(spine_slider obj, spine_skeleton skeleton, spine_physics physics) { + if (!obj) return ; + Slider *_obj = (Slider *) obj; + _obj->update(skeleton, physics); +} + +void spine_slider_sort(spine_slider obj, spine_skeleton skeleton) { + if (!obj) return ; + Slider *_obj = (Slider *) obj; + _obj->sort(skeleton); +} + +spine_bool spine_slider_is_source_active(spine_slider obj) { + if (!obj) return 0; + Slider *_obj = (Slider *) obj; + return _obj->isSourceActive(); +} + +spine_bone spine_slider_get_bone(spine_slider obj) { + if (!obj) return nullptr; + Slider *_obj = (Slider *) obj; + return (spine_bone) _obj->getBone(); +} + +void spine_slider_set_bone(spine_slider obj, spine_bone value) { + if (!obj) return; + Slider *_obj = (Slider *) obj; + _obj->setBone((Bone *) value); +} + +spine_constraint_data spine_slider_get_data(spine_slider obj) { + if (!obj) return 0; + Slider *_obj = (Slider *) obj; + return _obj->getData(); +} + +void spine_slider_pose(spine_slider obj) { + if (!obj) return ; + Slider *_obj = (Slider *) obj; + _obj->pose(); +} + +void spine_slider_setup_pose(spine_slider obj) { + if (!obj) return ; + Slider *_obj = (Slider *) obj; + _obj->setupPose(); +} + +spine_slider_pose spine_slider_get_pose(spine_slider obj) { + if (!obj) return nullptr; + Slider *_obj = (Slider *) obj; + return _obj->getPose(); +} + +spine_slider_pose spine_slider_get_applied_pose(spine_slider obj) { + if (!obj) return nullptr; + Slider *_obj = (Slider *) obj; + return _obj->getAppliedPose(); +} + +void spine_slider_reset_constrained(spine_slider obj) { + if (!obj) return ; + Slider *_obj = (Slider *) obj; + _obj->resetConstrained(); +} + +void spine_slider_constrained(spine_slider obj) { + if (!obj) return ; + Slider *_obj = (Slider *) obj; + _obj->constrained(); +} + +spine_bool spine_slider_is_pose_equal_to_applied(spine_slider obj) { + if (!obj) return 0; + Slider *_obj = (Slider *) obj; + return _obj->isPoseEqualToApplied(); +} + +spine_bool spine_slider_is_active(spine_slider obj) { + if (!obj) return 0; + Slider *_obj = (Slider *) obj; + return _obj->isActive(); +} + +void spine_slider_set_active(spine_slider obj, spine_bool value) { + if (!obj) return; + Slider *_obj = (Slider *) obj; + _obj->setActive(value); +} diff --git a/spine-c-new/src/generated/slider.h b/spine-c-new/src/generated/slider.h new file mode 100644 index 000000000..939f3f828 --- /dev/null +++ b/spine-c-new/src/generated/slider.h @@ -0,0 +1,65 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#ifndef SPINE_C_SLIDER_H +#define SPINE_C_SLIDER_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include "../custom.h" + +SPINE_OPAQUE_TYPE(spine_slider) + +SPINE_C_EXPORT spine_slider spine_slider_create(spine_slider_data data, spine_skeleton skeleton); +SPINE_C_EXPORT void spine_slider_dispose(spine_slider obj); +SPINE_C_EXPORT spine_rtti spine_slider_get_rtti(spine_slider obj); +SPINE_C_EXPORT spine_slider spine_slider_copy(spine_slider obj, spine_skeleton skeleton); +SPINE_C_EXPORT void spine_slider_update(spine_slider obj, spine_skeleton skeleton, spine_physics physics); +SPINE_C_EXPORT void spine_slider_sort(spine_slider obj, spine_skeleton skeleton); +SPINE_C_EXPORT spine_bool spine_slider_is_source_active(spine_slider obj); +SPINE_C_EXPORT spine_bone spine_slider_get_bone(spine_slider obj); +SPINE_C_EXPORT void spine_slider_set_bone(spine_slider obj, spine_bone value); +SPINE_C_EXPORT spine_constraint_data spine_slider_get_data(spine_slider obj); +SPINE_C_EXPORT void spine_slider_pose(spine_slider obj); +SPINE_C_EXPORT void spine_slider_setup_pose(spine_slider obj); +SPINE_C_EXPORT spine_slider_pose spine_slider_get_pose(spine_slider obj); +SPINE_C_EXPORT spine_slider_pose spine_slider_get_applied_pose(spine_slider obj); +SPINE_C_EXPORT void spine_slider_reset_constrained(spine_slider obj); +SPINE_C_EXPORT void spine_slider_constrained(spine_slider obj); +SPINE_C_EXPORT spine_bool spine_slider_is_pose_equal_to_applied(spine_slider obj); +SPINE_C_EXPORT spine_bool spine_slider_is_active(spine_slider obj); +SPINE_C_EXPORT void spine_slider_set_active(spine_slider obj, spine_bool value); + +#ifdef __cplusplus +} +#endif + +#endif // SPINE_C_SLIDER_H \ No newline at end of file diff --git a/spine-c-new/src/generated/slider_data.cpp b/spine-c-new/src/generated/slider_data.cpp new file mode 100644 index 000000000..6e97e44b1 --- /dev/null +++ b/spine-c-new/src/generated/slider_data.cpp @@ -0,0 +1,175 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#include "slider_data.h" +#include + +using namespace spine; + +spine_slider_data spine_slider_data_create(const utf8 * name) { + SliderData *obj = new (__FILE__, __LINE__) SliderData(String(name)); + return (spine_slider_data) obj; +} + +void spine_slider_data_dispose(spine_slider_data obj) { + if (!obj) return; + delete (SliderData *) obj; +} + +spine_rtti spine_slider_data_get_rtti(spine_slider_data obj) { + if (!obj) return nullptr; + SliderData *_obj = (SliderData *) obj; + return (spine_rtti) &_obj->getRTTI(); +} + +spine_constraint spine_slider_data_create(spine_slider_data obj, spine_skeleton skeleton) { + if (!obj) return 0; + SliderData *_obj = (SliderData *) obj; + return (spine_constraint) _obj->create(skeleton); +} + +spine_animation spine_slider_data_get_animation(spine_slider_data obj) { + if (!obj) return nullptr; + SliderData *_obj = (SliderData *) obj; + return (spine_animation) _obj->getAnimation(); +} + +void spine_slider_data_set_animation(spine_slider_data obj, spine_animation value) { + if (!obj) return; + SliderData *_obj = (SliderData *) obj; + _obj->setAnimation((Animation *) value); +} + +spine_bool spine_slider_data_get_additive(spine_slider_data obj) { + if (!obj) return 0; + SliderData *_obj = (SliderData *) obj; + return _obj->getAdditive(); +} + +void spine_slider_data_set_additive(spine_slider_data obj, spine_bool value) { + if (!obj) return; + SliderData *_obj = (SliderData *) obj; + _obj->setAdditive(value); +} + +spine_bool spine_slider_data_get_loop(spine_slider_data obj) { + if (!obj) return 0; + SliderData *_obj = (SliderData *) obj; + return _obj->getLoop(); +} + +void spine_slider_data_set_loop(spine_slider_data obj, spine_bool value) { + if (!obj) return; + SliderData *_obj = (SliderData *) obj; + _obj->setLoop(value); +} + +spine_bone_data spine_slider_data_get_bone(spine_slider_data obj) { + if (!obj) return nullptr; + SliderData *_obj = (SliderData *) obj; + return (spine_bone_data) _obj->getBone(); +} + +void spine_slider_data_set_bone(spine_slider_data obj, spine_bone_data value) { + if (!obj) return; + SliderData *_obj = (SliderData *) obj; + _obj->setBone((BoneData *) value); +} + +spine_from_property spine_slider_data_get_property(spine_slider_data obj) { + if (!obj) return nullptr; + SliderData *_obj = (SliderData *) obj; + return (spine_from_property) _obj->getProperty(); +} + +void spine_slider_data_set_property(spine_slider_data obj, spine_from_property value) { + if (!obj) return; + SliderData *_obj = (SliderData *) obj; + _obj->setProperty((FromProperty *) value); +} + +float spine_slider_data_get_scale(spine_slider_data obj) { + if (!obj) return 0; + SliderData *_obj = (SliderData *) obj; + return _obj->getScale(); +} + +void spine_slider_data_set_scale(spine_slider_data obj, float value) { + if (!obj) return; + SliderData *_obj = (SliderData *) obj; + _obj->setScale(value); +} + +float spine_slider_data_get_offset(spine_slider_data obj) { + if (!obj) return 0; + SliderData *_obj = (SliderData *) obj; + return _obj->getOffset(); +} + +void spine_slider_data_set_offset(spine_slider_data obj, float value) { + if (!obj) return; + SliderData *_obj = (SliderData *) obj; + _obj->setOffset(value); +} + +spine_bool spine_slider_data_get_local(spine_slider_data obj) { + if (!obj) return 0; + SliderData *_obj = (SliderData *) obj; + return _obj->getLocal(); +} + +void spine_slider_data_set_local(spine_slider_data obj, spine_bool value) { + if (!obj) return; + SliderData *_obj = (SliderData *) obj; + _obj->setLocal(value); +} + +const utf8 * spine_slider_data_get_name(spine_slider_data obj) { + if (!obj) return nullptr; + SliderData *_obj = (SliderData *) obj; + return (const utf8 *) _obj->getName().buffer(); +} + +spine_bool spine_slider_data_is_skin_required(spine_slider_data obj) { + if (!obj) return 0; + SliderData *_obj = (SliderData *) obj; + return _obj->isSkinRequired(); +} + +spine_slider_pose spine_slider_data_get_setup_pose(spine_slider_data obj) { + if (!obj) return nullptr; + SliderData *_obj = (SliderData *) obj; + return _obj->getSetupPose(); +} + +spine_slider_pose spine_slider_data_get_setup_pose(spine_slider_data obj) { + if (!obj) return nullptr; + SliderData *_obj = (SliderData *) obj; + return _obj->getSetupPose(); +} diff --git a/spine-c-new/src/generated/slider_data.h b/spine-c-new/src/generated/slider_data.h new file mode 100644 index 000000000..31e7a1f9a --- /dev/null +++ b/spine-c-new/src/generated/slider_data.h @@ -0,0 +1,70 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#ifndef SPINE_C_SLIDERDATA_H +#define SPINE_C_SLIDERDATA_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include "../custom.h" + +SPINE_OPAQUE_TYPE(spine_slider_data) + +SPINE_C_EXPORT spine_slider_data spine_slider_data_create(const utf8 * name); +SPINE_C_EXPORT void spine_slider_data_dispose(spine_slider_data obj); +SPINE_C_EXPORT spine_rtti spine_slider_data_get_rtti(spine_slider_data obj); +SPINE_C_EXPORT spine_constraint spine_slider_data_create(spine_slider_data obj, spine_skeleton skeleton); +SPINE_C_EXPORT spine_animation spine_slider_data_get_animation(spine_slider_data obj); +SPINE_C_EXPORT void spine_slider_data_set_animation(spine_slider_data obj, spine_animation value); +SPINE_C_EXPORT spine_bool spine_slider_data_get_additive(spine_slider_data obj); +SPINE_C_EXPORT void spine_slider_data_set_additive(spine_slider_data obj, spine_bool value); +SPINE_C_EXPORT spine_bool spine_slider_data_get_loop(spine_slider_data obj); +SPINE_C_EXPORT void spine_slider_data_set_loop(spine_slider_data obj, spine_bool value); +SPINE_C_EXPORT spine_bone_data spine_slider_data_get_bone(spine_slider_data obj); +SPINE_C_EXPORT void spine_slider_data_set_bone(spine_slider_data obj, spine_bone_data value); +SPINE_C_EXPORT spine_from_property spine_slider_data_get_property(spine_slider_data obj); +SPINE_C_EXPORT void spine_slider_data_set_property(spine_slider_data obj, spine_from_property value); +SPINE_C_EXPORT float spine_slider_data_get_scale(spine_slider_data obj); +SPINE_C_EXPORT void spine_slider_data_set_scale(spine_slider_data obj, float value); +SPINE_C_EXPORT float spine_slider_data_get_offset(spine_slider_data obj); +SPINE_C_EXPORT void spine_slider_data_set_offset(spine_slider_data obj, float value); +SPINE_C_EXPORT spine_bool spine_slider_data_get_local(spine_slider_data obj); +SPINE_C_EXPORT void spine_slider_data_set_local(spine_slider_data obj, spine_bool value); +SPINE_C_EXPORT const utf8 * spine_slider_data_get_name(spine_slider_data obj); +SPINE_C_EXPORT spine_bool spine_slider_data_is_skin_required(spine_slider_data obj); +SPINE_C_EXPORT spine_slider_pose spine_slider_data_get_setup_pose(spine_slider_data obj); +SPINE_C_EXPORT spine_slider_pose spine_slider_data_get_setup_pose(spine_slider_data obj); + +#ifdef __cplusplus +} +#endif + +#endif // SPINE_C_SLIDERDATA_H \ No newline at end of file diff --git a/spine-c-new/src/generated/slider_mix_timeline.cpp b/spine-c-new/src/generated/slider_mix_timeline.cpp new file mode 100644 index 000000000..2393522f4 --- /dev/null +++ b/spine-c-new/src/generated/slider_mix_timeline.cpp @@ -0,0 +1,103 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#include "slider_mix_timeline.h" +#include + +using namespace spine; + +spine_slider_mix_timeline spine_slider_mix_timeline_create(spine_size_t frameCount, spine_size_t bezierCount, int32_t sliderIndex) { + SliderMixTimeline *obj = new (__FILE__, __LINE__) SliderMixTimeline(frameCount, bezierCount, sliderIndex); + return (spine_slider_mix_timeline) obj; +} + +void spine_slider_mix_timeline_dispose(spine_slider_mix_timeline obj) { + if (!obj) return; + delete (SliderMixTimeline *) obj; +} + +spine_rtti spine_slider_mix_timeline_get_rtti(spine_slider_mix_timeline obj) { + if (!obj) return nullptr; + SliderMixTimeline *_obj = (SliderMixTimeline *) obj; + return (spine_rtti) &_obj->getRTTI(); +} + +void spine_slider_mix_timeline_apply(spine_slider_mix_timeline obj, spine_skeleton skeleton, float lastTime, float time, void * pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction, spine_bool appliedPose) { + if (!obj) return ; + SliderMixTimeline *_obj = (SliderMixTimeline *) obj; + _obj->apply(skeleton, lastTime, time, (Vector *) pEvents, alpha, blend, direction, appliedPose); +} + +void spine_slider_mix_timeline_set_frame(spine_slider_mix_timeline obj, spine_size_t frame, float time, float value) { + if (!obj) return ; + SliderMixTimeline *_obj = (SliderMixTimeline *) obj; + _obj->setFrame(frame, time, value); +} + +float spine_slider_mix_timeline_get_curve_value(spine_slider_mix_timeline obj, float time) { + if (!obj) return 0; + SliderMixTimeline *_obj = (SliderMixTimeline *) obj; + return _obj->getCurveValue(time); +} + +float spine_slider_mix_timeline_get_relative_value(spine_slider_mix_timeline obj, float time, float alpha, spine_mix_blend blend, float current, float setup) { + if (!obj) return 0; + SliderMixTimeline *_obj = (SliderMixTimeline *) obj; + return _obj->getRelativeValue(time, alpha, blend, current, setup); +} + +float spine_slider_mix_timeline_get_absolute_value(spine_slider_mix_timeline obj, float time, float alpha, spine_mix_blend blend, float current, float setup) { + if (!obj) return 0; + SliderMixTimeline *_obj = (SliderMixTimeline *) obj; + return _obj->getAbsoluteValue(time, alpha, blend, current, setup); +} + +float spine_slider_mix_timeline_get_absolute_value(spine_slider_mix_timeline obj, float time, float alpha, spine_mix_blend blend, float current, float setup, float value) { + if (!obj) return 0; + SliderMixTimeline *_obj = (SliderMixTimeline *) obj; + return _obj->getAbsoluteValue(time, alpha, blend, current, setup, value); +} + +float spine_slider_mix_timeline_get_scale_value(spine_slider_mix_timeline obj, float time, float alpha, spine_mix_blend blend, spine_mix_direction direction, float current, float setup) { + if (!obj) return 0; + SliderMixTimeline *_obj = (SliderMixTimeline *) obj; + return _obj->getScaleValue(time, alpha, blend, direction, current, setup); +} + +int32_t spine_slider_mix_timeline_get_constraint_index(spine_slider_mix_timeline obj) { + if (!obj) return 0; + SliderMixTimeline *_obj = (SliderMixTimeline *) obj; + return _obj->getConstraintIndex(); +} + +void spine_slider_mix_timeline_set_constraint_index(spine_slider_mix_timeline obj, int32_t value) { + if (!obj) return; + SliderMixTimeline *_obj = (SliderMixTimeline *) obj; + _obj->setConstraintIndex(value); +} diff --git a/spine-c-new/src/generated/slider_mix_timeline.h b/spine-c-new/src/generated/slider_mix_timeline.h new file mode 100644 index 000000000..7eced9180 --- /dev/null +++ b/spine-c-new/src/generated/slider_mix_timeline.h @@ -0,0 +1,58 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#ifndef SPINE_C_SLIDERMIXTIMELINE_H +#define SPINE_C_SLIDERMIXTIMELINE_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include "../custom.h" + +SPINE_OPAQUE_TYPE(spine_slider_mix_timeline) + +SPINE_C_EXPORT spine_slider_mix_timeline spine_slider_mix_timeline_create(spine_size_t frameCount, spine_size_t bezierCount, int32_t sliderIndex); +SPINE_C_EXPORT void spine_slider_mix_timeline_dispose(spine_slider_mix_timeline obj); +SPINE_C_EXPORT spine_rtti spine_slider_mix_timeline_get_rtti(spine_slider_mix_timeline obj); +SPINE_C_EXPORT void spine_slider_mix_timeline_apply(spine_slider_mix_timeline obj, spine_skeleton skeleton, float lastTime, float time, void * pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction, spine_bool appliedPose); +SPINE_C_EXPORT void spine_slider_mix_timeline_set_frame(spine_slider_mix_timeline obj, spine_size_t frame, float time, float value); +SPINE_C_EXPORT float spine_slider_mix_timeline_get_curve_value(spine_slider_mix_timeline obj, float time); +SPINE_C_EXPORT float spine_slider_mix_timeline_get_relative_value(spine_slider_mix_timeline obj, float time, float alpha, spine_mix_blend blend, float current, float setup); +SPINE_C_EXPORT float spine_slider_mix_timeline_get_absolute_value(spine_slider_mix_timeline obj, float time, float alpha, spine_mix_blend blend, float current, float setup); +SPINE_C_EXPORT float spine_slider_mix_timeline_get_absolute_value(spine_slider_mix_timeline obj, float time, float alpha, spine_mix_blend blend, float current, float setup, float value); +SPINE_C_EXPORT float spine_slider_mix_timeline_get_scale_value(spine_slider_mix_timeline obj, float time, float alpha, spine_mix_blend blend, spine_mix_direction direction, float current, float setup); +SPINE_C_EXPORT int32_t spine_slider_mix_timeline_get_constraint_index(spine_slider_mix_timeline obj); +SPINE_C_EXPORT void spine_slider_mix_timeline_set_constraint_index(spine_slider_mix_timeline obj, int32_t value); + +#ifdef __cplusplus +} +#endif + +#endif // SPINE_C_SLIDERMIXTIMELINE_H \ No newline at end of file diff --git a/spine-c-new/src/generated/slider_pose.cpp b/spine-c-new/src/generated/slider_pose.cpp new file mode 100644 index 000000000..9ad6fb457 --- /dev/null +++ b/spine-c-new/src/generated/slider_pose.cpp @@ -0,0 +1,73 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#include "slider_pose.h" +#include + +using namespace spine; + +spine_slider_pose spine_slider_pose_create(void) { + SliderPose *obj = new (__FILE__, __LINE__) SliderPose(); + return (spine_slider_pose) obj; +} + +void spine_slider_pose_dispose(spine_slider_pose obj) { + if (!obj) return; + delete (SliderPose *) obj; +} + +void spine_slider_pose_set(spine_slider_pose obj, spine_slider_pose value) { + if (!obj) return; + SliderPose *_obj = (SliderPose *) obj; + _obj->set(value); +} + +float spine_slider_pose_get_time(spine_slider_pose obj) { + if (!obj) return 0; + SliderPose *_obj = (SliderPose *) obj; + return _obj->getTime(); +} + +void spine_slider_pose_set_time(spine_slider_pose obj, float value) { + if (!obj) return; + SliderPose *_obj = (SliderPose *) obj; + _obj->setTime(value); +} + +float spine_slider_pose_get_mix(spine_slider_pose obj) { + if (!obj) return 0; + SliderPose *_obj = (SliderPose *) obj; + return _obj->getMix(); +} + +void spine_slider_pose_set_mix(spine_slider_pose obj, float value) { + if (!obj) return; + SliderPose *_obj = (SliderPose *) obj; + _obj->setMix(value); +} diff --git a/spine-c-new/src/generated/slider_pose.h b/spine-c-new/src/generated/slider_pose.h new file mode 100644 index 000000000..b71bec6df --- /dev/null +++ b/spine-c-new/src/generated/slider_pose.h @@ -0,0 +1,53 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#ifndef SPINE_C_SLIDERPOSE_H +#define SPINE_C_SLIDERPOSE_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include "../custom.h" + +SPINE_OPAQUE_TYPE(spine_slider_pose) + +SPINE_C_EXPORT spine_slider_pose spine_slider_pose_create(void); +SPINE_C_EXPORT void spine_slider_pose_dispose(spine_slider_pose obj); +SPINE_C_EXPORT void spine_slider_pose_set(spine_slider_pose obj, spine_slider_pose value); +SPINE_C_EXPORT float spine_slider_pose_get_time(spine_slider_pose obj); +SPINE_C_EXPORT void spine_slider_pose_set_time(spine_slider_pose obj, float value); +SPINE_C_EXPORT float spine_slider_pose_get_mix(spine_slider_pose obj); +SPINE_C_EXPORT void spine_slider_pose_set_mix(spine_slider_pose obj, float value); + +#ifdef __cplusplus +} +#endif + +#endif // SPINE_C_SLIDERPOSE_H \ No newline at end of file diff --git a/spine-c-new/src/generated/slider_timeline.cpp b/spine-c-new/src/generated/slider_timeline.cpp new file mode 100644 index 000000000..155e114b7 --- /dev/null +++ b/spine-c-new/src/generated/slider_timeline.cpp @@ -0,0 +1,103 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#include "slider_timeline.h" +#include + +using namespace spine; + +spine_slider_timeline spine_slider_timeline_create(spine_size_t frameCount, spine_size_t bezierCount, int32_t sliderIndex) { + SliderTimeline *obj = new (__FILE__, __LINE__) SliderTimeline(frameCount, bezierCount, sliderIndex); + return (spine_slider_timeline) obj; +} + +void spine_slider_timeline_dispose(spine_slider_timeline obj) { + if (!obj) return; + delete (SliderTimeline *) obj; +} + +spine_rtti spine_slider_timeline_get_rtti(spine_slider_timeline obj) { + if (!obj) return nullptr; + SliderTimeline *_obj = (SliderTimeline *) obj; + return (spine_rtti) &_obj->getRTTI(); +} + +void spine_slider_timeline_apply(spine_slider_timeline obj, spine_skeleton skeleton, float lastTime, float time, void * pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction, spine_bool appliedPose) { + if (!obj) return ; + SliderTimeline *_obj = (SliderTimeline *) obj; + _obj->apply(skeleton, lastTime, time, (Vector *) pEvents, alpha, blend, direction, appliedPose); +} + +void spine_slider_timeline_set_frame(spine_slider_timeline obj, spine_size_t frame, float time, float value) { + if (!obj) return ; + SliderTimeline *_obj = (SliderTimeline *) obj; + _obj->setFrame(frame, time, value); +} + +float spine_slider_timeline_get_curve_value(spine_slider_timeline obj, float time) { + if (!obj) return 0; + SliderTimeline *_obj = (SliderTimeline *) obj; + return _obj->getCurveValue(time); +} + +float spine_slider_timeline_get_relative_value(spine_slider_timeline obj, float time, float alpha, spine_mix_blend blend, float current, float setup) { + if (!obj) return 0; + SliderTimeline *_obj = (SliderTimeline *) obj; + return _obj->getRelativeValue(time, alpha, blend, current, setup); +} + +float spine_slider_timeline_get_absolute_value(spine_slider_timeline obj, float time, float alpha, spine_mix_blend blend, float current, float setup) { + if (!obj) return 0; + SliderTimeline *_obj = (SliderTimeline *) obj; + return _obj->getAbsoluteValue(time, alpha, blend, current, setup); +} + +float spine_slider_timeline_get_absolute_value(spine_slider_timeline obj, float time, float alpha, spine_mix_blend blend, float current, float setup, float value) { + if (!obj) return 0; + SliderTimeline *_obj = (SliderTimeline *) obj; + return _obj->getAbsoluteValue(time, alpha, blend, current, setup, value); +} + +float spine_slider_timeline_get_scale_value(spine_slider_timeline obj, float time, float alpha, spine_mix_blend blend, spine_mix_direction direction, float current, float setup) { + if (!obj) return 0; + SliderTimeline *_obj = (SliderTimeline *) obj; + return _obj->getScaleValue(time, alpha, blend, direction, current, setup); +} + +int32_t spine_slider_timeline_get_constraint_index(spine_slider_timeline obj) { + if (!obj) return 0; + SliderTimeline *_obj = (SliderTimeline *) obj; + return _obj->getConstraintIndex(); +} + +void spine_slider_timeline_set_constraint_index(spine_slider_timeline obj, int32_t value) { + if (!obj) return; + SliderTimeline *_obj = (SliderTimeline *) obj; + _obj->setConstraintIndex(value); +} diff --git a/spine-c-new/src/generated/slider_timeline.h b/spine-c-new/src/generated/slider_timeline.h new file mode 100644 index 000000000..3c0590888 --- /dev/null +++ b/spine-c-new/src/generated/slider_timeline.h @@ -0,0 +1,58 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#ifndef SPINE_C_SLIDERTIMELINE_H +#define SPINE_C_SLIDERTIMELINE_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include "../custom.h" + +SPINE_OPAQUE_TYPE(spine_slider_timeline) + +SPINE_C_EXPORT spine_slider_timeline spine_slider_timeline_create(spine_size_t frameCount, spine_size_t bezierCount, int32_t sliderIndex); +SPINE_C_EXPORT void spine_slider_timeline_dispose(spine_slider_timeline obj); +SPINE_C_EXPORT spine_rtti spine_slider_timeline_get_rtti(spine_slider_timeline obj); +SPINE_C_EXPORT void spine_slider_timeline_apply(spine_slider_timeline obj, spine_skeleton skeleton, float lastTime, float time, void * pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction, spine_bool appliedPose); +SPINE_C_EXPORT void spine_slider_timeline_set_frame(spine_slider_timeline obj, spine_size_t frame, float time, float value); +SPINE_C_EXPORT float spine_slider_timeline_get_curve_value(spine_slider_timeline obj, float time); +SPINE_C_EXPORT float spine_slider_timeline_get_relative_value(spine_slider_timeline obj, float time, float alpha, spine_mix_blend blend, float current, float setup); +SPINE_C_EXPORT float spine_slider_timeline_get_absolute_value(spine_slider_timeline obj, float time, float alpha, spine_mix_blend blend, float current, float setup); +SPINE_C_EXPORT float spine_slider_timeline_get_absolute_value(spine_slider_timeline obj, float time, float alpha, spine_mix_blend blend, float current, float setup, float value); +SPINE_C_EXPORT float spine_slider_timeline_get_scale_value(spine_slider_timeline obj, float time, float alpha, spine_mix_blend blend, spine_mix_direction direction, float current, float setup); +SPINE_C_EXPORT int32_t spine_slider_timeline_get_constraint_index(spine_slider_timeline obj); +SPINE_C_EXPORT void spine_slider_timeline_set_constraint_index(spine_slider_timeline obj, int32_t value); + +#ifdef __cplusplus +} +#endif + +#endif // SPINE_C_SLIDERTIMELINE_H \ No newline at end of file diff --git a/spine-c-new/src/generated/slot.cpp b/spine-c-new/src/generated/slot.cpp new file mode 100644 index 000000000..5665ea607 --- /dev/null +++ b/spine-c-new/src/generated/slot.cpp @@ -0,0 +1,97 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#include "slot.h" +#include + +using namespace spine; + +spine_slot spine_slot_create(spine_slot_data data, spine_skeleton skeleton) { + Slot *obj = new (__FILE__, __LINE__) Slot(data, skeleton); + return (spine_slot) obj; +} + +void spine_slot_dispose(spine_slot obj) { + if (!obj) return; + delete (Slot *) obj; +} + +spine_bone spine_slot_get_bone(spine_slot obj) { + if (!obj) return nullptr; + Slot *_obj = (Slot *) obj; + return _obj->getBone(); +} + +void spine_slot_setup_pose(spine_slot obj) { + if (!obj) return ; + Slot *_obj = (Slot *) obj; + _obj->setupPose(); +} + +spine_slot_data spine_slot_get_data(spine_slot obj) { + if (!obj) return nullptr; + Slot *_obj = (Slot *) obj; + return _obj->getData(); +} + +spine_slot_pose spine_slot_get_pose(spine_slot obj) { + if (!obj) return nullptr; + Slot *_obj = (Slot *) obj; + return _obj->getPose(); +} + +spine_slot_pose spine_slot_get_applied_pose(spine_slot obj) { + if (!obj) return nullptr; + Slot *_obj = (Slot *) obj; + return _obj->getAppliedPose(); +} + +void spine_slot_reset_constrained(spine_slot obj) { + if (!obj) return ; + Slot *_obj = (Slot *) obj; + _obj->resetConstrained(); +} + +void spine_slot_pose(spine_slot obj) { + if (!obj) return ; + Slot *_obj = (Slot *) obj; + _obj->pose(); +} + +void spine_slot_constrained(spine_slot obj) { + if (!obj) return ; + Slot *_obj = (Slot *) obj; + _obj->constrained(); +} + +spine_bool spine_slot_is_pose_equal_to_applied(spine_slot obj) { + if (!obj) return 0; + Slot *_obj = (Slot *) obj; + return _obj->isPoseEqualToApplied(); +} diff --git a/spine-c-new/src/generated/slot.h b/spine-c-new/src/generated/slot.h new file mode 100644 index 000000000..4530f54f4 --- /dev/null +++ b/spine-c-new/src/generated/slot.h @@ -0,0 +1,57 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#ifndef SPINE_C_SLOT_H +#define SPINE_C_SLOT_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include "../custom.h" + +SPINE_OPAQUE_TYPE(spine_slot) + +SPINE_C_EXPORT spine_slot spine_slot_create(spine_slot_data data, spine_skeleton skeleton); +SPINE_C_EXPORT void spine_slot_dispose(spine_slot obj); +SPINE_C_EXPORT spine_bone spine_slot_get_bone(spine_slot obj); +SPINE_C_EXPORT void spine_slot_setup_pose(spine_slot obj); +SPINE_C_EXPORT spine_slot_data spine_slot_get_data(spine_slot obj); +SPINE_C_EXPORT spine_slot_pose spine_slot_get_pose(spine_slot obj); +SPINE_C_EXPORT spine_slot_pose spine_slot_get_applied_pose(spine_slot obj); +SPINE_C_EXPORT void spine_slot_reset_constrained(spine_slot obj); +SPINE_C_EXPORT void spine_slot_pose(spine_slot obj); +SPINE_C_EXPORT void spine_slot_constrained(spine_slot obj); +SPINE_C_EXPORT spine_bool spine_slot_is_pose_equal_to_applied(spine_slot obj); + +#ifdef __cplusplus +} +#endif + +#endif // SPINE_C_SLOT_H \ No newline at end of file diff --git a/spine-c-new/src/generated/slot_curve_timeline.cpp b/spine-c-new/src/generated/slot_curve_timeline.cpp new file mode 100644 index 000000000..ab1c05036 --- /dev/null +++ b/spine-c-new/src/generated/slot_curve_timeline.cpp @@ -0,0 +1,163 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#include "slot_curve_timeline.h" +#include + +using namespace spine; + +spine_slot_curve_timeline spine_slot_curve_timeline_create(spine_size_t frameCount, spine_size_t frameEntries, spine_size_t bezierCount, int32_t slotIndex) { + SlotCurveTimeline *obj = new (__FILE__, __LINE__) SlotCurveTimeline(frameCount, frameEntries, bezierCount, slotIndex); + return (spine_slot_curve_timeline) obj; +} + +void spine_slot_curve_timeline_dispose(spine_slot_curve_timeline obj) { + if (!obj) return; + delete (SlotCurveTimeline *) obj; +} + +spine_rtti spine_slot_curve_timeline_get_rtti(spine_slot_curve_timeline obj) { + if (!obj) return nullptr; + SlotCurveTimeline *_obj = (SlotCurveTimeline *) obj; + return (spine_rtti) &_obj->getRTTI(); +} + +void spine_slot_curve_timeline_apply(spine_slot_curve_timeline obj, spine_skeleton skeleton, float lastTime, float time, void * pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction, spine_bool appliedPose) { + if (!obj) return ; + SlotCurveTimeline *_obj = (SlotCurveTimeline *) obj; + _obj->apply(skeleton, lastTime, time, (Vector *) pEvents, alpha, blend, direction, appliedPose); +} + +void spine_slot_curve_timeline_set_linear(spine_slot_curve_timeline obj, spine_size_t value) { + if (!obj) return; + SlotCurveTimeline *_obj = (SlotCurveTimeline *) obj; + _obj->setLinear(value); +} + +void spine_slot_curve_timeline_set_stepped(spine_slot_curve_timeline obj, spine_size_t value) { + if (!obj) return; + SlotCurveTimeline *_obj = (SlotCurveTimeline *) obj; + _obj->setStepped(value); +} + +void spine_slot_curve_timeline_set_bezier(spine_slot_curve_timeline obj, spine_size_t bezier, spine_size_t frame, float value, float time1, float value1, float cx1, float cy1, float cx2, float cy2, float time2, float value2) { + if (!obj) return ; + SlotCurveTimeline *_obj = (SlotCurveTimeline *) obj; + _obj->setBezier(bezier, frame, value, time1, value1, cx1, cy1, cx2, cy2, time2, value2); +} + +float spine_slot_curve_timeline_get_bezier_value(spine_slot_curve_timeline obj, float time, spine_size_t frame, spine_size_t valueOffset, spine_size_t i) { + if (!obj) return 0; + SlotCurveTimeline *_obj = (SlotCurveTimeline *) obj; + return _obj->getBezierValue(time, frame, valueOffset, i); +} + +void * spine_slot_curve_timeline_get_curves(spine_slot_curve_timeline obj) { + if (!obj) return nullptr; + SlotCurveTimeline *_obj = (SlotCurveTimeline *) obj; + return _obj->getCurves(); +} + +int32_t spine_slot_curve_timeline_get_num_curves(spine_slot_curve_timeline obj) { + if (!obj) return 0; + SlotCurveTimeline *_obj = (SlotCurveTimeline *) obj; + return (int32_t) _obj->getCurves().size(); +} + +spine_float *spine_slot_curve_timeline_get_curves(spine_slot_curve_timeline obj) { + if (!obj) return nullptr; + SlotCurveTimeline *_obj = (SlotCurveTimeline *) obj; + return (spine_float *) _obj->getCurves().buffer(); +} + +spine_size_t spine_slot_curve_timeline_get_frame_entries(spine_slot_curve_timeline obj) { + if (!obj) return nullptr; + SlotCurveTimeline *_obj = (SlotCurveTimeline *) obj; + return _obj->getFrameEntries(); +} + +spine_size_t spine_slot_curve_timeline_get_frame_count(spine_slot_curve_timeline obj) { + if (!obj) return nullptr; + SlotCurveTimeline *_obj = (SlotCurveTimeline *) obj; + return _obj->getFrameCount(); +} + +void * spine_slot_curve_timeline_get_frames(spine_slot_curve_timeline obj) { + if (!obj) return nullptr; + SlotCurveTimeline *_obj = (SlotCurveTimeline *) obj; + return _obj->getFrames(); +} + +int32_t spine_slot_curve_timeline_get_num_frames(spine_slot_curve_timeline obj) { + if (!obj) return 0; + SlotCurveTimeline *_obj = (SlotCurveTimeline *) obj; + return (int32_t) _obj->getFrames().size(); +} + +spine_float *spine_slot_curve_timeline_get_frames(spine_slot_curve_timeline obj) { + if (!obj) return nullptr; + SlotCurveTimeline *_obj = (SlotCurveTimeline *) obj; + return (spine_float *) _obj->getFrames().buffer(); +} + +float spine_slot_curve_timeline_get_duration(spine_slot_curve_timeline obj) { + if (!obj) return 0; + SlotCurveTimeline *_obj = (SlotCurveTimeline *) obj; + return _obj->getDuration(); +} + +void * spine_slot_curve_timeline_get_property_ids(spine_slot_curve_timeline obj) { + if (!obj) return nullptr; + SlotCurveTimeline *_obj = (SlotCurveTimeline *) obj; + return _obj->getPropertyIds(); +} + +int32_t spine_slot_curve_timeline_get_num_property_ids(spine_slot_curve_timeline obj) { + if (!obj) return 0; + SlotCurveTimeline *_obj = (SlotCurveTimeline *) obj; + return (int32_t) _obj->getPropertyIds().size(); +} + +spine_property_id *spine_slot_curve_timeline_get_property_ids(spine_slot_curve_timeline obj) { + if (!obj) return nullptr; + SlotCurveTimeline *_obj = (SlotCurveTimeline *) obj; + return (spine_property_id *) _obj->getPropertyIds().buffer(); +} + +int32_t spine_slot_curve_timeline_get_slot_index(spine_slot_curve_timeline obj) { + if (!obj) return 0; + SlotCurveTimeline *_obj = (SlotCurveTimeline *) obj; + return _obj->getSlotIndex(); +} + +void spine_slot_curve_timeline_set_slot_index(spine_slot_curve_timeline obj, int32_t value) { + if (!obj) return; + SlotCurveTimeline *_obj = (SlotCurveTimeline *) obj; + _obj->setSlotIndex(value); +} diff --git a/spine-c-new/src/generated/slot_curve_timeline.h b/spine-c-new/src/generated/slot_curve_timeline.h new file mode 100644 index 000000000..8db621c12 --- /dev/null +++ b/spine-c-new/src/generated/slot_curve_timeline.h @@ -0,0 +1,68 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#ifndef SPINE_C_SLOTCURVETIMELINE_H +#define SPINE_C_SLOTCURVETIMELINE_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include "../custom.h" + +SPINE_OPAQUE_TYPE(spine_slot_curve_timeline) + +SPINE_C_EXPORT spine_slot_curve_timeline spine_slot_curve_timeline_create(spine_size_t frameCount, spine_size_t frameEntries, spine_size_t bezierCount, int32_t slotIndex); +SPINE_C_EXPORT void spine_slot_curve_timeline_dispose(spine_slot_curve_timeline obj); +SPINE_C_EXPORT spine_rtti spine_slot_curve_timeline_get_rtti(spine_slot_curve_timeline obj); +SPINE_C_EXPORT void spine_slot_curve_timeline_apply(spine_slot_curve_timeline obj, spine_skeleton skeleton, float lastTime, float time, void * pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction, spine_bool appliedPose); +SPINE_C_EXPORT void spine_slot_curve_timeline_set_linear(spine_slot_curve_timeline obj, spine_size_t value); +SPINE_C_EXPORT void spine_slot_curve_timeline_set_stepped(spine_slot_curve_timeline obj, spine_size_t value); +SPINE_C_EXPORT void spine_slot_curve_timeline_set_bezier(spine_slot_curve_timeline obj, spine_size_t bezier, spine_size_t frame, float value, float time1, float value1, float cx1, float cy1, float cx2, float cy2, float time2, float value2); +SPINE_C_EXPORT float spine_slot_curve_timeline_get_bezier_value(spine_slot_curve_timeline obj, float time, spine_size_t frame, spine_size_t valueOffset, spine_size_t i); +SPINE_C_EXPORT void * spine_slot_curve_timeline_get_curves(spine_slot_curve_timeline obj); +SPINE_C_EXPORT int32_t spine_slot_curve_timeline_get_num_curves(spine_slot_curve_timeline obj); +SPINE_C_EXPORT spine_float *spine_slot_curve_timeline_get_curves(spine_slot_curve_timeline obj); +SPINE_C_EXPORT spine_size_t spine_slot_curve_timeline_get_frame_entries(spine_slot_curve_timeline obj); +SPINE_C_EXPORT spine_size_t spine_slot_curve_timeline_get_frame_count(spine_slot_curve_timeline obj); +SPINE_C_EXPORT void * spine_slot_curve_timeline_get_frames(spine_slot_curve_timeline obj); +SPINE_C_EXPORT int32_t spine_slot_curve_timeline_get_num_frames(spine_slot_curve_timeline obj); +SPINE_C_EXPORT spine_float *spine_slot_curve_timeline_get_frames(spine_slot_curve_timeline obj); +SPINE_C_EXPORT float spine_slot_curve_timeline_get_duration(spine_slot_curve_timeline obj); +SPINE_C_EXPORT void * spine_slot_curve_timeline_get_property_ids(spine_slot_curve_timeline obj); +SPINE_C_EXPORT int32_t spine_slot_curve_timeline_get_num_property_ids(spine_slot_curve_timeline obj); +SPINE_C_EXPORT spine_property_id *spine_slot_curve_timeline_get_property_ids(spine_slot_curve_timeline obj); +SPINE_C_EXPORT int32_t spine_slot_curve_timeline_get_slot_index(spine_slot_curve_timeline obj); +SPINE_C_EXPORT void spine_slot_curve_timeline_set_slot_index(spine_slot_curve_timeline obj, int32_t value); + +#ifdef __cplusplus +} +#endif + +#endif // SPINE_C_SLOTCURVETIMELINE_H \ No newline at end of file diff --git a/spine-c-new/src/generated/slot_data.cpp b/spine-c-new/src/generated/slot_data.cpp new file mode 100644 index 000000000..708e37bf4 --- /dev/null +++ b/spine-c-new/src/generated/slot_data.cpp @@ -0,0 +1,121 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#include "slot_data.h" +#include + +using namespace spine; + +spine_slot_data spine_slot_data_create(int32_t index, const utf8 * name, spine_bone_data boneData) { + SlotData *obj = new (__FILE__, __LINE__) SlotData(index, String(name), boneData); + return (spine_slot_data) obj; +} + +void spine_slot_data_dispose(spine_slot_data obj) { + if (!obj) return; + delete (SlotData *) obj; +} + +int32_t spine_slot_data_get_index(spine_slot_data obj) { + if (!obj) return 0; + SlotData *_obj = (SlotData *) obj; + return _obj->getIndex(); +} + +spine_bone_data spine_slot_data_get_bone_data(spine_slot_data obj) { + if (!obj) return nullptr; + SlotData *_obj = (SlotData *) obj; + return _obj->getBoneData(); +} + +void spine_slot_data_set_attachment_name(spine_slot_data obj, const utf8 * value) { + if (!obj) return; + SlotData *_obj = (SlotData *) obj; + _obj->setAttachmentName(String(value)); +} + +const utf8 * spine_slot_data_get_attachment_name(spine_slot_data obj) { + if (!obj) return nullptr; + SlotData *_obj = (SlotData *) obj; + return (const utf8 *) _obj->getAttachmentName().buffer(); +} + +spine_blend_mode spine_slot_data_get_blend_mode(spine_slot_data obj) { + if (!obj) return nullptr; + SlotData *_obj = (SlotData *) obj; + return _obj->getBlendMode(); +} + +void spine_slot_data_set_blend_mode(spine_slot_data obj, spine_blend_mode value) { + if (!obj) return; + SlotData *_obj = (SlotData *) obj; + _obj->setBlendMode(value); +} + +spine_bool spine_slot_data_get_visible(spine_slot_data obj) { + if (!obj) return 0; + SlotData *_obj = (SlotData *) obj; + return _obj->getVisible(); +} + +void spine_slot_data_set_visible(spine_slot_data obj, spine_bool value) { + if (!obj) return; + SlotData *_obj = (SlotData *) obj; + _obj->setVisible(value); +} + +spine_slot_pose spine_slot_data_get_setup_pose(spine_slot_data obj) { + if (!obj) return nullptr; + SlotData *_obj = (SlotData *) obj; + return _obj->getSetupPose(); +} + +spine_slot_pose spine_slot_data_get_setup_pose(spine_slot_data obj) { + if (!obj) return nullptr; + SlotData *_obj = (SlotData *) obj; + return _obj->getSetupPose(); +} + +spine_spine::string spine_slot_data_get_name(spine_slot_data obj) { + if (!obj) return nullptr; + SlotData *_obj = (SlotData *) obj; + return _obj->getName(); +} + +spine_bool spine_slot_data_is_skin_required(spine_slot_data obj) { + if (!obj) return 0; + SlotData *_obj = (SlotData *) obj; + return _obj->isSkinRequired(); +} + +void spine_slot_data_set_skin_required(spine_slot_data obj, spine_bool value) { + if (!obj) return; + SlotData *_obj = (SlotData *) obj; + _obj->setSkinRequired(value); +} diff --git a/spine-c-new/src/generated/slot_data.h b/spine-c-new/src/generated/slot_data.h new file mode 100644 index 000000000..7859f02ff --- /dev/null +++ b/spine-c-new/src/generated/slot_data.h @@ -0,0 +1,61 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#ifndef SPINE_C_SLOTDATA_H +#define SPINE_C_SLOTDATA_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include "../custom.h" + +SPINE_OPAQUE_TYPE(spine_slot_data) + +SPINE_C_EXPORT spine_slot_data spine_slot_data_create(int32_t index, const utf8 * name, spine_bone_data boneData); +SPINE_C_EXPORT void spine_slot_data_dispose(spine_slot_data obj); +SPINE_C_EXPORT int32_t spine_slot_data_get_index(spine_slot_data obj); +SPINE_C_EXPORT spine_bone_data spine_slot_data_get_bone_data(spine_slot_data obj); +SPINE_C_EXPORT void spine_slot_data_set_attachment_name(spine_slot_data obj, const utf8 * value); +SPINE_C_EXPORT const utf8 * spine_slot_data_get_attachment_name(spine_slot_data obj); +SPINE_C_EXPORT spine_blend_mode spine_slot_data_get_blend_mode(spine_slot_data obj); +SPINE_C_EXPORT void spine_slot_data_set_blend_mode(spine_slot_data obj, spine_blend_mode value); +SPINE_C_EXPORT spine_bool spine_slot_data_get_visible(spine_slot_data obj); +SPINE_C_EXPORT void spine_slot_data_set_visible(spine_slot_data obj, spine_bool value); +SPINE_C_EXPORT spine_slot_pose spine_slot_data_get_setup_pose(spine_slot_data obj); +SPINE_C_EXPORT spine_slot_pose spine_slot_data_get_setup_pose(spine_slot_data obj); +SPINE_C_EXPORT spine_spine::string spine_slot_data_get_name(spine_slot_data obj); +SPINE_C_EXPORT spine_bool spine_slot_data_is_skin_required(spine_slot_data obj); +SPINE_C_EXPORT void spine_slot_data_set_skin_required(spine_slot_data obj, spine_bool value); + +#ifdef __cplusplus +} +#endif + +#endif // SPINE_C_SLOTDATA_H \ No newline at end of file diff --git a/spine-c-new/src/generated/slot_pose.cpp b/spine-c-new/src/generated/slot_pose.cpp new file mode 100644 index 000000000..264d63e11 --- /dev/null +++ b/spine-c-new/src/generated/slot_pose.cpp @@ -0,0 +1,115 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#include "slot_pose.h" +#include + +using namespace spine; + +spine_slot_pose spine_slot_pose_create(void) { + SlotPose *obj = new (__FILE__, __LINE__) SlotPose(); + return (spine_slot_pose) obj; +} + +void spine_slot_pose_dispose(spine_slot_pose obj) { + if (!obj) return; + delete (SlotPose *) obj; +} + +void spine_slot_pose_set(spine_slot_pose obj, spine_slot_pose value) { + if (!obj) return; + SlotPose *_obj = (SlotPose *) obj; + _obj->set(value); +} + +spine_color spine_slot_pose_get_color(spine_slot_pose obj) { + if (!obj) return nullptr; + SlotPose *_obj = (SlotPose *) obj; + return (spine_color) &_obj->getColor(); +} + +spine_color spine_slot_pose_get_dark_color(spine_slot_pose obj) { + if (!obj) return nullptr; + SlotPose *_obj = (SlotPose *) obj; + return (spine_color) &_obj->getDarkColor(); +} + +spine_bool spine_slot_pose_has_dark_color(spine_slot_pose obj) { + if (!obj) return 0; + SlotPose *_obj = (SlotPose *) obj; + return _obj->hasDarkColor(); +} + +void spine_slot_pose_set_has_dark_color(spine_slot_pose obj, spine_bool value) { + if (!obj) return; + SlotPose *_obj = (SlotPose *) obj; + _obj->setHasDarkColor(value); +} + +spine_attachment spine_slot_pose_get_attachment(spine_slot_pose obj) { + if (!obj) return nullptr; + SlotPose *_obj = (SlotPose *) obj; + return (spine_attachment) _obj->getAttachment(); +} + +void spine_slot_pose_set_attachment(spine_slot_pose obj, spine_attachment value) { + if (!obj) return; + SlotPose *_obj = (SlotPose *) obj; + _obj->setAttachment((Attachment *) value); +} + +int32_t spine_slot_pose_get_sequence_index(spine_slot_pose obj) { + if (!obj) return 0; + SlotPose *_obj = (SlotPose *) obj; + return _obj->getSequenceIndex(); +} + +void spine_slot_pose_set_sequence_index(spine_slot_pose obj, int32_t value) { + if (!obj) return; + SlotPose *_obj = (SlotPose *) obj; + _obj->setSequenceIndex(value); +} + +void * spine_slot_pose_get_deform(spine_slot_pose obj) { + if (!obj) return nullptr; + SlotPose *_obj = (SlotPose *) obj; + return _obj->getDeform(); +} + +int32_t spine_slot_pose_get_num_deform(spine_slot_pose obj) { + if (!obj) return 0; + SlotPose *_obj = (SlotPose *) obj; + return (int32_t) _obj->getDeform().size(); +} + +spine_float *spine_slot_pose_get_deform(spine_slot_pose obj) { + if (!obj) return nullptr; + SlotPose *_obj = (SlotPose *) obj; + return (spine_float *) _obj->getDeform().buffer(); +} diff --git a/spine-c-new/src/generated/slot_pose.h b/spine-c-new/src/generated/slot_pose.h new file mode 100644 index 000000000..9344a4a82 --- /dev/null +++ b/spine-c-new/src/generated/slot_pose.h @@ -0,0 +1,60 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#ifndef SPINE_C_SLOTPOSE_H +#define SPINE_C_SLOTPOSE_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include "../custom.h" + +SPINE_OPAQUE_TYPE(spine_slot_pose) + +SPINE_C_EXPORT spine_slot_pose spine_slot_pose_create(void); +SPINE_C_EXPORT void spine_slot_pose_dispose(spine_slot_pose obj); +SPINE_C_EXPORT void spine_slot_pose_set(spine_slot_pose obj, spine_slot_pose value); +SPINE_C_EXPORT spine_color spine_slot_pose_get_color(spine_slot_pose obj); +SPINE_C_EXPORT spine_color spine_slot_pose_get_dark_color(spine_slot_pose obj); +SPINE_C_EXPORT spine_bool spine_slot_pose_has_dark_color(spine_slot_pose obj); +SPINE_C_EXPORT void spine_slot_pose_set_has_dark_color(spine_slot_pose obj, spine_bool value); +SPINE_C_EXPORT spine_attachment spine_slot_pose_get_attachment(spine_slot_pose obj); +SPINE_C_EXPORT void spine_slot_pose_set_attachment(spine_slot_pose obj, spine_attachment value); +SPINE_C_EXPORT int32_t spine_slot_pose_get_sequence_index(spine_slot_pose obj); +SPINE_C_EXPORT void spine_slot_pose_set_sequence_index(spine_slot_pose obj, int32_t value); +SPINE_C_EXPORT void * spine_slot_pose_get_deform(spine_slot_pose obj); +SPINE_C_EXPORT int32_t spine_slot_pose_get_num_deform(spine_slot_pose obj); +SPINE_C_EXPORT spine_float *spine_slot_pose_get_deform(spine_slot_pose obj); + +#ifdef __cplusplus +} +#endif + +#endif // SPINE_C_SLOTPOSE_H \ No newline at end of file diff --git a/spine-c-new/src/generated/slot_timeline.cpp b/spine-c-new/src/generated/slot_timeline.cpp new file mode 100644 index 000000000..af59724f2 --- /dev/null +++ b/spine-c-new/src/generated/slot_timeline.cpp @@ -0,0 +1,61 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#include "slot_timeline.h" +#include + +using namespace spine; + +spine_slot_timeline spine_slot_timeline_create(int32_t slotIndex) { + SlotTimeline *obj = new (__FILE__, __LINE__) SlotTimeline(slotIndex); + return (spine_slot_timeline) obj; +} + +void spine_slot_timeline_dispose(spine_slot_timeline obj) { + if (!obj) return; + delete (SlotTimeline *) obj; +} + +spine_rtti spine_slot_timeline_get_rtti(spine_slot_timeline obj) { + if (!obj) return nullptr; + SlotTimeline *_obj = (SlotTimeline *) obj; + return (spine_rtti) &_obj->getRTTI(); +} + +int32_t spine_slot_timeline_get_slot_index(spine_slot_timeline obj) { + if (!obj) return 0; + SlotTimeline *_obj = (SlotTimeline *) obj; + return _obj->getSlotIndex(); +} + +void spine_slot_timeline_set_slot_index(spine_slot_timeline obj, int32_t value) { + if (!obj) return; + SlotTimeline *_obj = (SlotTimeline *) obj; + _obj->setSlotIndex(value); +} diff --git a/spine-c-new/src/generated/slot_timeline.h b/spine-c-new/src/generated/slot_timeline.h new file mode 100644 index 000000000..83106bd89 --- /dev/null +++ b/spine-c-new/src/generated/slot_timeline.h @@ -0,0 +1,51 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#ifndef SPINE_C_SLOTTIMELINE_H +#define SPINE_C_SLOTTIMELINE_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include "../custom.h" + +SPINE_OPAQUE_TYPE(spine_slot_timeline) + +SPINE_C_EXPORT spine_slot_timeline spine_slot_timeline_create(int32_t slotIndex); +SPINE_C_EXPORT void spine_slot_timeline_dispose(spine_slot_timeline obj); +SPINE_C_EXPORT spine_rtti spine_slot_timeline_get_rtti(spine_slot_timeline obj); +SPINE_C_EXPORT int32_t spine_slot_timeline_get_slot_index(spine_slot_timeline obj); +SPINE_C_EXPORT void spine_slot_timeline_set_slot_index(spine_slot_timeline obj, int32_t value); + +#ifdef __cplusplus +} +#endif + +#endif // SPINE_C_SLOTTIMELINE_H \ No newline at end of file diff --git a/spine-c-new/src/generated/spacing_mode.h b/spine-c-new/src/generated/spacing_mode.h new file mode 100644 index 000000000..e93b6c83b --- /dev/null +++ b/spine-c-new/src/generated/spacing_mode.h @@ -0,0 +1,50 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#ifndef SPINE_C_SPACINGMODE_H +#define SPINE_C_SPACINGMODE_H + +#include "../../custom.h" + +#ifdef __cplusplus +extern "C" { +#endif + +typedef enum spine_spacing_mode { + SPINE_SPACING_MODE_SPACING_MODE_LENGTH = 0, + SPINE_SPACING_MODE_SPACING_MODE_FIXED, + SPINE_SPACING_MODE_SPACING_MODE_PERCENT, + SPINE_SPACING_MODE_SPACING_MODE_PROPORTIONAL +} spine_spacing_mode; + +#ifdef __cplusplus +} +#endif + +#endif // SPINE_C_SPACINGMODE_H \ No newline at end of file diff --git a/spine-c-new/src/generated/texture_filter.h b/spine-c-new/src/generated/texture_filter.h new file mode 100644 index 000000000..5681b98a3 --- /dev/null +++ b/spine-c-new/src/generated/texture_filter.h @@ -0,0 +1,54 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#ifndef SPINE_C_TEXTUREFILTER_H +#define SPINE_C_TEXTUREFILTER_H + +#include "../../custom.h" + +#ifdef __cplusplus +extern "C" { +#endif + +typedef enum spine_texture_filter { + SPINE_TEXTURE_FILTER_TEXTURE_FILTER_UNKNOWN, + SPINE_TEXTURE_FILTER_TEXTURE_FILTER_NEAREST, + SPINE_TEXTURE_FILTER_TEXTURE_FILTER_LINEAR, + SPINE_TEXTURE_FILTER_TEXTURE_FILTER_MIP_MAP, + SPINE_TEXTURE_FILTER_TEXTURE_FILTER_MIP_MAP_NEAREST_NEAREST, + SPINE_TEXTURE_FILTER_TEXTURE_FILTER_MIP_MAP_LINEAR_NEAREST, + SPINE_TEXTURE_FILTER_TEXTURE_FILTER_MIP_MAP_NEAREST_LINEAR, + SPINE_TEXTURE_FILTER_TEXTURE_FILTER_MIP_MAP_LINEAR_LINEAR +} spine_texture_filter; + +#ifdef __cplusplus +} +#endif + +#endif // SPINE_C_TEXTUREFILTER_H \ No newline at end of file diff --git a/spine-c-new/src/generated/texture_region.cpp b/spine-c-new/src/generated/texture_region.cpp new file mode 100644 index 000000000..6d4ece4c6 --- /dev/null +++ b/spine-c-new/src/generated/texture_region.cpp @@ -0,0 +1,43 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#include "texture_region.h" +#include + +using namespace spine; + +spine_texture_region spine_texture_region_create(void) { + TextureRegion *obj = new (__FILE__, __LINE__) TextureRegion(); + return (spine_texture_region) obj; +} + +void spine_texture_region_dispose(spine_texture_region obj) { + if (!obj) return; + delete (TextureRegion *) obj; +} diff --git a/spine-c-new/src/generated/texture_region.h b/spine-c-new/src/generated/texture_region.h new file mode 100644 index 000000000..e42265f78 --- /dev/null +++ b/spine-c-new/src/generated/texture_region.h @@ -0,0 +1,48 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#ifndef SPINE_C_TEXTUREREGION_H +#define SPINE_C_TEXTUREREGION_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include "../custom.h" + +SPINE_OPAQUE_TYPE(spine_texture_region) + +SPINE_C_EXPORT spine_texture_region spine_texture_region_create(void); +SPINE_C_EXPORT void spine_texture_region_dispose(spine_texture_region obj); + +#ifdef __cplusplus +} +#endif + +#endif // SPINE_C_TEXTUREREGION_H \ No newline at end of file diff --git a/spine-c-new/src/generated/texture_wrap.h b/spine-c-new/src/generated/texture_wrap.h new file mode 100644 index 000000000..cbc4284c7 --- /dev/null +++ b/spine-c-new/src/generated/texture_wrap.h @@ -0,0 +1,49 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#ifndef SPINE_C_TEXTUREWRAP_H +#define SPINE_C_TEXTUREWRAP_H + +#include "../../custom.h" + +#ifdef __cplusplus +extern "C" { +#endif + +typedef enum spine_texture_wrap { + SPINE_TEXTURE_WRAP_TEXTURE_WRAP_MIRRORED_REPEAT, + SPINE_TEXTURE_WRAP_TEXTURE_WRAP_CLAMP_TO_EDGE, + SPINE_TEXTURE_WRAP_TEXTURE_WRAP_REPEAT +} spine_texture_wrap; + +#ifdef __cplusplus +} +#endif + +#endif // SPINE_C_TEXTUREWRAP_H \ No newline at end of file diff --git a/spine-c-new/src/generated/timeline.cpp b/spine-c-new/src/generated/timeline.cpp new file mode 100644 index 000000000..128153857 --- /dev/null +++ b/spine-c-new/src/generated/timeline.cpp @@ -0,0 +1,442 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#include "timeline.h" +#include + +using namespace spine; + +spine_timeline spine_timeline_create(spine_size_t frameCount, spine_size_t frameEntries) { + Timeline *obj = new (__FILE__, __LINE__) Timeline(frameCount, frameEntries); + return (spine_timeline) obj; +} + +void spine_timeline_dispose(spine_timeline obj) { + if (!obj) return; + delete (Timeline *) obj; +} + +spine_rtti spine_timeline_get_rtti(spine_timeline obj) { + if (!obj) return nullptr; + Timeline *_obj = (Timeline *) obj; + return (spine_rtti) &_obj->getRTTI(); +} + +void spine_timeline_apply(spine_timeline obj, spine_skeleton skeleton, float lastTime, float time, void * pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction, spine_bool appliedPose) { + if (!obj) return ; + Timeline *_obj = (Timeline *) obj; + _obj->apply(skeleton, lastTime, time, (Vector *) pEvents, alpha, blend, direction, appliedPose); +} + +spine_size_t spine_timeline_get_frame_entries(spine_timeline obj) { + if (!obj) return nullptr; + Timeline *_obj = (Timeline *) obj; + return _obj->getFrameEntries(); +} + +spine_size_t spine_timeline_get_frame_count(spine_timeline obj) { + if (!obj) return nullptr; + Timeline *_obj = (Timeline *) obj; + return _obj->getFrameCount(); +} + +void * spine_timeline_get_frames(spine_timeline obj) { + if (!obj) return nullptr; + Timeline *_obj = (Timeline *) obj; + return _obj->getFrames(); +} + +int32_t spine_timeline_get_num_frames(spine_timeline obj) { + if (!obj) return 0; + Timeline *_obj = (Timeline *) obj; + return (int32_t) _obj->getFrames().size(); +} + +spine_float *spine_timeline_get_frames(spine_timeline obj) { + if (!obj) return nullptr; + Timeline *_obj = (Timeline *) obj; + return (spine_float *) _obj->getFrames().buffer(); +} + +float spine_timeline_get_duration(spine_timeline obj) { + if (!obj) return 0; + Timeline *_obj = (Timeline *) obj; + return _obj->getDuration(); +} + +void * spine_timeline_get_property_ids(spine_timeline obj) { + if (!obj) return nullptr; + Timeline *_obj = (Timeline *) obj; + return _obj->getPropertyIds(); +} + +int32_t spine_timeline_get_num_property_ids(spine_timeline obj) { + if (!obj) return 0; + Timeline *_obj = (Timeline *) obj; + return (int32_t) _obj->getPropertyIds().size(); +} + +spine_property_id *spine_timeline_get_property_ids(spine_timeline obj) { + if (!obj) return nullptr; + Timeline *_obj = (Timeline *) obj; + return (spine_property_id *) _obj->getPropertyIds().buffer(); +} + +spine_bool spine_timeline_is_type(spine_timeline obj, spine_timeline_type type) { + if (!obj) return 0; + Timeline *_obj = (Timeline *) obj; + + switch (type) { + case SPINE_TYPE_TIMELINE_ATTACHMENT_TIMELINE: + return _obj->getRTTI().instanceOf(AttachmentTimeline::rtti); + case SPINE_TYPE_TIMELINE_ROTATE_TIMELINE: + return _obj->getRTTI().instanceOf(RotateTimeline::rtti); + case SPINE_TYPE_TIMELINE_SCALE_X_TIMELINE: + return _obj->getRTTI().instanceOf(ScaleXTimeline::rtti); + case SPINE_TYPE_TIMELINE_SCALE_Y_TIMELINE: + return _obj->getRTTI().instanceOf(ScaleYTimeline::rtti); + case SPINE_TYPE_TIMELINE_SHEAR_X_TIMELINE: + return _obj->getRTTI().instanceOf(ShearXTimeline::rtti); + case SPINE_TYPE_TIMELINE_SHEAR_Y_TIMELINE: + return _obj->getRTTI().instanceOf(ShearYTimeline::rtti); + case SPINE_TYPE_TIMELINE_TRANSLATE_X_TIMELINE: + return _obj->getRTTI().instanceOf(TranslateXTimeline::rtti); + case SPINE_TYPE_TIMELINE_TRANSLATE_Y_TIMELINE: + return _obj->getRTTI().instanceOf(TranslateYTimeline::rtti); + case SPINE_TYPE_TIMELINE_ALPHA_TIMELINE: + return _obj->getRTTI().instanceOf(AlphaTimeline::rtti); + case SPINE_TYPE_TIMELINE_PATH_CONSTRAINT_POSITION_TIMELINE: + return _obj->getRTTI().instanceOf(PathConstraintPositionTimeline::rtti); + case SPINE_TYPE_TIMELINE_PATH_CONSTRAINT_SPACING_TIMELINE: + return _obj->getRTTI().instanceOf(PathConstraintSpacingTimeline::rtti); + case SPINE_TYPE_TIMELINE_SLIDER_MIX_TIMELINE: + return _obj->getRTTI().instanceOf(SliderMixTimeline::rtti); + case SPINE_TYPE_TIMELINE_SLIDER_TIMELINE: + return _obj->getRTTI().instanceOf(SliderTimeline::rtti); + case SPINE_TYPE_TIMELINE_PHYSICS_CONSTRAINT_INERTIA_TIMELINE: + return _obj->getRTTI().instanceOf(PhysicsConstraintInertiaTimeline::rtti); + case SPINE_TYPE_TIMELINE_PHYSICS_CONSTRAINT_STRENGTH_TIMELINE: + return _obj->getRTTI().instanceOf(PhysicsConstraintStrengthTimeline::rtti); + case SPINE_TYPE_TIMELINE_PHYSICS_CONSTRAINT_DAMPING_TIMELINE: + return _obj->getRTTI().instanceOf(PhysicsConstraintDampingTimeline::rtti); + case SPINE_TYPE_TIMELINE_PHYSICS_CONSTRAINT_MASS_TIMELINE: + return _obj->getRTTI().instanceOf(PhysicsConstraintMassTimeline::rtti); + case SPINE_TYPE_TIMELINE_PHYSICS_CONSTRAINT_WIND_TIMELINE: + return _obj->getRTTI().instanceOf(PhysicsConstraintWindTimeline::rtti); + case SPINE_TYPE_TIMELINE_PHYSICS_CONSTRAINT_GRAVITY_TIMELINE: + return _obj->getRTTI().instanceOf(PhysicsConstraintGravityTimeline::rtti); + case SPINE_TYPE_TIMELINE_PHYSICS_CONSTRAINT_MIX_TIMELINE: + return _obj->getRTTI().instanceOf(PhysicsConstraintMixTimeline::rtti); + case SPINE_TYPE_TIMELINE_SCALE_TIMELINE: + return _obj->getRTTI().instanceOf(ScaleTimeline::rtti); + case SPINE_TYPE_TIMELINE_SHEAR_TIMELINE: + return _obj->getRTTI().instanceOf(ShearTimeline::rtti); + case SPINE_TYPE_TIMELINE_TRANSLATE_TIMELINE: + return _obj->getRTTI().instanceOf(TranslateTimeline::rtti); + case SPINE_TYPE_TIMELINE_IK_CONSTRAINT_TIMELINE: + return _obj->getRTTI().instanceOf(IkConstraintTimeline::rtti); + case SPINE_TYPE_TIMELINE_PATH_CONSTRAINT_MIX_TIMELINE: + return _obj->getRTTI().instanceOf(PathConstraintMixTimeline::rtti); + case SPINE_TYPE_TIMELINE_RGBA_TIMELINE: + return _obj->getRTTI().instanceOf(RGBATimeline::rtti); + case SPINE_TYPE_TIMELINE_RGB_TIMELINE: + return _obj->getRTTI().instanceOf(RGBTimeline::rtti); + case SPINE_TYPE_TIMELINE_RGBA2_TIMELINE: + return _obj->getRTTI().instanceOf(RGBA2Timeline::rtti); + case SPINE_TYPE_TIMELINE_RGB2_TIMELINE: + return _obj->getRTTI().instanceOf(RGB2Timeline::rtti); + case SPINE_TYPE_TIMELINE_DEFORM_TIMELINE: + return _obj->getRTTI().instanceOf(DeformTimeline::rtti); + case SPINE_TYPE_TIMELINE_TRANSFORM_CONSTRAINT_TIMELINE: + return _obj->getRTTI().instanceOf(TransformConstraintTimeline::rtti); + case SPINE_TYPE_TIMELINE_DRAW_ORDER_TIMELINE: + return _obj->getRTTI().instanceOf(DrawOrderTimeline::rtti); + case SPINE_TYPE_TIMELINE_EVENT_TIMELINE: + return _obj->getRTTI().instanceOf(EventTimeline::rtti); + case SPINE_TYPE_TIMELINE_INHERIT_TIMELINE: + return _obj->getRTTI().instanceOf(InheritTimeline::rtti); + case SPINE_TYPE_TIMELINE_PHYSICS_CONSTRAINT_RESET_TIMELINE: + return _obj->getRTTI().instanceOf(PhysicsConstraintResetTimeline::rtti); + case SPINE_TYPE_TIMELINE_SEQUENCE_TIMELINE: + return _obj->getRTTI().instanceOf(SequenceTimeline::rtti); + } + return 0; +} + +spine_attachment_timeline spine_timeline_as_attachment_timeline(spine_timeline obj) { + if (!obj) return nullptr; + Timeline *_obj = (Timeline *) obj; + if (!_obj->getRTTI().instanceOf(AttachmentTimeline::rtti)) return nullptr; + return (spine_attachment_timeline) obj; +} + +spine_rotate_timeline spine_timeline_as_rotate_timeline(spine_timeline obj) { + if (!obj) return nullptr; + Timeline *_obj = (Timeline *) obj; + if (!_obj->getRTTI().instanceOf(RotateTimeline::rtti)) return nullptr; + return (spine_rotate_timeline) obj; +} + +spine_scale_x_timeline spine_timeline_as_scale_x_timeline(spine_timeline obj) { + if (!obj) return nullptr; + Timeline *_obj = (Timeline *) obj; + if (!_obj->getRTTI().instanceOf(ScaleXTimeline::rtti)) return nullptr; + return (spine_scale_x_timeline) obj; +} + +spine_scale_y_timeline spine_timeline_as_scale_y_timeline(spine_timeline obj) { + if (!obj) return nullptr; + Timeline *_obj = (Timeline *) obj; + if (!_obj->getRTTI().instanceOf(ScaleYTimeline::rtti)) return nullptr; + return (spine_scale_y_timeline) obj; +} + +spine_shear_x_timeline spine_timeline_as_shear_x_timeline(spine_timeline obj) { + if (!obj) return nullptr; + Timeline *_obj = (Timeline *) obj; + if (!_obj->getRTTI().instanceOf(ShearXTimeline::rtti)) return nullptr; + return (spine_shear_x_timeline) obj; +} + +spine_shear_y_timeline spine_timeline_as_shear_y_timeline(spine_timeline obj) { + if (!obj) return nullptr; + Timeline *_obj = (Timeline *) obj; + if (!_obj->getRTTI().instanceOf(ShearYTimeline::rtti)) return nullptr; + return (spine_shear_y_timeline) obj; +} + +spine_translate_x_timeline spine_timeline_as_translate_x_timeline(spine_timeline obj) { + if (!obj) return nullptr; + Timeline *_obj = (Timeline *) obj; + if (!_obj->getRTTI().instanceOf(TranslateXTimeline::rtti)) return nullptr; + return (spine_translate_x_timeline) obj; +} + +spine_translate_y_timeline spine_timeline_as_translate_y_timeline(spine_timeline obj) { + if (!obj) return nullptr; + Timeline *_obj = (Timeline *) obj; + if (!_obj->getRTTI().instanceOf(TranslateYTimeline::rtti)) return nullptr; + return (spine_translate_y_timeline) obj; +} + +spine_alpha_timeline spine_timeline_as_alpha_timeline(spine_timeline obj) { + if (!obj) return nullptr; + Timeline *_obj = (Timeline *) obj; + if (!_obj->getRTTI().instanceOf(AlphaTimeline::rtti)) return nullptr; + return (spine_alpha_timeline) obj; +} + +spine_path_constraint_position_timeline spine_timeline_as_path_constraint_position_timeline(spine_timeline obj) { + if (!obj) return nullptr; + Timeline *_obj = (Timeline *) obj; + if (!_obj->getRTTI().instanceOf(PathConstraintPositionTimeline::rtti)) return nullptr; + return (spine_path_constraint_position_timeline) obj; +} + +spine_path_constraint_spacing_timeline spine_timeline_as_path_constraint_spacing_timeline(spine_timeline obj) { + if (!obj) return nullptr; + Timeline *_obj = (Timeline *) obj; + if (!_obj->getRTTI().instanceOf(PathConstraintSpacingTimeline::rtti)) return nullptr; + return (spine_path_constraint_spacing_timeline) obj; +} + +spine_slider_mix_timeline spine_timeline_as_slider_mix_timeline(spine_timeline obj) { + if (!obj) return nullptr; + Timeline *_obj = (Timeline *) obj; + if (!_obj->getRTTI().instanceOf(SliderMixTimeline::rtti)) return nullptr; + return (spine_slider_mix_timeline) obj; +} + +spine_slider_timeline spine_timeline_as_slider_timeline(spine_timeline obj) { + if (!obj) return nullptr; + Timeline *_obj = (Timeline *) obj; + if (!_obj->getRTTI().instanceOf(SliderTimeline::rtti)) return nullptr; + return (spine_slider_timeline) obj; +} + +spine_physics_constraint_inertia_timeline spine_timeline_as_physics_constraint_inertia_timeline(spine_timeline obj) { + if (!obj) return nullptr; + Timeline *_obj = (Timeline *) obj; + if (!_obj->getRTTI().instanceOf(PhysicsConstraintInertiaTimeline::rtti)) return nullptr; + return (spine_physics_constraint_inertia_timeline) obj; +} + +spine_physics_constraint_strength_timeline spine_timeline_as_physics_constraint_strength_timeline(spine_timeline obj) { + if (!obj) return nullptr; + Timeline *_obj = (Timeline *) obj; + if (!_obj->getRTTI().instanceOf(PhysicsConstraintStrengthTimeline::rtti)) return nullptr; + return (spine_physics_constraint_strength_timeline) obj; +} + +spine_physics_constraint_damping_timeline spine_timeline_as_physics_constraint_damping_timeline(spine_timeline obj) { + if (!obj) return nullptr; + Timeline *_obj = (Timeline *) obj; + if (!_obj->getRTTI().instanceOf(PhysicsConstraintDampingTimeline::rtti)) return nullptr; + return (spine_physics_constraint_damping_timeline) obj; +} + +spine_physics_constraint_mass_timeline spine_timeline_as_physics_constraint_mass_timeline(spine_timeline obj) { + if (!obj) return nullptr; + Timeline *_obj = (Timeline *) obj; + if (!_obj->getRTTI().instanceOf(PhysicsConstraintMassTimeline::rtti)) return nullptr; + return (spine_physics_constraint_mass_timeline) obj; +} + +spine_physics_constraint_wind_timeline spine_timeline_as_physics_constraint_wind_timeline(spine_timeline obj) { + if (!obj) return nullptr; + Timeline *_obj = (Timeline *) obj; + if (!_obj->getRTTI().instanceOf(PhysicsConstraintWindTimeline::rtti)) return nullptr; + return (spine_physics_constraint_wind_timeline) obj; +} + +spine_physics_constraint_gravity_timeline spine_timeline_as_physics_constraint_gravity_timeline(spine_timeline obj) { + if (!obj) return nullptr; + Timeline *_obj = (Timeline *) obj; + if (!_obj->getRTTI().instanceOf(PhysicsConstraintGravityTimeline::rtti)) return nullptr; + return (spine_physics_constraint_gravity_timeline) obj; +} + +spine_physics_constraint_mix_timeline spine_timeline_as_physics_constraint_mix_timeline(spine_timeline obj) { + if (!obj) return nullptr; + Timeline *_obj = (Timeline *) obj; + if (!_obj->getRTTI().instanceOf(PhysicsConstraintMixTimeline::rtti)) return nullptr; + return (spine_physics_constraint_mix_timeline) obj; +} + +spine_scale_timeline spine_timeline_as_scale_timeline(spine_timeline obj) { + if (!obj) return nullptr; + Timeline *_obj = (Timeline *) obj; + if (!_obj->getRTTI().instanceOf(ScaleTimeline::rtti)) return nullptr; + return (spine_scale_timeline) obj; +} + +spine_shear_timeline spine_timeline_as_shear_timeline(spine_timeline obj) { + if (!obj) return nullptr; + Timeline *_obj = (Timeline *) obj; + if (!_obj->getRTTI().instanceOf(ShearTimeline::rtti)) return nullptr; + return (spine_shear_timeline) obj; +} + +spine_translate_timeline spine_timeline_as_translate_timeline(spine_timeline obj) { + if (!obj) return nullptr; + Timeline *_obj = (Timeline *) obj; + if (!_obj->getRTTI().instanceOf(TranslateTimeline::rtti)) return nullptr; + return (spine_translate_timeline) obj; +} + +spine_ik_constraint_timeline spine_timeline_as_ik_constraint_timeline(spine_timeline obj) { + if (!obj) return nullptr; + Timeline *_obj = (Timeline *) obj; + if (!_obj->getRTTI().instanceOf(IkConstraintTimeline::rtti)) return nullptr; + return (spine_ik_constraint_timeline) obj; +} + +spine_path_constraint_mix_timeline spine_timeline_as_path_constraint_mix_timeline(spine_timeline obj) { + if (!obj) return nullptr; + Timeline *_obj = (Timeline *) obj; + if (!_obj->getRTTI().instanceOf(PathConstraintMixTimeline::rtti)) return nullptr; + return (spine_path_constraint_mix_timeline) obj; +} + +spine_rgba_timeline spine_timeline_as_rgba_timeline(spine_timeline obj) { + if (!obj) return nullptr; + Timeline *_obj = (Timeline *) obj; + if (!_obj->getRTTI().instanceOf(RGBATimeline::rtti)) return nullptr; + return (spine_rgba_timeline) obj; +} + +spine_rgb_timeline spine_timeline_as_rgb_timeline(spine_timeline obj) { + if (!obj) return nullptr; + Timeline *_obj = (Timeline *) obj; + if (!_obj->getRTTI().instanceOf(RGBTimeline::rtti)) return nullptr; + return (spine_rgb_timeline) obj; +} + +spine_rgba2_timeline spine_timeline_as_rgba2_timeline(spine_timeline obj) { + if (!obj) return nullptr; + Timeline *_obj = (Timeline *) obj; + if (!_obj->getRTTI().instanceOf(RGBA2Timeline::rtti)) return nullptr; + return (spine_rgba2_timeline) obj; +} + +spine_rgb2_timeline spine_timeline_as_rgb2_timeline(spine_timeline obj) { + if (!obj) return nullptr; + Timeline *_obj = (Timeline *) obj; + if (!_obj->getRTTI().instanceOf(RGB2Timeline::rtti)) return nullptr; + return (spine_rgb2_timeline) obj; +} + +spine_deform_timeline spine_timeline_as_deform_timeline(spine_timeline obj) { + if (!obj) return nullptr; + Timeline *_obj = (Timeline *) obj; + if (!_obj->getRTTI().instanceOf(DeformTimeline::rtti)) return nullptr; + return (spine_deform_timeline) obj; +} + +spine_transform_constraint_timeline spine_timeline_as_transform_constraint_timeline(spine_timeline obj) { + if (!obj) return nullptr; + Timeline *_obj = (Timeline *) obj; + if (!_obj->getRTTI().instanceOf(TransformConstraintTimeline::rtti)) return nullptr; + return (spine_transform_constraint_timeline) obj; +} + +spine_draw_order_timeline spine_timeline_as_draw_order_timeline(spine_timeline obj) { + if (!obj) return nullptr; + Timeline *_obj = (Timeline *) obj; + if (!_obj->getRTTI().instanceOf(DrawOrderTimeline::rtti)) return nullptr; + return (spine_draw_order_timeline) obj; +} + +spine_event_timeline spine_timeline_as_event_timeline(spine_timeline obj) { + if (!obj) return nullptr; + Timeline *_obj = (Timeline *) obj; + if (!_obj->getRTTI().instanceOf(EventTimeline::rtti)) return nullptr; + return (spine_event_timeline) obj; +} + +spine_inherit_timeline spine_timeline_as_inherit_timeline(spine_timeline obj) { + if (!obj) return nullptr; + Timeline *_obj = (Timeline *) obj; + if (!_obj->getRTTI().instanceOf(InheritTimeline::rtti)) return nullptr; + return (spine_inherit_timeline) obj; +} + +spine_physics_constraint_reset_timeline spine_timeline_as_physics_constraint_reset_timeline(spine_timeline obj) { + if (!obj) return nullptr; + Timeline *_obj = (Timeline *) obj; + if (!_obj->getRTTI().instanceOf(PhysicsConstraintResetTimeline::rtti)) return nullptr; + return (spine_physics_constraint_reset_timeline) obj; +} + +spine_sequence_timeline spine_timeline_as_sequence_timeline(spine_timeline obj) { + if (!obj) return nullptr; + Timeline *_obj = (Timeline *) obj; + if (!_obj->getRTTI().instanceOf(SequenceTimeline::rtti)) return nullptr; + return (spine_sequence_timeline) obj; +} diff --git a/spine-c-new/src/generated/timeline.h b/spine-c-new/src/generated/timeline.h new file mode 100644 index 000000000..cb48ef8aa --- /dev/null +++ b/spine-c-new/src/generated/timeline.h @@ -0,0 +1,208 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#ifndef SPINE_C_TIMELINE_H +#define SPINE_C_TIMELINE_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include "../custom.h" + +SPINE_OPAQUE_TYPE(spine_timeline) + +SPINE_C_EXPORT spine_timeline spine_timeline_create(spine_size_t frameCount, spine_size_t frameEntries); +SPINE_C_EXPORT void spine_timeline_dispose(spine_timeline obj); +SPINE_C_EXPORT spine_rtti spine_timeline_get_rtti(spine_timeline obj); +SPINE_C_EXPORT void spine_timeline_apply(spine_timeline obj, spine_skeleton skeleton, float lastTime, float time, void * pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction, spine_bool appliedPose); +SPINE_C_EXPORT spine_size_t spine_timeline_get_frame_entries(spine_timeline obj); +SPINE_C_EXPORT spine_size_t spine_timeline_get_frame_count(spine_timeline obj); +SPINE_C_EXPORT void * spine_timeline_get_frames(spine_timeline obj); +SPINE_C_EXPORT int32_t spine_timeline_get_num_frames(spine_timeline obj); +SPINE_C_EXPORT spine_float *spine_timeline_get_frames(spine_timeline obj); +SPINE_C_EXPORT float spine_timeline_get_duration(spine_timeline obj); +SPINE_C_EXPORT void * spine_timeline_get_property_ids(spine_timeline obj); +SPINE_C_EXPORT int32_t spine_timeline_get_num_property_ids(spine_timeline obj); +SPINE_C_EXPORT spine_property_id *spine_timeline_get_property_ids(spine_timeline obj); +struct spine_attachment_timeline_wrapper; +typedef struct spine_attachment_timeline_wrapper *spine_attachment_timeline; +struct spine_rotate_timeline_wrapper; +typedef struct spine_rotate_timeline_wrapper *spine_rotate_timeline; +struct spine_scale_x_timeline_wrapper; +typedef struct spine_scale_x_timeline_wrapper *spine_scale_x_timeline; +struct spine_scale_y_timeline_wrapper; +typedef struct spine_scale_y_timeline_wrapper *spine_scale_y_timeline; +struct spine_shear_x_timeline_wrapper; +typedef struct spine_shear_x_timeline_wrapper *spine_shear_x_timeline; +struct spine_shear_y_timeline_wrapper; +typedef struct spine_shear_y_timeline_wrapper *spine_shear_y_timeline; +struct spine_translate_x_timeline_wrapper; +typedef struct spine_translate_x_timeline_wrapper *spine_translate_x_timeline; +struct spine_translate_y_timeline_wrapper; +typedef struct spine_translate_y_timeline_wrapper *spine_translate_y_timeline; +struct spine_alpha_timeline_wrapper; +typedef struct spine_alpha_timeline_wrapper *spine_alpha_timeline; +struct spine_path_constraint_position_timeline_wrapper; +typedef struct spine_path_constraint_position_timeline_wrapper *spine_path_constraint_position_timeline; +struct spine_path_constraint_spacing_timeline_wrapper; +typedef struct spine_path_constraint_spacing_timeline_wrapper *spine_path_constraint_spacing_timeline; +struct spine_slider_mix_timeline_wrapper; +typedef struct spine_slider_mix_timeline_wrapper *spine_slider_mix_timeline; +struct spine_slider_timeline_wrapper; +typedef struct spine_slider_timeline_wrapper *spine_slider_timeline; +struct spine_physics_constraint_inertia_timeline_wrapper; +typedef struct spine_physics_constraint_inertia_timeline_wrapper *spine_physics_constraint_inertia_timeline; +struct spine_physics_constraint_strength_timeline_wrapper; +typedef struct spine_physics_constraint_strength_timeline_wrapper *spine_physics_constraint_strength_timeline; +struct spine_physics_constraint_damping_timeline_wrapper; +typedef struct spine_physics_constraint_damping_timeline_wrapper *spine_physics_constraint_damping_timeline; +struct spine_physics_constraint_mass_timeline_wrapper; +typedef struct spine_physics_constraint_mass_timeline_wrapper *spine_physics_constraint_mass_timeline; +struct spine_physics_constraint_wind_timeline_wrapper; +typedef struct spine_physics_constraint_wind_timeline_wrapper *spine_physics_constraint_wind_timeline; +struct spine_physics_constraint_gravity_timeline_wrapper; +typedef struct spine_physics_constraint_gravity_timeline_wrapper *spine_physics_constraint_gravity_timeline; +struct spine_physics_constraint_mix_timeline_wrapper; +typedef struct spine_physics_constraint_mix_timeline_wrapper *spine_physics_constraint_mix_timeline; +struct spine_scale_timeline_wrapper; +typedef struct spine_scale_timeline_wrapper *spine_scale_timeline; +struct spine_shear_timeline_wrapper; +typedef struct spine_shear_timeline_wrapper *spine_shear_timeline; +struct spine_translate_timeline_wrapper; +typedef struct spine_translate_timeline_wrapper *spine_translate_timeline; +struct spine_ik_constraint_timeline_wrapper; +typedef struct spine_ik_constraint_timeline_wrapper *spine_ik_constraint_timeline; +struct spine_path_constraint_mix_timeline_wrapper; +typedef struct spine_path_constraint_mix_timeline_wrapper *spine_path_constraint_mix_timeline; +struct spine_rgba_timeline_wrapper; +typedef struct spine_rgba_timeline_wrapper *spine_rgba_timeline; +struct spine_rgb_timeline_wrapper; +typedef struct spine_rgb_timeline_wrapper *spine_rgb_timeline; +struct spine_rgba2_timeline_wrapper; +typedef struct spine_rgba2_timeline_wrapper *spine_rgba2_timeline; +struct spine_rgb2_timeline_wrapper; +typedef struct spine_rgb2_timeline_wrapper *spine_rgb2_timeline; +struct spine_deform_timeline_wrapper; +typedef struct spine_deform_timeline_wrapper *spine_deform_timeline; +struct spine_transform_constraint_timeline_wrapper; +typedef struct spine_transform_constraint_timeline_wrapper *spine_transform_constraint_timeline; +struct spine_draw_order_timeline_wrapper; +typedef struct spine_draw_order_timeline_wrapper *spine_draw_order_timeline; +struct spine_event_timeline_wrapper; +typedef struct spine_event_timeline_wrapper *spine_event_timeline; +struct spine_inherit_timeline_wrapper; +typedef struct spine_inherit_timeline_wrapper *spine_inherit_timeline; +struct spine_physics_constraint_reset_timeline_wrapper; +typedef struct spine_physics_constraint_reset_timeline_wrapper *spine_physics_constraint_reset_timeline; +struct spine_sequence_timeline_wrapper; +typedef struct spine_sequence_timeline_wrapper *spine_sequence_timeline; + +typedef enum spine_timeline_type { + SPINE_TYPE_TIMELINE_ATTACHMENT_TIMELINE = 0, + SPINE_TYPE_TIMELINE_ROTATE_TIMELINE = 1, + SPINE_TYPE_TIMELINE_SCALE_X_TIMELINE = 2, + SPINE_TYPE_TIMELINE_SCALE_Y_TIMELINE = 3, + SPINE_TYPE_TIMELINE_SHEAR_X_TIMELINE = 4, + SPINE_TYPE_TIMELINE_SHEAR_Y_TIMELINE = 5, + SPINE_TYPE_TIMELINE_TRANSLATE_X_TIMELINE = 6, + SPINE_TYPE_TIMELINE_TRANSLATE_Y_TIMELINE = 7, + SPINE_TYPE_TIMELINE_ALPHA_TIMELINE = 8, + SPINE_TYPE_TIMELINE_PATH_CONSTRAINT_POSITION_TIMELINE = 9, + SPINE_TYPE_TIMELINE_PATH_CONSTRAINT_SPACING_TIMELINE = 10, + SPINE_TYPE_TIMELINE_SLIDER_MIX_TIMELINE = 11, + SPINE_TYPE_TIMELINE_SLIDER_TIMELINE = 12, + SPINE_TYPE_TIMELINE_PHYSICS_CONSTRAINT_INERTIA_TIMELINE = 13, + SPINE_TYPE_TIMELINE_PHYSICS_CONSTRAINT_STRENGTH_TIMELINE = 14, + SPINE_TYPE_TIMELINE_PHYSICS_CONSTRAINT_DAMPING_TIMELINE = 15, + SPINE_TYPE_TIMELINE_PHYSICS_CONSTRAINT_MASS_TIMELINE = 16, + SPINE_TYPE_TIMELINE_PHYSICS_CONSTRAINT_WIND_TIMELINE = 17, + SPINE_TYPE_TIMELINE_PHYSICS_CONSTRAINT_GRAVITY_TIMELINE = 18, + SPINE_TYPE_TIMELINE_PHYSICS_CONSTRAINT_MIX_TIMELINE = 19, + SPINE_TYPE_TIMELINE_SCALE_TIMELINE = 20, + SPINE_TYPE_TIMELINE_SHEAR_TIMELINE = 21, + SPINE_TYPE_TIMELINE_TRANSLATE_TIMELINE = 22, + SPINE_TYPE_TIMELINE_IK_CONSTRAINT_TIMELINE = 23, + SPINE_TYPE_TIMELINE_PATH_CONSTRAINT_MIX_TIMELINE = 24, + SPINE_TYPE_TIMELINE_RGBA_TIMELINE = 25, + SPINE_TYPE_TIMELINE_RGB_TIMELINE = 26, + SPINE_TYPE_TIMELINE_RGBA2_TIMELINE = 27, + SPINE_TYPE_TIMELINE_RGB2_TIMELINE = 28, + SPINE_TYPE_TIMELINE_DEFORM_TIMELINE = 29, + SPINE_TYPE_TIMELINE_TRANSFORM_CONSTRAINT_TIMELINE = 30, + SPINE_TYPE_TIMELINE_DRAW_ORDER_TIMELINE = 31, + SPINE_TYPE_TIMELINE_EVENT_TIMELINE = 32, + SPINE_TYPE_TIMELINE_INHERIT_TIMELINE = 33, + SPINE_TYPE_TIMELINE_PHYSICS_CONSTRAINT_RESET_TIMELINE = 34, + SPINE_TYPE_TIMELINE_SEQUENCE_TIMELINE = 35 +} spine_timeline_type; + +SPINE_C_EXPORT spine_bool spine_timeline_is_type(spine_timeline obj, spine_timeline_type type); +SPINE_C_EXPORT spine_attachment_timeline spine_timeline_as_attachment_timeline(spine_timeline obj); +SPINE_C_EXPORT spine_rotate_timeline spine_timeline_as_rotate_timeline(spine_timeline obj); +SPINE_C_EXPORT spine_scale_x_timeline spine_timeline_as_scale_x_timeline(spine_timeline obj); +SPINE_C_EXPORT spine_scale_y_timeline spine_timeline_as_scale_y_timeline(spine_timeline obj); +SPINE_C_EXPORT spine_shear_x_timeline spine_timeline_as_shear_x_timeline(spine_timeline obj); +SPINE_C_EXPORT spine_shear_y_timeline spine_timeline_as_shear_y_timeline(spine_timeline obj); +SPINE_C_EXPORT spine_translate_x_timeline spine_timeline_as_translate_x_timeline(spine_timeline obj); +SPINE_C_EXPORT spine_translate_y_timeline spine_timeline_as_translate_y_timeline(spine_timeline obj); +SPINE_C_EXPORT spine_alpha_timeline spine_timeline_as_alpha_timeline(spine_timeline obj); +SPINE_C_EXPORT spine_path_constraint_position_timeline spine_timeline_as_path_constraint_position_timeline(spine_timeline obj); +SPINE_C_EXPORT spine_path_constraint_spacing_timeline spine_timeline_as_path_constraint_spacing_timeline(spine_timeline obj); +SPINE_C_EXPORT spine_slider_mix_timeline spine_timeline_as_slider_mix_timeline(spine_timeline obj); +SPINE_C_EXPORT spine_slider_timeline spine_timeline_as_slider_timeline(spine_timeline obj); +SPINE_C_EXPORT spine_physics_constraint_inertia_timeline spine_timeline_as_physics_constraint_inertia_timeline(spine_timeline obj); +SPINE_C_EXPORT spine_physics_constraint_strength_timeline spine_timeline_as_physics_constraint_strength_timeline(spine_timeline obj); +SPINE_C_EXPORT spine_physics_constraint_damping_timeline spine_timeline_as_physics_constraint_damping_timeline(spine_timeline obj); +SPINE_C_EXPORT spine_physics_constraint_mass_timeline spine_timeline_as_physics_constraint_mass_timeline(spine_timeline obj); +SPINE_C_EXPORT spine_physics_constraint_wind_timeline spine_timeline_as_physics_constraint_wind_timeline(spine_timeline obj); +SPINE_C_EXPORT spine_physics_constraint_gravity_timeline spine_timeline_as_physics_constraint_gravity_timeline(spine_timeline obj); +SPINE_C_EXPORT spine_physics_constraint_mix_timeline spine_timeline_as_physics_constraint_mix_timeline(spine_timeline obj); +SPINE_C_EXPORT spine_scale_timeline spine_timeline_as_scale_timeline(spine_timeline obj); +SPINE_C_EXPORT spine_shear_timeline spine_timeline_as_shear_timeline(spine_timeline obj); +SPINE_C_EXPORT spine_translate_timeline spine_timeline_as_translate_timeline(spine_timeline obj); +SPINE_C_EXPORT spine_ik_constraint_timeline spine_timeline_as_ik_constraint_timeline(spine_timeline obj); +SPINE_C_EXPORT spine_path_constraint_mix_timeline spine_timeline_as_path_constraint_mix_timeline(spine_timeline obj); +SPINE_C_EXPORT spine_rgba_timeline spine_timeline_as_rgba_timeline(spine_timeline obj); +SPINE_C_EXPORT spine_rgb_timeline spine_timeline_as_rgb_timeline(spine_timeline obj); +SPINE_C_EXPORT spine_rgba2_timeline spine_timeline_as_rgba2_timeline(spine_timeline obj); +SPINE_C_EXPORT spine_rgb2_timeline spine_timeline_as_rgb2_timeline(spine_timeline obj); +SPINE_C_EXPORT spine_deform_timeline spine_timeline_as_deform_timeline(spine_timeline obj); +SPINE_C_EXPORT spine_transform_constraint_timeline spine_timeline_as_transform_constraint_timeline(spine_timeline obj); +SPINE_C_EXPORT spine_draw_order_timeline spine_timeline_as_draw_order_timeline(spine_timeline obj); +SPINE_C_EXPORT spine_event_timeline spine_timeline_as_event_timeline(spine_timeline obj); +SPINE_C_EXPORT spine_inherit_timeline spine_timeline_as_inherit_timeline(spine_timeline obj); +SPINE_C_EXPORT spine_physics_constraint_reset_timeline spine_timeline_as_physics_constraint_reset_timeline(spine_timeline obj); +SPINE_C_EXPORT spine_sequence_timeline spine_timeline_as_sequence_timeline(spine_timeline obj); + +#ifdef __cplusplus +} +#endif + +#endif // SPINE_C_TIMELINE_H \ No newline at end of file diff --git a/spine-c-new/src/generated/to_property.cpp b/spine-c-new/src/generated/to_property.cpp new file mode 100644 index 000000000..85481d7ac --- /dev/null +++ b/spine-c-new/src/generated/to_property.cpp @@ -0,0 +1,55 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#include "to_property.h" +#include + +using namespace spine; + +spine_to_property spine_to_property_create(void) { + ToProperty *obj = new (__FILE__, __LINE__) ToProperty(); + return (spine_to_property) obj; +} + +void spine_to_property_dispose(spine_to_property obj) { + if (!obj) return; + delete (ToProperty *) obj; +} + +float spine_to_property_mix(spine_to_property obj, spine_transform_constraint_pose pose) { + if (!obj) return 0; + ToProperty *_obj = (ToProperty *) obj; + return _obj->mix(pose); +} + +void spine_to_property_apply(spine_to_property obj, spine_skeleton skeleton, spine_transform_constraint_pose pose, spine_bone_pose bone, float value, spine_bool local, spine_bool additive) { + if (!obj) return ; + ToProperty *_obj = (ToProperty *) obj; + _obj->apply(skeleton, pose, bone, value, local, additive); +} diff --git a/spine-c-new/src/generated/to_property.h b/spine-c-new/src/generated/to_property.h new file mode 100644 index 000000000..ed9ea8b4d --- /dev/null +++ b/spine-c-new/src/generated/to_property.h @@ -0,0 +1,50 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#ifndef SPINE_C_TOPROPERTY_H +#define SPINE_C_TOPROPERTY_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include "../custom.h" + +SPINE_OPAQUE_TYPE(spine_to_property) + +SPINE_C_EXPORT spine_to_property spine_to_property_create(void); +SPINE_C_EXPORT void spine_to_property_dispose(spine_to_property obj); +SPINE_C_EXPORT float spine_to_property_mix(spine_to_property obj, spine_transform_constraint_pose pose); +SPINE_C_EXPORT void spine_to_property_apply(spine_to_property obj, spine_skeleton skeleton, spine_transform_constraint_pose pose, spine_bone_pose bone, float value, spine_bool local, spine_bool additive); + +#ifdef __cplusplus +} +#endif + +#endif // SPINE_C_TOPROPERTY_H \ No newline at end of file diff --git a/spine-c-new/src/generated/to_rotate.cpp b/spine-c-new/src/generated/to_rotate.cpp new file mode 100644 index 000000000..28a9920ea --- /dev/null +++ b/spine-c-new/src/generated/to_rotate.cpp @@ -0,0 +1,50 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#include "to_rotate.h" +#include + +using namespace spine; + +void spine_to_rotate_dispose(spine_to_rotate obj) { + if (!obj) return; + delete (ToRotate *) obj; +} + +float spine_to_rotate_mix(spine_to_rotate obj, spine_transform_constraint_pose pose) { + if (!obj) return 0; + ToRotate *_obj = (ToRotate *) obj; + return _obj->mix(pose); +} + +void spine_to_rotate_apply(spine_to_rotate obj, spine_skeleton skeleton, spine_transform_constraint_pose pose, spine_bone_pose bone, float value, spine_bool local, spine_bool additive) { + if (!obj) return ; + ToRotate *_obj = (ToRotate *) obj; + _obj->apply(skeleton, pose, bone, value, local, additive); +} diff --git a/spine-c-new/src/generated/to_rotate.h b/spine-c-new/src/generated/to_rotate.h new file mode 100644 index 000000000..53eb43110 --- /dev/null +++ b/spine-c-new/src/generated/to_rotate.h @@ -0,0 +1,49 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#ifndef SPINE_C_TOROTATE_H +#define SPINE_C_TOROTATE_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include "../custom.h" + +SPINE_OPAQUE_TYPE(spine_to_rotate) + +SPINE_C_EXPORT void spine_to_rotate_dispose(spine_to_rotate obj); +SPINE_C_EXPORT float spine_to_rotate_mix(spine_to_rotate obj, spine_transform_constraint_pose pose); +SPINE_C_EXPORT void spine_to_rotate_apply(spine_to_rotate obj, spine_skeleton skeleton, spine_transform_constraint_pose pose, spine_bone_pose bone, float value, spine_bool local, spine_bool additive); + +#ifdef __cplusplus +} +#endif + +#endif // SPINE_C_TOROTATE_H \ No newline at end of file diff --git a/spine-c-new/src/generated/to_scale_x.cpp b/spine-c-new/src/generated/to_scale_x.cpp new file mode 100644 index 000000000..5bd13b0b5 --- /dev/null +++ b/spine-c-new/src/generated/to_scale_x.cpp @@ -0,0 +1,50 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#include "to_scale_x.h" +#include + +using namespace spine; + +void spine_to_scale_x_dispose(spine_to_scale_x obj) { + if (!obj) return; + delete (ToScaleX *) obj; +} + +float spine_to_scale_x_mix(spine_to_scale_x obj, spine_transform_constraint_pose pose) { + if (!obj) return 0; + ToScaleX *_obj = (ToScaleX *) obj; + return _obj->mix(pose); +} + +void spine_to_scale_x_apply(spine_to_scale_x obj, spine_skeleton skeleton, spine_transform_constraint_pose pose, spine_bone_pose bone, float value, spine_bool local, spine_bool additive) { + if (!obj) return ; + ToScaleX *_obj = (ToScaleX *) obj; + _obj->apply(skeleton, pose, bone, value, local, additive); +} diff --git a/spine-c-new/src/generated/to_scale_x.h b/spine-c-new/src/generated/to_scale_x.h new file mode 100644 index 000000000..e3518fc04 --- /dev/null +++ b/spine-c-new/src/generated/to_scale_x.h @@ -0,0 +1,49 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#ifndef SPINE_C_TOSCALEX_H +#define SPINE_C_TOSCALEX_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include "../custom.h" + +SPINE_OPAQUE_TYPE(spine_to_scale_x) + +SPINE_C_EXPORT void spine_to_scale_x_dispose(spine_to_scale_x obj); +SPINE_C_EXPORT float spine_to_scale_x_mix(spine_to_scale_x obj, spine_transform_constraint_pose pose); +SPINE_C_EXPORT void spine_to_scale_x_apply(spine_to_scale_x obj, spine_skeleton skeleton, spine_transform_constraint_pose pose, spine_bone_pose bone, float value, spine_bool local, spine_bool additive); + +#ifdef __cplusplus +} +#endif + +#endif // SPINE_C_TOSCALEX_H \ No newline at end of file diff --git a/spine-c-new/src/generated/to_scale_y.cpp b/spine-c-new/src/generated/to_scale_y.cpp new file mode 100644 index 000000000..420a218d2 --- /dev/null +++ b/spine-c-new/src/generated/to_scale_y.cpp @@ -0,0 +1,50 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#include "to_scale_y.h" +#include + +using namespace spine; + +void spine_to_scale_y_dispose(spine_to_scale_y obj) { + if (!obj) return; + delete (ToScaleY *) obj; +} + +float spine_to_scale_y_mix(spine_to_scale_y obj, spine_transform_constraint_pose pose) { + if (!obj) return 0; + ToScaleY *_obj = (ToScaleY *) obj; + return _obj->mix(pose); +} + +void spine_to_scale_y_apply(spine_to_scale_y obj, spine_skeleton skeleton, spine_transform_constraint_pose pose, spine_bone_pose bone, float value, spine_bool local, spine_bool additive) { + if (!obj) return ; + ToScaleY *_obj = (ToScaleY *) obj; + _obj->apply(skeleton, pose, bone, value, local, additive); +} diff --git a/spine-c-new/src/generated/to_scale_y.h b/spine-c-new/src/generated/to_scale_y.h new file mode 100644 index 000000000..a1ab8888a --- /dev/null +++ b/spine-c-new/src/generated/to_scale_y.h @@ -0,0 +1,49 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#ifndef SPINE_C_TOSCALEY_H +#define SPINE_C_TOSCALEY_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include "../custom.h" + +SPINE_OPAQUE_TYPE(spine_to_scale_y) + +SPINE_C_EXPORT void spine_to_scale_y_dispose(spine_to_scale_y obj); +SPINE_C_EXPORT float spine_to_scale_y_mix(spine_to_scale_y obj, spine_transform_constraint_pose pose); +SPINE_C_EXPORT void spine_to_scale_y_apply(spine_to_scale_y obj, spine_skeleton skeleton, spine_transform_constraint_pose pose, spine_bone_pose bone, float value, spine_bool local, spine_bool additive); + +#ifdef __cplusplus +} +#endif + +#endif // SPINE_C_TOSCALEY_H \ No newline at end of file diff --git a/spine-c-new/src/generated/to_shear_y.cpp b/spine-c-new/src/generated/to_shear_y.cpp new file mode 100644 index 000000000..6907f9eef --- /dev/null +++ b/spine-c-new/src/generated/to_shear_y.cpp @@ -0,0 +1,50 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#include "to_shear_y.h" +#include + +using namespace spine; + +void spine_to_shear_y_dispose(spine_to_shear_y obj) { + if (!obj) return; + delete (ToShearY *) obj; +} + +float spine_to_shear_y_mix(spine_to_shear_y obj, spine_transform_constraint_pose pose) { + if (!obj) return 0; + ToShearY *_obj = (ToShearY *) obj; + return _obj->mix(pose); +} + +void spine_to_shear_y_apply(spine_to_shear_y obj, spine_skeleton skeleton, spine_transform_constraint_pose pose, spine_bone_pose bone, float value, spine_bool local, spine_bool additive) { + if (!obj) return ; + ToShearY *_obj = (ToShearY *) obj; + _obj->apply(skeleton, pose, bone, value, local, additive); +} diff --git a/spine-c-new/src/generated/to_shear_y.h b/spine-c-new/src/generated/to_shear_y.h new file mode 100644 index 000000000..db3e2f277 --- /dev/null +++ b/spine-c-new/src/generated/to_shear_y.h @@ -0,0 +1,49 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#ifndef SPINE_C_TOSHEARY_H +#define SPINE_C_TOSHEARY_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include "../custom.h" + +SPINE_OPAQUE_TYPE(spine_to_shear_y) + +SPINE_C_EXPORT void spine_to_shear_y_dispose(spine_to_shear_y obj); +SPINE_C_EXPORT float spine_to_shear_y_mix(spine_to_shear_y obj, spine_transform_constraint_pose pose); +SPINE_C_EXPORT void spine_to_shear_y_apply(spine_to_shear_y obj, spine_skeleton skeleton, spine_transform_constraint_pose pose, spine_bone_pose bone, float value, spine_bool local, spine_bool additive); + +#ifdef __cplusplus +} +#endif + +#endif // SPINE_C_TOSHEARY_H \ No newline at end of file diff --git a/spine-c-new/src/generated/to_x.cpp b/spine-c-new/src/generated/to_x.cpp new file mode 100644 index 000000000..dbd634b2d --- /dev/null +++ b/spine-c-new/src/generated/to_x.cpp @@ -0,0 +1,50 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#include "to_x.h" +#include + +using namespace spine; + +void spine_to_x_dispose(spine_to_x obj) { + if (!obj) return; + delete (ToX *) obj; +} + +float spine_to_x_mix(spine_to_x obj, spine_transform_constraint_pose pose) { + if (!obj) return 0; + ToX *_obj = (ToX *) obj; + return _obj->mix(pose); +} + +void spine_to_x_apply(spine_to_x obj, spine_skeleton skeleton, spine_transform_constraint_pose pose, spine_bone_pose bone, float value, spine_bool local, spine_bool additive) { + if (!obj) return ; + ToX *_obj = (ToX *) obj; + _obj->apply(skeleton, pose, bone, value, local, additive); +} diff --git a/spine-c-new/src/generated/to_x.h b/spine-c-new/src/generated/to_x.h new file mode 100644 index 000000000..7031d2d84 --- /dev/null +++ b/spine-c-new/src/generated/to_x.h @@ -0,0 +1,49 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#ifndef SPINE_C_TOX_H +#define SPINE_C_TOX_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include "../custom.h" + +SPINE_OPAQUE_TYPE(spine_to_x) + +SPINE_C_EXPORT void spine_to_x_dispose(spine_to_x obj); +SPINE_C_EXPORT float spine_to_x_mix(spine_to_x obj, spine_transform_constraint_pose pose); +SPINE_C_EXPORT void spine_to_x_apply(spine_to_x obj, spine_skeleton skeleton, spine_transform_constraint_pose pose, spine_bone_pose bone, float value, spine_bool local, spine_bool additive); + +#ifdef __cplusplus +} +#endif + +#endif // SPINE_C_TOX_H \ No newline at end of file diff --git a/spine-c-new/src/generated/to_y.cpp b/spine-c-new/src/generated/to_y.cpp new file mode 100644 index 000000000..a45746be5 --- /dev/null +++ b/spine-c-new/src/generated/to_y.cpp @@ -0,0 +1,50 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#include "to_y.h" +#include + +using namespace spine; + +void spine_to_y_dispose(spine_to_y obj) { + if (!obj) return; + delete (ToY *) obj; +} + +float spine_to_y_mix(spine_to_y obj, spine_transform_constraint_pose pose) { + if (!obj) return 0; + ToY *_obj = (ToY *) obj; + return _obj->mix(pose); +} + +void spine_to_y_apply(spine_to_y obj, spine_skeleton skeleton, spine_transform_constraint_pose pose, spine_bone_pose bone, float value, spine_bool local, spine_bool additive) { + if (!obj) return ; + ToY *_obj = (ToY *) obj; + _obj->apply(skeleton, pose, bone, value, local, additive); +} diff --git a/spine-c-new/src/generated/to_y.h b/spine-c-new/src/generated/to_y.h new file mode 100644 index 000000000..bb30d1e07 --- /dev/null +++ b/spine-c-new/src/generated/to_y.h @@ -0,0 +1,49 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#ifndef SPINE_C_TOY_H +#define SPINE_C_TOY_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include "../custom.h" + +SPINE_OPAQUE_TYPE(spine_to_y) + +SPINE_C_EXPORT void spine_to_y_dispose(spine_to_y obj); +SPINE_C_EXPORT float spine_to_y_mix(spine_to_y obj, spine_transform_constraint_pose pose); +SPINE_C_EXPORT void spine_to_y_apply(spine_to_y obj, spine_skeleton skeleton, spine_transform_constraint_pose pose, spine_bone_pose bone, float value, spine_bool local, spine_bool additive); + +#ifdef __cplusplus +} +#endif + +#endif // SPINE_C_TOY_H \ No newline at end of file diff --git a/spine-c-new/src/generated/track_entry.cpp b/spine-c-new/src/generated/track_entry.cpp new file mode 100644 index 000000000..a99de4ebd --- /dev/null +++ b/spine-c-new/src/generated/track_entry.cpp @@ -0,0 +1,385 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#include "track_entry.h" +#include + +using namespace spine; + +spine_track_entry spine_track_entry_create(void) { + TrackEntry *obj = new (__FILE__, __LINE__) TrackEntry(); + return (spine_track_entry) obj; +} + +void spine_track_entry_dispose(spine_track_entry obj) { + if (!obj) return; + delete (TrackEntry *) obj; +} + +int32_t spine_track_entry_get_track_index(spine_track_entry obj) { + if (!obj) return 0; + TrackEntry *_obj = (TrackEntry *) obj; + return _obj->getTrackIndex(); +} + +spine_animation spine_track_entry_get_animation(spine_track_entry obj) { + if (!obj) return nullptr; + TrackEntry *_obj = (TrackEntry *) obj; + return (spine_animation) _obj->getAnimation(); +} + +void spine_track_entry_set_animation(spine_track_entry obj, spine_animation value) { + if (!obj) return; + TrackEntry *_obj = (TrackEntry *) obj; + _obj->setAnimation((Animation *) value); +} + +spine_track_entry spine_track_entry_get_previous(spine_track_entry obj) { + if (!obj) return nullptr; + TrackEntry *_obj = (TrackEntry *) obj; + return (spine_track_entry) _obj->getPrevious(); +} + +spine_bool spine_track_entry_get_loop(spine_track_entry obj) { + if (!obj) return 0; + TrackEntry *_obj = (TrackEntry *) obj; + return _obj->getLoop(); +} + +void spine_track_entry_set_loop(spine_track_entry obj, spine_bool value) { + if (!obj) return; + TrackEntry *_obj = (TrackEntry *) obj; + _obj->setLoop(value); +} + +spine_bool spine_track_entry_get_hold_previous(spine_track_entry obj) { + if (!obj) return 0; + TrackEntry *_obj = (TrackEntry *) obj; + return _obj->getHoldPrevious(); +} + +void spine_track_entry_set_hold_previous(spine_track_entry obj, spine_bool value) { + if (!obj) return; + TrackEntry *_obj = (TrackEntry *) obj; + _obj->setHoldPrevious(value); +} + +spine_bool spine_track_entry_get_reverse(spine_track_entry obj) { + if (!obj) return 0; + TrackEntry *_obj = (TrackEntry *) obj; + return _obj->getReverse(); +} + +void spine_track_entry_set_reverse(spine_track_entry obj, spine_bool value) { + if (!obj) return; + TrackEntry *_obj = (TrackEntry *) obj; + _obj->setReverse(value); +} + +spine_bool spine_track_entry_get_shortest_rotation(spine_track_entry obj) { + if (!obj) return 0; + TrackEntry *_obj = (TrackEntry *) obj; + return _obj->getShortestRotation(); +} + +void spine_track_entry_set_shortest_rotation(spine_track_entry obj, spine_bool value) { + if (!obj) return; + TrackEntry *_obj = (TrackEntry *) obj; + _obj->setShortestRotation(value); +} + +float spine_track_entry_get_delay(spine_track_entry obj) { + if (!obj) return 0; + TrackEntry *_obj = (TrackEntry *) obj; + return _obj->getDelay(); +} + +void spine_track_entry_set_delay(spine_track_entry obj, float value) { + if (!obj) return; + TrackEntry *_obj = (TrackEntry *) obj; + _obj->setDelay(value); +} + +float spine_track_entry_get_track_time(spine_track_entry obj) { + if (!obj) return 0; + TrackEntry *_obj = (TrackEntry *) obj; + return _obj->getTrackTime(); +} + +void spine_track_entry_set_track_time(spine_track_entry obj, float value) { + if (!obj) return; + TrackEntry *_obj = (TrackEntry *) obj; + _obj->setTrackTime(value); +} + +float spine_track_entry_get_track_end(spine_track_entry obj) { + if (!obj) return 0; + TrackEntry *_obj = (TrackEntry *) obj; + return _obj->getTrackEnd(); +} + +void spine_track_entry_set_track_end(spine_track_entry obj, float value) { + if (!obj) return; + TrackEntry *_obj = (TrackEntry *) obj; + _obj->setTrackEnd(value); +} + +float spine_track_entry_get_animation_start(spine_track_entry obj) { + if (!obj) return 0; + TrackEntry *_obj = (TrackEntry *) obj; + return _obj->getAnimationStart(); +} + +void spine_track_entry_set_animation_start(spine_track_entry obj, float value) { + if (!obj) return; + TrackEntry *_obj = (TrackEntry *) obj; + _obj->setAnimationStart(value); +} + +float spine_track_entry_get_animation_end(spine_track_entry obj) { + if (!obj) return 0; + TrackEntry *_obj = (TrackEntry *) obj; + return _obj->getAnimationEnd(); +} + +void spine_track_entry_set_animation_end(spine_track_entry obj, float value) { + if (!obj) return; + TrackEntry *_obj = (TrackEntry *) obj; + _obj->setAnimationEnd(value); +} + +float spine_track_entry_get_animation_last(spine_track_entry obj) { + if (!obj) return 0; + TrackEntry *_obj = (TrackEntry *) obj; + return _obj->getAnimationLast(); +} + +void spine_track_entry_set_animation_last(spine_track_entry obj, float value) { + if (!obj) return; + TrackEntry *_obj = (TrackEntry *) obj; + _obj->setAnimationLast(value); +} + +float spine_track_entry_get_animation_time(spine_track_entry obj) { + if (!obj) return 0; + TrackEntry *_obj = (TrackEntry *) obj; + return _obj->getAnimationTime(); +} + +float spine_track_entry_get_time_scale(spine_track_entry obj) { + if (!obj) return 0; + TrackEntry *_obj = (TrackEntry *) obj; + return _obj->getTimeScale(); +} + +void spine_track_entry_set_time_scale(spine_track_entry obj, float value) { + if (!obj) return; + TrackEntry *_obj = (TrackEntry *) obj; + _obj->setTimeScale(value); +} + +float spine_track_entry_get_alpha(spine_track_entry obj) { + if (!obj) return 0; + TrackEntry *_obj = (TrackEntry *) obj; + return _obj->getAlpha(); +} + +void spine_track_entry_set_alpha(spine_track_entry obj, float value) { + if (!obj) return; + TrackEntry *_obj = (TrackEntry *) obj; + _obj->setAlpha(value); +} + +float spine_track_entry_get_event_threshold(spine_track_entry obj) { + if (!obj) return 0; + TrackEntry *_obj = (TrackEntry *) obj; + return _obj->getEventThreshold(); +} + +void spine_track_entry_set_event_threshold(spine_track_entry obj, float value) { + if (!obj) return; + TrackEntry *_obj = (TrackEntry *) obj; + _obj->setEventThreshold(value); +} + +float spine_track_entry_get_mix_attachment_threshold(spine_track_entry obj) { + if (!obj) return 0; + TrackEntry *_obj = (TrackEntry *) obj; + return _obj->getMixAttachmentThreshold(); +} + +void spine_track_entry_set_mix_attachment_threshold(spine_track_entry obj, float value) { + if (!obj) return; + TrackEntry *_obj = (TrackEntry *) obj; + _obj->setMixAttachmentThreshold(value); +} + +float spine_track_entry_get_alpha_attachment_threshold(spine_track_entry obj) { + if (!obj) return 0; + TrackEntry *_obj = (TrackEntry *) obj; + return _obj->getAlphaAttachmentThreshold(); +} + +void spine_track_entry_set_alpha_attachment_threshold(spine_track_entry obj, float value) { + if (!obj) return; + TrackEntry *_obj = (TrackEntry *) obj; + _obj->setAlphaAttachmentThreshold(value); +} + +float spine_track_entry_get_mix_draw_order_threshold(spine_track_entry obj) { + if (!obj) return 0; + TrackEntry *_obj = (TrackEntry *) obj; + return _obj->getMixDrawOrderThreshold(); +} + +void spine_track_entry_set_mix_draw_order_threshold(spine_track_entry obj, float value) { + if (!obj) return; + TrackEntry *_obj = (TrackEntry *) obj; + _obj->setMixDrawOrderThreshold(value); +} + +spine_track_entry spine_track_entry_get_next(spine_track_entry obj) { + if (!obj) return nullptr; + TrackEntry *_obj = (TrackEntry *) obj; + return (spine_track_entry) _obj->getNext(); +} + +spine_bool spine_track_entry_is_complete(spine_track_entry obj) { + if (!obj) return 0; + TrackEntry *_obj = (TrackEntry *) obj; + return _obj->isComplete(); +} + +float spine_track_entry_get_mix_time(spine_track_entry obj) { + if (!obj) return 0; + TrackEntry *_obj = (TrackEntry *) obj; + return _obj->getMixTime(); +} + +void spine_track_entry_set_mix_time(spine_track_entry obj, float value) { + if (!obj) return; + TrackEntry *_obj = (TrackEntry *) obj; + _obj->setMixTime(value); +} + +float spine_track_entry_get_mix_duration(spine_track_entry obj) { + if (!obj) return 0; + TrackEntry *_obj = (TrackEntry *) obj; + return _obj->getMixDuration(); +} + +void spine_track_entry_set_mix_duration(spine_track_entry obj, float value) { + if (!obj) return; + TrackEntry *_obj = (TrackEntry *) obj; + _obj->setMixDuration(value); +} + +void spine_track_entry_set_mix_duration(spine_track_entry obj, float mixDuration, float delay) { + if (!obj) return ; + TrackEntry *_obj = (TrackEntry *) obj; + _obj->setMixDuration(mixDuration, delay); +} + +spine_mix_blend spine_track_entry_get_mix_blend(spine_track_entry obj) { + if (!obj) return nullptr; + TrackEntry *_obj = (TrackEntry *) obj; + return _obj->getMixBlend(); +} + +void spine_track_entry_set_mix_blend(spine_track_entry obj, spine_mix_blend value) { + if (!obj) return; + TrackEntry *_obj = (TrackEntry *) obj; + _obj->setMixBlend(value); +} + +spine_track_entry spine_track_entry_get_mixing_from(spine_track_entry obj) { + if (!obj) return nullptr; + TrackEntry *_obj = (TrackEntry *) obj; + return (spine_track_entry) _obj->getMixingFrom(); +} + +spine_track_entry spine_track_entry_get_mixing_to(spine_track_entry obj) { + if (!obj) return nullptr; + TrackEntry *_obj = (TrackEntry *) obj; + return (spine_track_entry) _obj->getMixingTo(); +} + +void spine_track_entry_reset_rotation_directions(spine_track_entry obj) { + if (!obj) return ; + TrackEntry *_obj = (TrackEntry *) obj; + _obj->resetRotationDirections(); +} + +float spine_track_entry_get_track_complete(spine_track_entry obj) { + if (!obj) return 0; + TrackEntry *_obj = (TrackEntry *) obj; + return _obj->getTrackComplete(); +} + +void spine_track_entry_set_listener(spine_track_entry obj, spine_animation_state_listener value) { + if (!obj) return; + TrackEntry *_obj = (TrackEntry *) obj; + _obj->setListener(value); +} + +void spine_track_entry_set_listener(spine_track_entry obj, spine_animation_state_listener_object value) { + if (!obj) return; + TrackEntry *_obj = (TrackEntry *) obj; + _obj->setListener((AnimationStateListenerObject *) value); +} + +spine_bool spine_track_entry_is_empty_animation(spine_track_entry obj) { + if (!obj) return 0; + TrackEntry *_obj = (TrackEntry *) obj; + return _obj->isEmptyAnimation(); +} + +spine_bool spine_track_entry_was_applied(spine_track_entry obj) { + if (!obj) return 0; + TrackEntry *_obj = (TrackEntry *) obj; + return _obj->wasApplied(); +} + +spine_bool spine_track_entry_is_next_ready(spine_track_entry obj) { + if (!obj) return 0; + TrackEntry *_obj = (TrackEntry *) obj; + return _obj->isNextReady(); +} + +spine_void spine_track_entry_get_renderer_object(spine_track_entry obj) { + if (!obj) return nullptr; + TrackEntry *_obj = (TrackEntry *) obj; + return (spine_void) _obj->getRendererObject(); +} + +void spine_track_entry_set_renderer_object(spine_track_entry obj, spine_void rendererObject, spine_dispose_renderer_object dispose) { + if (!obj) return ; + TrackEntry *_obj = (TrackEntry *) obj; + _obj->setRendererObject((void *) rendererObject, dispose); +} diff --git a/spine-c-new/src/generated/track_entry.h b/spine-c-new/src/generated/track_entry.h new file mode 100644 index 000000000..3d733b07b --- /dev/null +++ b/spine-c-new/src/generated/track_entry.h @@ -0,0 +1,105 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#ifndef SPINE_C_TRACKENTRY_H +#define SPINE_C_TRACKENTRY_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include "../custom.h" + +SPINE_OPAQUE_TYPE(spine_track_entry) + +SPINE_C_EXPORT spine_track_entry spine_track_entry_create(void); +SPINE_C_EXPORT void spine_track_entry_dispose(spine_track_entry obj); +SPINE_C_EXPORT int32_t spine_track_entry_get_track_index(spine_track_entry obj); +SPINE_C_EXPORT spine_animation spine_track_entry_get_animation(spine_track_entry obj); +SPINE_C_EXPORT void spine_track_entry_set_animation(spine_track_entry obj, spine_animation value); +SPINE_C_EXPORT spine_track_entry spine_track_entry_get_previous(spine_track_entry obj); +SPINE_C_EXPORT spine_bool spine_track_entry_get_loop(spine_track_entry obj); +SPINE_C_EXPORT void spine_track_entry_set_loop(spine_track_entry obj, spine_bool value); +SPINE_C_EXPORT spine_bool spine_track_entry_get_hold_previous(spine_track_entry obj); +SPINE_C_EXPORT void spine_track_entry_set_hold_previous(spine_track_entry obj, spine_bool value); +SPINE_C_EXPORT spine_bool spine_track_entry_get_reverse(spine_track_entry obj); +SPINE_C_EXPORT void spine_track_entry_set_reverse(spine_track_entry obj, spine_bool value); +SPINE_C_EXPORT spine_bool spine_track_entry_get_shortest_rotation(spine_track_entry obj); +SPINE_C_EXPORT void spine_track_entry_set_shortest_rotation(spine_track_entry obj, spine_bool value); +SPINE_C_EXPORT float spine_track_entry_get_delay(spine_track_entry obj); +SPINE_C_EXPORT void spine_track_entry_set_delay(spine_track_entry obj, float value); +SPINE_C_EXPORT float spine_track_entry_get_track_time(spine_track_entry obj); +SPINE_C_EXPORT void spine_track_entry_set_track_time(spine_track_entry obj, float value); +SPINE_C_EXPORT float spine_track_entry_get_track_end(spine_track_entry obj); +SPINE_C_EXPORT void spine_track_entry_set_track_end(spine_track_entry obj, float value); +SPINE_C_EXPORT float spine_track_entry_get_animation_start(spine_track_entry obj); +SPINE_C_EXPORT void spine_track_entry_set_animation_start(spine_track_entry obj, float value); +SPINE_C_EXPORT float spine_track_entry_get_animation_end(spine_track_entry obj); +SPINE_C_EXPORT void spine_track_entry_set_animation_end(spine_track_entry obj, float value); +SPINE_C_EXPORT float spine_track_entry_get_animation_last(spine_track_entry obj); +SPINE_C_EXPORT void spine_track_entry_set_animation_last(spine_track_entry obj, float value); +SPINE_C_EXPORT float spine_track_entry_get_animation_time(spine_track_entry obj); +SPINE_C_EXPORT float spine_track_entry_get_time_scale(spine_track_entry obj); +SPINE_C_EXPORT void spine_track_entry_set_time_scale(spine_track_entry obj, float value); +SPINE_C_EXPORT float spine_track_entry_get_alpha(spine_track_entry obj); +SPINE_C_EXPORT void spine_track_entry_set_alpha(spine_track_entry obj, float value); +SPINE_C_EXPORT float spine_track_entry_get_event_threshold(spine_track_entry obj); +SPINE_C_EXPORT void spine_track_entry_set_event_threshold(spine_track_entry obj, float value); +SPINE_C_EXPORT float spine_track_entry_get_mix_attachment_threshold(spine_track_entry obj); +SPINE_C_EXPORT void spine_track_entry_set_mix_attachment_threshold(spine_track_entry obj, float value); +SPINE_C_EXPORT float spine_track_entry_get_alpha_attachment_threshold(spine_track_entry obj); +SPINE_C_EXPORT void spine_track_entry_set_alpha_attachment_threshold(spine_track_entry obj, float value); +SPINE_C_EXPORT float spine_track_entry_get_mix_draw_order_threshold(spine_track_entry obj); +SPINE_C_EXPORT void spine_track_entry_set_mix_draw_order_threshold(spine_track_entry obj, float value); +SPINE_C_EXPORT spine_track_entry spine_track_entry_get_next(spine_track_entry obj); +SPINE_C_EXPORT spine_bool spine_track_entry_is_complete(spine_track_entry obj); +SPINE_C_EXPORT float spine_track_entry_get_mix_time(spine_track_entry obj); +SPINE_C_EXPORT void spine_track_entry_set_mix_time(spine_track_entry obj, float value); +SPINE_C_EXPORT float spine_track_entry_get_mix_duration(spine_track_entry obj); +SPINE_C_EXPORT void spine_track_entry_set_mix_duration(spine_track_entry obj, float value); +SPINE_C_EXPORT void spine_track_entry_set_mix_duration(spine_track_entry obj, float mixDuration, float delay); +SPINE_C_EXPORT spine_mix_blend spine_track_entry_get_mix_blend(spine_track_entry obj); +SPINE_C_EXPORT void spine_track_entry_set_mix_blend(spine_track_entry obj, spine_mix_blend value); +SPINE_C_EXPORT spine_track_entry spine_track_entry_get_mixing_from(spine_track_entry obj); +SPINE_C_EXPORT spine_track_entry spine_track_entry_get_mixing_to(spine_track_entry obj); +SPINE_C_EXPORT void spine_track_entry_reset_rotation_directions(spine_track_entry obj); +SPINE_C_EXPORT float spine_track_entry_get_track_complete(spine_track_entry obj); +SPINE_C_EXPORT void spine_track_entry_set_listener(spine_track_entry obj, spine_animation_state_listener value); +SPINE_C_EXPORT void spine_track_entry_set_listener(spine_track_entry obj, spine_animation_state_listener_object value); +SPINE_C_EXPORT spine_bool spine_track_entry_is_empty_animation(spine_track_entry obj); +SPINE_C_EXPORT spine_bool spine_track_entry_was_applied(spine_track_entry obj); +SPINE_C_EXPORT spine_bool spine_track_entry_is_next_ready(spine_track_entry obj); +SPINE_C_EXPORT spine_void spine_track_entry_get_renderer_object(spine_track_entry obj); +SPINE_C_EXPORT void spine_track_entry_set_renderer_object(spine_track_entry obj, spine_void rendererObject, spine_dispose_renderer_object dispose); + +#ifdef __cplusplus +} +#endif + +#endif // SPINE_C_TRACKENTRY_H \ No newline at end of file diff --git a/spine-c-new/src/generated/transform_constraint.cpp b/spine-c-new/src/generated/transform_constraint.cpp new file mode 100644 index 000000000..328765571 --- /dev/null +++ b/spine-c-new/src/generated/transform_constraint.cpp @@ -0,0 +1,163 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#include "transform_constraint.h" +#include + +using namespace spine; + +spine_transform_constraint spine_transform_constraint_create(spine_transform_constraint_data data, spine_skeleton skeleton) { + TransformConstraint *obj = new (__FILE__, __LINE__) TransformConstraint(data, skeleton); + return (spine_transform_constraint) obj; +} + +void spine_transform_constraint_dispose(spine_transform_constraint obj) { + if (!obj) return; + delete (TransformConstraint *) obj; +} + +spine_rtti spine_transform_constraint_get_rtti(spine_transform_constraint obj) { + if (!obj) return nullptr; + TransformConstraint *_obj = (TransformConstraint *) obj; + return (spine_rtti) &_obj->getRTTI(); +} + +spine_transform_constraint spine_transform_constraint_copy(spine_transform_constraint obj, spine_skeleton skeleton) { + if (!obj) return 0; + TransformConstraint *_obj = (TransformConstraint *) obj; + return (spine_transform_constraint) _obj->copy(skeleton); +} + +void spine_transform_constraint_update(spine_transform_constraint obj, spine_skeleton skeleton, spine_physics physics) { + if (!obj) return ; + TransformConstraint *_obj = (TransformConstraint *) obj; + _obj->update(skeleton, physics); +} + +void spine_transform_constraint_sort(spine_transform_constraint obj, spine_skeleton skeleton) { + if (!obj) return ; + TransformConstraint *_obj = (TransformConstraint *) obj; + _obj->sort(skeleton); +} + +spine_bool spine_transform_constraint_is_source_active(spine_transform_constraint obj) { + if (!obj) return 0; + TransformConstraint *_obj = (TransformConstraint *) obj; + return _obj->isSourceActive(); +} + +void * spine_transform_constraint_get_bones(spine_transform_constraint obj) { + if (!obj) return nullptr; + TransformConstraint *_obj = (TransformConstraint *) obj; + return (void *) _obj->getBones(); +} + +int32_t spine_transform_constraint_get_num_bones(spine_transform_constraint obj) { + if (!obj) return 0; + TransformConstraint *_obj = (TransformConstraint *) obj; + return (int32_t) _obj->getBones().size(); +} + +spine_bone_pose *spine_transform_constraint_get_bones(spine_transform_constraint obj) { + if (!obj) return nullptr; + TransformConstraint *_obj = (TransformConstraint *) obj; + return (spine_bone_pose *) _obj->getBones().buffer(); +} + +spine_bone spine_transform_constraint_get_source(spine_transform_constraint obj) { + if (!obj) return nullptr; + TransformConstraint *_obj = (TransformConstraint *) obj; + return (spine_bone) _obj->getSource(); +} + +void spine_transform_constraint_set_source(spine_transform_constraint obj, spine_bone value) { + if (!obj) return; + TransformConstraint *_obj = (TransformConstraint *) obj; + _obj->setSource((Bone *) value); +} + +spine_constraint_data spine_transform_constraint_get_data(spine_transform_constraint obj) { + if (!obj) return 0; + TransformConstraint *_obj = (TransformConstraint *) obj; + return _obj->getData(); +} + +void spine_transform_constraint_pose(spine_transform_constraint obj) { + if (!obj) return ; + TransformConstraint *_obj = (TransformConstraint *) obj; + _obj->pose(); +} + +void spine_transform_constraint_setup_pose(spine_transform_constraint obj) { + if (!obj) return ; + TransformConstraint *_obj = (TransformConstraint *) obj; + _obj->setupPose(); +} + +spine_transform_constraint_pose spine_transform_constraint_get_pose(spine_transform_constraint obj) { + if (!obj) return 0; + TransformConstraint *_obj = (TransformConstraint *) obj; + return _obj->getPose(); +} + +spine_transform_constraint_pose spine_transform_constraint_get_applied_pose(spine_transform_constraint obj) { + if (!obj) return 0; + TransformConstraint *_obj = (TransformConstraint *) obj; + return _obj->getAppliedPose(); +} + +void spine_transform_constraint_reset_constrained(spine_transform_constraint obj) { + if (!obj) return ; + TransformConstraint *_obj = (TransformConstraint *) obj; + _obj->resetConstrained(); +} + +void spine_transform_constraint_constrained(spine_transform_constraint obj) { + if (!obj) return ; + TransformConstraint *_obj = (TransformConstraint *) obj; + _obj->constrained(); +} + +spine_bool spine_transform_constraint_is_pose_equal_to_applied(spine_transform_constraint obj) { + if (!obj) return 0; + TransformConstraint *_obj = (TransformConstraint *) obj; + return _obj->isPoseEqualToApplied(); +} + +spine_bool spine_transform_constraint_is_active(spine_transform_constraint obj) { + if (!obj) return 0; + TransformConstraint *_obj = (TransformConstraint *) obj; + return _obj->isActive(); +} + +void spine_transform_constraint_set_active(spine_transform_constraint obj, spine_bool value) { + if (!obj) return; + TransformConstraint *_obj = (TransformConstraint *) obj; + _obj->setActive(value); +} diff --git a/spine-c-new/src/generated/transform_constraint.h b/spine-c-new/src/generated/transform_constraint.h new file mode 100644 index 000000000..cc394a620 --- /dev/null +++ b/spine-c-new/src/generated/transform_constraint.h @@ -0,0 +1,68 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#ifndef SPINE_C_TRANSFORMCONSTRAINT_H +#define SPINE_C_TRANSFORMCONSTRAINT_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include "../custom.h" + +SPINE_OPAQUE_TYPE(spine_transform_constraint) + +SPINE_C_EXPORT spine_transform_constraint spine_transform_constraint_create(spine_transform_constraint_data data, spine_skeleton skeleton); +SPINE_C_EXPORT void spine_transform_constraint_dispose(spine_transform_constraint obj); +SPINE_C_EXPORT spine_rtti spine_transform_constraint_get_rtti(spine_transform_constraint obj); +SPINE_C_EXPORT spine_transform_constraint spine_transform_constraint_copy(spine_transform_constraint obj, spine_skeleton skeleton); +SPINE_C_EXPORT void spine_transform_constraint_update(spine_transform_constraint obj, spine_skeleton skeleton, spine_physics physics); +SPINE_C_EXPORT void spine_transform_constraint_sort(spine_transform_constraint obj, spine_skeleton skeleton); +SPINE_C_EXPORT spine_bool spine_transform_constraint_is_source_active(spine_transform_constraint obj); +SPINE_C_EXPORT void * spine_transform_constraint_get_bones(spine_transform_constraint obj); +SPINE_C_EXPORT int32_t spine_transform_constraint_get_num_bones(spine_transform_constraint obj); +SPINE_C_EXPORT spine_bone_pose *spine_transform_constraint_get_bones(spine_transform_constraint obj); +SPINE_C_EXPORT spine_bone spine_transform_constraint_get_source(spine_transform_constraint obj); +SPINE_C_EXPORT void spine_transform_constraint_set_source(spine_transform_constraint obj, spine_bone value); +SPINE_C_EXPORT spine_constraint_data spine_transform_constraint_get_data(spine_transform_constraint obj); +SPINE_C_EXPORT void spine_transform_constraint_pose(spine_transform_constraint obj); +SPINE_C_EXPORT void spine_transform_constraint_setup_pose(spine_transform_constraint obj); +SPINE_C_EXPORT spine_transform_constraint_pose spine_transform_constraint_get_pose(spine_transform_constraint obj); +SPINE_C_EXPORT spine_transform_constraint_pose spine_transform_constraint_get_applied_pose(spine_transform_constraint obj); +SPINE_C_EXPORT void spine_transform_constraint_reset_constrained(spine_transform_constraint obj); +SPINE_C_EXPORT void spine_transform_constraint_constrained(spine_transform_constraint obj); +SPINE_C_EXPORT spine_bool spine_transform_constraint_is_pose_equal_to_applied(spine_transform_constraint obj); +SPINE_C_EXPORT spine_bool spine_transform_constraint_is_active(spine_transform_constraint obj); +SPINE_C_EXPORT void spine_transform_constraint_set_active(spine_transform_constraint obj, spine_bool value); + +#ifdef __cplusplus +} +#endif + +#endif // SPINE_C_TRANSFORMCONSTRAINT_H \ No newline at end of file diff --git a/spine-c-new/src/generated/transform_constraint_data.cpp b/spine-c-new/src/generated/transform_constraint_data.cpp new file mode 100644 index 000000000..10086e7e9 --- /dev/null +++ b/spine-c-new/src/generated/transform_constraint_data.cpp @@ -0,0 +1,247 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#include "transform_constraint_data.h" +#include + +using namespace spine; + +spine_transform_constraint_data spine_transform_constraint_data_create(const utf8 * name) { + TransformConstraintData *obj = new (__FILE__, __LINE__) TransformConstraintData(String(name)); + return (spine_transform_constraint_data) obj; +} + +void spine_transform_constraint_data_dispose(spine_transform_constraint_data obj) { + if (!obj) return; + delete (TransformConstraintData *) obj; +} + +spine_rtti spine_transform_constraint_data_get_rtti(spine_transform_constraint_data obj) { + if (!obj) return nullptr; + TransformConstraintData *_obj = (TransformConstraintData *) obj; + return (spine_rtti) &_obj->getRTTI(); +} + +spine_constraint spine_transform_constraint_data_create(spine_transform_constraint_data obj, spine_skeleton skeleton) { + if (!obj) return 0; + TransformConstraintData *_obj = (TransformConstraintData *) obj; + return (spine_constraint) _obj->create(skeleton); +} + +void * spine_transform_constraint_data_get_bones(spine_transform_constraint_data obj) { + if (!obj) return nullptr; + TransformConstraintData *_obj = (TransformConstraintData *) obj; + return (void *) _obj->getBones(); +} + +int32_t spine_transform_constraint_data_get_num_bones(spine_transform_constraint_data obj) { + if (!obj) return 0; + TransformConstraintData *_obj = (TransformConstraintData *) obj; + return (int32_t) _obj->getBones().size(); +} + +spine_bone_data *spine_transform_constraint_data_get_bones(spine_transform_constraint_data obj) { + if (!obj) return nullptr; + TransformConstraintData *_obj = (TransformConstraintData *) obj; + return (spine_bone_data *) _obj->getBones().buffer(); +} + +spine_bone_data spine_transform_constraint_data_get_source(spine_transform_constraint_data obj) { + if (!obj) return nullptr; + TransformConstraintData *_obj = (TransformConstraintData *) obj; + return (spine_bone_data) _obj->getSource(); +} + +void spine_transform_constraint_data_set_source(spine_transform_constraint_data obj, spine_bone_data value) { + if (!obj) return; + TransformConstraintData *_obj = (TransformConstraintData *) obj; + _obj->setSource((BoneData *) value); +} + +float spine_transform_constraint_data_get_offset_rotation(spine_transform_constraint_data obj) { + if (!obj) return 0; + TransformConstraintData *_obj = (TransformConstraintData *) obj; + return _obj->getOffsetRotation(); +} + +void spine_transform_constraint_data_set_offset_rotation(spine_transform_constraint_data obj, float value) { + if (!obj) return; + TransformConstraintData *_obj = (TransformConstraintData *) obj; + _obj->setOffsetRotation(value); +} + +float spine_transform_constraint_data_get_offset_x(spine_transform_constraint_data obj) { + if (!obj) return 0; + TransformConstraintData *_obj = (TransformConstraintData *) obj; + return _obj->getOffsetX(); +} + +void spine_transform_constraint_data_set_offset_x(spine_transform_constraint_data obj, float value) { + if (!obj) return; + TransformConstraintData *_obj = (TransformConstraintData *) obj; + _obj->setOffsetX(value); +} + +float spine_transform_constraint_data_get_offset_y(spine_transform_constraint_data obj) { + if (!obj) return 0; + TransformConstraintData *_obj = (TransformConstraintData *) obj; + return _obj->getOffsetY(); +} + +void spine_transform_constraint_data_set_offset_y(spine_transform_constraint_data obj, float value) { + if (!obj) return; + TransformConstraintData *_obj = (TransformConstraintData *) obj; + _obj->setOffsetY(value); +} + +float spine_transform_constraint_data_get_offset_scale_x(spine_transform_constraint_data obj) { + if (!obj) return 0; + TransformConstraintData *_obj = (TransformConstraintData *) obj; + return _obj->getOffsetScaleX(); +} + +void spine_transform_constraint_data_set_offset_scale_x(spine_transform_constraint_data obj, float value) { + if (!obj) return; + TransformConstraintData *_obj = (TransformConstraintData *) obj; + _obj->setOffsetScaleX(value); +} + +float spine_transform_constraint_data_get_offset_scale_y(spine_transform_constraint_data obj) { + if (!obj) return 0; + TransformConstraintData *_obj = (TransformConstraintData *) obj; + return _obj->getOffsetScaleY(); +} + +void spine_transform_constraint_data_set_offset_scale_y(spine_transform_constraint_data obj, float value) { + if (!obj) return; + TransformConstraintData *_obj = (TransformConstraintData *) obj; + _obj->setOffsetScaleY(value); +} + +float spine_transform_constraint_data_get_offset_shear_y(spine_transform_constraint_data obj) { + if (!obj) return 0; + TransformConstraintData *_obj = (TransformConstraintData *) obj; + return _obj->getOffsetShearY(); +} + +void spine_transform_constraint_data_set_offset_shear_y(spine_transform_constraint_data obj, float value) { + if (!obj) return; + TransformConstraintData *_obj = (TransformConstraintData *) obj; + _obj->setOffsetShearY(value); +} + +spine_bool spine_transform_constraint_data_get_local_source(spine_transform_constraint_data obj) { + if (!obj) return 0; + TransformConstraintData *_obj = (TransformConstraintData *) obj; + return _obj->getLocalSource(); +} + +void spine_transform_constraint_data_set_local_source(spine_transform_constraint_data obj, spine_bool value) { + if (!obj) return; + TransformConstraintData *_obj = (TransformConstraintData *) obj; + _obj->setLocalSource(value); +} + +spine_bool spine_transform_constraint_data_get_local_target(spine_transform_constraint_data obj) { + if (!obj) return 0; + TransformConstraintData *_obj = (TransformConstraintData *) obj; + return _obj->getLocalTarget(); +} + +void spine_transform_constraint_data_set_local_target(spine_transform_constraint_data obj, spine_bool value) { + if (!obj) return; + TransformConstraintData *_obj = (TransformConstraintData *) obj; + _obj->setLocalTarget(value); +} + +spine_bool spine_transform_constraint_data_get_additive(spine_transform_constraint_data obj) { + if (!obj) return 0; + TransformConstraintData *_obj = (TransformConstraintData *) obj; + return _obj->getAdditive(); +} + +void spine_transform_constraint_data_set_additive(spine_transform_constraint_data obj, spine_bool value) { + if (!obj) return; + TransformConstraintData *_obj = (TransformConstraintData *) obj; + _obj->setAdditive(value); +} + +spine_bool spine_transform_constraint_data_get_clamp(spine_transform_constraint_data obj) { + if (!obj) return 0; + TransformConstraintData *_obj = (TransformConstraintData *) obj; + return _obj->getClamp(); +} + +void spine_transform_constraint_data_set_clamp(spine_transform_constraint_data obj, spine_bool value) { + if (!obj) return; + TransformConstraintData *_obj = (TransformConstraintData *) obj; + _obj->setClamp(value); +} + +void * spine_transform_constraint_data_get_properties(spine_transform_constraint_data obj) { + if (!obj) return nullptr; + TransformConstraintData *_obj = (TransformConstraintData *) obj; + return (void *) _obj->getProperties(); +} + +int32_t spine_transform_constraint_data_get_num_properties(spine_transform_constraint_data obj) { + if (!obj) return 0; + TransformConstraintData *_obj = (TransformConstraintData *) obj; + return (int32_t) _obj->getProperties().size(); +} + +spine_class from_property *spine_transform_constraint_data_get_properties(spine_transform_constraint_data obj) { + if (!obj) return nullptr; + TransformConstraintData *_obj = (TransformConstraintData *) obj; + return (spine_class from_property *) _obj->getProperties().buffer(); +} + +const utf8 * spine_transform_constraint_data_get_name(spine_transform_constraint_data obj) { + if (!obj) return nullptr; + TransformConstraintData *_obj = (TransformConstraintData *) obj; + return (const utf8 *) _obj->getName().buffer(); +} + +spine_bool spine_transform_constraint_data_is_skin_required(spine_transform_constraint_data obj) { + if (!obj) return 0; + TransformConstraintData *_obj = (TransformConstraintData *) obj; + return _obj->isSkinRequired(); +} + +spine_transform_constraint_pose spine_transform_constraint_data_get_setup_pose(spine_transform_constraint_data obj) { + if (!obj) return 0; + TransformConstraintData *_obj = (TransformConstraintData *) obj; + return _obj->getSetupPose(); +} + +spine_transform_constraint_pose spine_transform_constraint_data_get_setup_pose(spine_transform_constraint_data obj) { + if (!obj) return 0; + TransformConstraintData *_obj = (TransformConstraintData *) obj; + return _obj->getSetupPose(); +} diff --git a/spine-c-new/src/generated/transform_constraint_data.h b/spine-c-new/src/generated/transform_constraint_data.h new file mode 100644 index 000000000..d6dcdbd87 --- /dev/null +++ b/spine-c-new/src/generated/transform_constraint_data.h @@ -0,0 +1,82 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#ifndef SPINE_C_TRANSFORMCONSTRAINTDATA_H +#define SPINE_C_TRANSFORMCONSTRAINTDATA_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include "../custom.h" + +SPINE_OPAQUE_TYPE(spine_transform_constraint_data) + +SPINE_C_EXPORT spine_transform_constraint_data spine_transform_constraint_data_create(const utf8 * name); +SPINE_C_EXPORT void spine_transform_constraint_data_dispose(spine_transform_constraint_data obj); +SPINE_C_EXPORT spine_rtti spine_transform_constraint_data_get_rtti(spine_transform_constraint_data obj); +SPINE_C_EXPORT spine_constraint spine_transform_constraint_data_create(spine_transform_constraint_data obj, spine_skeleton skeleton); +SPINE_C_EXPORT void * spine_transform_constraint_data_get_bones(spine_transform_constraint_data obj); +SPINE_C_EXPORT int32_t spine_transform_constraint_data_get_num_bones(spine_transform_constraint_data obj); +SPINE_C_EXPORT spine_bone_data *spine_transform_constraint_data_get_bones(spine_transform_constraint_data obj); +SPINE_C_EXPORT spine_bone_data spine_transform_constraint_data_get_source(spine_transform_constraint_data obj); +SPINE_C_EXPORT void spine_transform_constraint_data_set_source(spine_transform_constraint_data obj, spine_bone_data value); +SPINE_C_EXPORT float spine_transform_constraint_data_get_offset_rotation(spine_transform_constraint_data obj); +SPINE_C_EXPORT void spine_transform_constraint_data_set_offset_rotation(spine_transform_constraint_data obj, float value); +SPINE_C_EXPORT float spine_transform_constraint_data_get_offset_x(spine_transform_constraint_data obj); +SPINE_C_EXPORT void spine_transform_constraint_data_set_offset_x(spine_transform_constraint_data obj, float value); +SPINE_C_EXPORT float spine_transform_constraint_data_get_offset_y(spine_transform_constraint_data obj); +SPINE_C_EXPORT void spine_transform_constraint_data_set_offset_y(spine_transform_constraint_data obj, float value); +SPINE_C_EXPORT float spine_transform_constraint_data_get_offset_scale_x(spine_transform_constraint_data obj); +SPINE_C_EXPORT void spine_transform_constraint_data_set_offset_scale_x(spine_transform_constraint_data obj, float value); +SPINE_C_EXPORT float spine_transform_constraint_data_get_offset_scale_y(spine_transform_constraint_data obj); +SPINE_C_EXPORT void spine_transform_constraint_data_set_offset_scale_y(spine_transform_constraint_data obj, float value); +SPINE_C_EXPORT float spine_transform_constraint_data_get_offset_shear_y(spine_transform_constraint_data obj); +SPINE_C_EXPORT void spine_transform_constraint_data_set_offset_shear_y(spine_transform_constraint_data obj, float value); +SPINE_C_EXPORT spine_bool spine_transform_constraint_data_get_local_source(spine_transform_constraint_data obj); +SPINE_C_EXPORT void spine_transform_constraint_data_set_local_source(spine_transform_constraint_data obj, spine_bool value); +SPINE_C_EXPORT spine_bool spine_transform_constraint_data_get_local_target(spine_transform_constraint_data obj); +SPINE_C_EXPORT void spine_transform_constraint_data_set_local_target(spine_transform_constraint_data obj, spine_bool value); +SPINE_C_EXPORT spine_bool spine_transform_constraint_data_get_additive(spine_transform_constraint_data obj); +SPINE_C_EXPORT void spine_transform_constraint_data_set_additive(spine_transform_constraint_data obj, spine_bool value); +SPINE_C_EXPORT spine_bool spine_transform_constraint_data_get_clamp(spine_transform_constraint_data obj); +SPINE_C_EXPORT void spine_transform_constraint_data_set_clamp(spine_transform_constraint_data obj, spine_bool value); +SPINE_C_EXPORT void * spine_transform_constraint_data_get_properties(spine_transform_constraint_data obj); +SPINE_C_EXPORT int32_t spine_transform_constraint_data_get_num_properties(spine_transform_constraint_data obj); +SPINE_C_EXPORT spine_class from_property *spine_transform_constraint_data_get_properties(spine_transform_constraint_data obj); +SPINE_C_EXPORT const utf8 * spine_transform_constraint_data_get_name(spine_transform_constraint_data obj); +SPINE_C_EXPORT spine_bool spine_transform_constraint_data_is_skin_required(spine_transform_constraint_data obj); +SPINE_C_EXPORT spine_transform_constraint_pose spine_transform_constraint_data_get_setup_pose(spine_transform_constraint_data obj); +SPINE_C_EXPORT spine_transform_constraint_pose spine_transform_constraint_data_get_setup_pose(spine_transform_constraint_data obj); + +#ifdef __cplusplus +} +#endif + +#endif // SPINE_C_TRANSFORMCONSTRAINTDATA_H \ No newline at end of file diff --git a/spine-c-new/src/generated/transform_constraint_pose.cpp b/spine-c-new/src/generated/transform_constraint_pose.cpp new file mode 100644 index 000000000..b35b565b7 --- /dev/null +++ b/spine-c-new/src/generated/transform_constraint_pose.cpp @@ -0,0 +1,121 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#include "transform_constraint_pose.h" +#include + +using namespace spine; + +spine_transform_constraint_pose spine_transform_constraint_pose_create(void) { + TransformConstraintPose *obj = new (__FILE__, __LINE__) TransformConstraintPose(); + return (spine_transform_constraint_pose) obj; +} + +void spine_transform_constraint_pose_dispose(spine_transform_constraint_pose obj) { + if (!obj) return; + delete (TransformConstraintPose *) obj; +} + +void spine_transform_constraint_pose_set(spine_transform_constraint_pose obj, spine_transform_constraint_pose value) { + if (!obj) return; + TransformConstraintPose *_obj = (TransformConstraintPose *) obj; + _obj->set(value); +} + +float spine_transform_constraint_pose_get_mix_rotate(spine_transform_constraint_pose obj) { + if (!obj) return 0; + TransformConstraintPose *_obj = (TransformConstraintPose *) obj; + return _obj->getMixRotate(); +} + +void spine_transform_constraint_pose_set_mix_rotate(spine_transform_constraint_pose obj, float value) { + if (!obj) return; + TransformConstraintPose *_obj = (TransformConstraintPose *) obj; + _obj->setMixRotate(value); +} + +float spine_transform_constraint_pose_get_mix_x(spine_transform_constraint_pose obj) { + if (!obj) return 0; + TransformConstraintPose *_obj = (TransformConstraintPose *) obj; + return _obj->getMixX(); +} + +void spine_transform_constraint_pose_set_mix_x(spine_transform_constraint_pose obj, float value) { + if (!obj) return; + TransformConstraintPose *_obj = (TransformConstraintPose *) obj; + _obj->setMixX(value); +} + +float spine_transform_constraint_pose_get_mix_y(spine_transform_constraint_pose obj) { + if (!obj) return 0; + TransformConstraintPose *_obj = (TransformConstraintPose *) obj; + return _obj->getMixY(); +} + +void spine_transform_constraint_pose_set_mix_y(spine_transform_constraint_pose obj, float value) { + if (!obj) return; + TransformConstraintPose *_obj = (TransformConstraintPose *) obj; + _obj->setMixY(value); +} + +float spine_transform_constraint_pose_get_mix_scale_x(spine_transform_constraint_pose obj) { + if (!obj) return 0; + TransformConstraintPose *_obj = (TransformConstraintPose *) obj; + return _obj->getMixScaleX(); +} + +void spine_transform_constraint_pose_set_mix_scale_x(spine_transform_constraint_pose obj, float value) { + if (!obj) return; + TransformConstraintPose *_obj = (TransformConstraintPose *) obj; + _obj->setMixScaleX(value); +} + +float spine_transform_constraint_pose_get_mix_scale_y(spine_transform_constraint_pose obj) { + if (!obj) return 0; + TransformConstraintPose *_obj = (TransformConstraintPose *) obj; + return _obj->getMixScaleY(); +} + +void spine_transform_constraint_pose_set_mix_scale_y(spine_transform_constraint_pose obj, float value) { + if (!obj) return; + TransformConstraintPose *_obj = (TransformConstraintPose *) obj; + _obj->setMixScaleY(value); +} + +float spine_transform_constraint_pose_get_mix_shear_y(spine_transform_constraint_pose obj) { + if (!obj) return 0; + TransformConstraintPose *_obj = (TransformConstraintPose *) obj; + return _obj->getMixShearY(); +} + +void spine_transform_constraint_pose_set_mix_shear_y(spine_transform_constraint_pose obj, float value) { + if (!obj) return; + TransformConstraintPose *_obj = (TransformConstraintPose *) obj; + _obj->setMixShearY(value); +} diff --git a/spine-c-new/src/generated/transform_constraint_pose.h b/spine-c-new/src/generated/transform_constraint_pose.h new file mode 100644 index 000000000..4aa85de5c --- /dev/null +++ b/spine-c-new/src/generated/transform_constraint_pose.h @@ -0,0 +1,61 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#ifndef SPINE_C_TRANSFORMCONSTRAINTPOSE_H +#define SPINE_C_TRANSFORMCONSTRAINTPOSE_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include "../custom.h" + +SPINE_OPAQUE_TYPE(spine_transform_constraint_pose) + +SPINE_C_EXPORT spine_transform_constraint_pose spine_transform_constraint_pose_create(void); +SPINE_C_EXPORT void spine_transform_constraint_pose_dispose(spine_transform_constraint_pose obj); +SPINE_C_EXPORT void spine_transform_constraint_pose_set(spine_transform_constraint_pose obj, spine_transform_constraint_pose value); +SPINE_C_EXPORT float spine_transform_constraint_pose_get_mix_rotate(spine_transform_constraint_pose obj); +SPINE_C_EXPORT void spine_transform_constraint_pose_set_mix_rotate(spine_transform_constraint_pose obj, float value); +SPINE_C_EXPORT float spine_transform_constraint_pose_get_mix_x(spine_transform_constraint_pose obj); +SPINE_C_EXPORT void spine_transform_constraint_pose_set_mix_x(spine_transform_constraint_pose obj, float value); +SPINE_C_EXPORT float spine_transform_constraint_pose_get_mix_y(spine_transform_constraint_pose obj); +SPINE_C_EXPORT void spine_transform_constraint_pose_set_mix_y(spine_transform_constraint_pose obj, float value); +SPINE_C_EXPORT float spine_transform_constraint_pose_get_mix_scale_x(spine_transform_constraint_pose obj); +SPINE_C_EXPORT void spine_transform_constraint_pose_set_mix_scale_x(spine_transform_constraint_pose obj, float value); +SPINE_C_EXPORT float spine_transform_constraint_pose_get_mix_scale_y(spine_transform_constraint_pose obj); +SPINE_C_EXPORT void spine_transform_constraint_pose_set_mix_scale_y(spine_transform_constraint_pose obj, float value); +SPINE_C_EXPORT float spine_transform_constraint_pose_get_mix_shear_y(spine_transform_constraint_pose obj); +SPINE_C_EXPORT void spine_transform_constraint_pose_set_mix_shear_y(spine_transform_constraint_pose obj, float value); + +#ifdef __cplusplus +} +#endif + +#endif // SPINE_C_TRANSFORMCONSTRAINTPOSE_H \ No newline at end of file diff --git a/spine-c-new/src/generated/transform_constraint_timeline.cpp b/spine-c-new/src/generated/transform_constraint_timeline.cpp new file mode 100644 index 000000000..25006a4f8 --- /dev/null +++ b/spine-c-new/src/generated/transform_constraint_timeline.cpp @@ -0,0 +1,169 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#include "transform_constraint_timeline.h" +#include + +using namespace spine; + +spine_transform_constraint_timeline spine_transform_constraint_timeline_create(spine_size_t frameCount, spine_size_t bezierCount, int32_t transformConstraintIndex) { + TransformConstraintTimeline *obj = new (__FILE__, __LINE__) TransformConstraintTimeline(frameCount, bezierCount, transformConstraintIndex); + return (spine_transform_constraint_timeline) obj; +} + +void spine_transform_constraint_timeline_dispose(spine_transform_constraint_timeline obj) { + if (!obj) return; + delete (TransformConstraintTimeline *) obj; +} + +spine_rtti spine_transform_constraint_timeline_get_rtti(spine_transform_constraint_timeline obj) { + if (!obj) return nullptr; + TransformConstraintTimeline *_obj = (TransformConstraintTimeline *) obj; + return (spine_rtti) &_obj->getRTTI(); +} + +void spine_transform_constraint_timeline_apply(spine_transform_constraint_timeline obj, spine_skeleton skeleton, float lastTime, float time, void * pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction, spine_bool appliedPose) { + if (!obj) return ; + TransformConstraintTimeline *_obj = (TransformConstraintTimeline *) obj; + _obj->apply(skeleton, lastTime, time, (Vector *) pEvents, alpha, blend, direction, appliedPose); +} + +void spine_transform_constraint_timeline_set_frame(spine_transform_constraint_timeline obj, int32_t frame, float time, float mixRotate, float mixX, float mixY, float mixScaleX, float mixScaleY, float mixShearY) { + if (!obj) return ; + TransformConstraintTimeline *_obj = (TransformConstraintTimeline *) obj; + _obj->setFrame(frame, time, mixRotate, mixX, mixY, mixScaleX, mixScaleY, mixShearY); +} + +void spine_transform_constraint_timeline_set_linear(spine_transform_constraint_timeline obj, spine_size_t value) { + if (!obj) return; + TransformConstraintTimeline *_obj = (TransformConstraintTimeline *) obj; + _obj->setLinear(value); +} + +void spine_transform_constraint_timeline_set_stepped(spine_transform_constraint_timeline obj, spine_size_t value) { + if (!obj) return; + TransformConstraintTimeline *_obj = (TransformConstraintTimeline *) obj; + _obj->setStepped(value); +} + +void spine_transform_constraint_timeline_set_bezier(spine_transform_constraint_timeline obj, spine_size_t bezier, spine_size_t frame, float value, float time1, float value1, float cx1, float cy1, float cx2, float cy2, float time2, float value2) { + if (!obj) return ; + TransformConstraintTimeline *_obj = (TransformConstraintTimeline *) obj; + _obj->setBezier(bezier, frame, value, time1, value1, cx1, cy1, cx2, cy2, time2, value2); +} + +float spine_transform_constraint_timeline_get_bezier_value(spine_transform_constraint_timeline obj, float time, spine_size_t frame, spine_size_t valueOffset, spine_size_t i) { + if (!obj) return 0; + TransformConstraintTimeline *_obj = (TransformConstraintTimeline *) obj; + return _obj->getBezierValue(time, frame, valueOffset, i); +} + +void * spine_transform_constraint_timeline_get_curves(spine_transform_constraint_timeline obj) { + if (!obj) return nullptr; + TransformConstraintTimeline *_obj = (TransformConstraintTimeline *) obj; + return _obj->getCurves(); +} + +int32_t spine_transform_constraint_timeline_get_num_curves(spine_transform_constraint_timeline obj) { + if (!obj) return 0; + TransformConstraintTimeline *_obj = (TransformConstraintTimeline *) obj; + return (int32_t) _obj->getCurves().size(); +} + +spine_float *spine_transform_constraint_timeline_get_curves(spine_transform_constraint_timeline obj) { + if (!obj) return nullptr; + TransformConstraintTimeline *_obj = (TransformConstraintTimeline *) obj; + return (spine_float *) _obj->getCurves().buffer(); +} + +spine_size_t spine_transform_constraint_timeline_get_frame_entries(spine_transform_constraint_timeline obj) { + if (!obj) return nullptr; + TransformConstraintTimeline *_obj = (TransformConstraintTimeline *) obj; + return _obj->getFrameEntries(); +} + +spine_size_t spine_transform_constraint_timeline_get_frame_count(spine_transform_constraint_timeline obj) { + if (!obj) return nullptr; + TransformConstraintTimeline *_obj = (TransformConstraintTimeline *) obj; + return _obj->getFrameCount(); +} + +void * spine_transform_constraint_timeline_get_frames(spine_transform_constraint_timeline obj) { + if (!obj) return nullptr; + TransformConstraintTimeline *_obj = (TransformConstraintTimeline *) obj; + return _obj->getFrames(); +} + +int32_t spine_transform_constraint_timeline_get_num_frames(spine_transform_constraint_timeline obj) { + if (!obj) return 0; + TransformConstraintTimeline *_obj = (TransformConstraintTimeline *) obj; + return (int32_t) _obj->getFrames().size(); +} + +spine_float *spine_transform_constraint_timeline_get_frames(spine_transform_constraint_timeline obj) { + if (!obj) return nullptr; + TransformConstraintTimeline *_obj = (TransformConstraintTimeline *) obj; + return (spine_float *) _obj->getFrames().buffer(); +} + +float spine_transform_constraint_timeline_get_duration(spine_transform_constraint_timeline obj) { + if (!obj) return 0; + TransformConstraintTimeline *_obj = (TransformConstraintTimeline *) obj; + return _obj->getDuration(); +} + +void * spine_transform_constraint_timeline_get_property_ids(spine_transform_constraint_timeline obj) { + if (!obj) return nullptr; + TransformConstraintTimeline *_obj = (TransformConstraintTimeline *) obj; + return _obj->getPropertyIds(); +} + +int32_t spine_transform_constraint_timeline_get_num_property_ids(spine_transform_constraint_timeline obj) { + if (!obj) return 0; + TransformConstraintTimeline *_obj = (TransformConstraintTimeline *) obj; + return (int32_t) _obj->getPropertyIds().size(); +} + +spine_property_id *spine_transform_constraint_timeline_get_property_ids(spine_transform_constraint_timeline obj) { + if (!obj) return nullptr; + TransformConstraintTimeline *_obj = (TransformConstraintTimeline *) obj; + return (spine_property_id *) _obj->getPropertyIds().buffer(); +} + +int32_t spine_transform_constraint_timeline_get_constraint_index(spine_transform_constraint_timeline obj) { + if (!obj) return 0; + TransformConstraintTimeline *_obj = (TransformConstraintTimeline *) obj; + return _obj->getConstraintIndex(); +} + +void spine_transform_constraint_timeline_set_constraint_index(spine_transform_constraint_timeline obj, int32_t value) { + if (!obj) return; + TransformConstraintTimeline *_obj = (TransformConstraintTimeline *) obj; + _obj->setConstraintIndex(value); +} diff --git a/spine-c-new/src/generated/transform_constraint_timeline.h b/spine-c-new/src/generated/transform_constraint_timeline.h new file mode 100644 index 000000000..8bc63c1bd --- /dev/null +++ b/spine-c-new/src/generated/transform_constraint_timeline.h @@ -0,0 +1,69 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#ifndef SPINE_C_TRANSFORMCONSTRAINTTIMELINE_H +#define SPINE_C_TRANSFORMCONSTRAINTTIMELINE_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include "../custom.h" + +SPINE_OPAQUE_TYPE(spine_transform_constraint_timeline) + +SPINE_C_EXPORT spine_transform_constraint_timeline spine_transform_constraint_timeline_create(spine_size_t frameCount, spine_size_t bezierCount, int32_t transformConstraintIndex); +SPINE_C_EXPORT void spine_transform_constraint_timeline_dispose(spine_transform_constraint_timeline obj); +SPINE_C_EXPORT spine_rtti spine_transform_constraint_timeline_get_rtti(spine_transform_constraint_timeline obj); +SPINE_C_EXPORT void spine_transform_constraint_timeline_apply(spine_transform_constraint_timeline obj, spine_skeleton skeleton, float lastTime, float time, void * pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction, spine_bool appliedPose); +SPINE_C_EXPORT void spine_transform_constraint_timeline_set_frame(spine_transform_constraint_timeline obj, int32_t frame, float time, float mixRotate, float mixX, float mixY, float mixScaleX, float mixScaleY, float mixShearY); +SPINE_C_EXPORT void spine_transform_constraint_timeline_set_linear(spine_transform_constraint_timeline obj, spine_size_t value); +SPINE_C_EXPORT void spine_transform_constraint_timeline_set_stepped(spine_transform_constraint_timeline obj, spine_size_t value); +SPINE_C_EXPORT void spine_transform_constraint_timeline_set_bezier(spine_transform_constraint_timeline obj, spine_size_t bezier, spine_size_t frame, float value, float time1, float value1, float cx1, float cy1, float cx2, float cy2, float time2, float value2); +SPINE_C_EXPORT float spine_transform_constraint_timeline_get_bezier_value(spine_transform_constraint_timeline obj, float time, spine_size_t frame, spine_size_t valueOffset, spine_size_t i); +SPINE_C_EXPORT void * spine_transform_constraint_timeline_get_curves(spine_transform_constraint_timeline obj); +SPINE_C_EXPORT int32_t spine_transform_constraint_timeline_get_num_curves(spine_transform_constraint_timeline obj); +SPINE_C_EXPORT spine_float *spine_transform_constraint_timeline_get_curves(spine_transform_constraint_timeline obj); +SPINE_C_EXPORT spine_size_t spine_transform_constraint_timeline_get_frame_entries(spine_transform_constraint_timeline obj); +SPINE_C_EXPORT spine_size_t spine_transform_constraint_timeline_get_frame_count(spine_transform_constraint_timeline obj); +SPINE_C_EXPORT void * spine_transform_constraint_timeline_get_frames(spine_transform_constraint_timeline obj); +SPINE_C_EXPORT int32_t spine_transform_constraint_timeline_get_num_frames(spine_transform_constraint_timeline obj); +SPINE_C_EXPORT spine_float *spine_transform_constraint_timeline_get_frames(spine_transform_constraint_timeline obj); +SPINE_C_EXPORT float spine_transform_constraint_timeline_get_duration(spine_transform_constraint_timeline obj); +SPINE_C_EXPORT void * spine_transform_constraint_timeline_get_property_ids(spine_transform_constraint_timeline obj); +SPINE_C_EXPORT int32_t spine_transform_constraint_timeline_get_num_property_ids(spine_transform_constraint_timeline obj); +SPINE_C_EXPORT spine_property_id *spine_transform_constraint_timeline_get_property_ids(spine_transform_constraint_timeline obj); +SPINE_C_EXPORT int32_t spine_transform_constraint_timeline_get_constraint_index(spine_transform_constraint_timeline obj); +SPINE_C_EXPORT void spine_transform_constraint_timeline_set_constraint_index(spine_transform_constraint_timeline obj, int32_t value); + +#ifdef __cplusplus +} +#endif + +#endif // SPINE_C_TRANSFORMCONSTRAINTTIMELINE_H \ No newline at end of file diff --git a/spine-c-new/src/generated/translate_timeline.cpp b/spine-c-new/src/generated/translate_timeline.cpp new file mode 100644 index 000000000..00286e485 --- /dev/null +++ b/spine-c-new/src/generated/translate_timeline.cpp @@ -0,0 +1,79 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#include "translate_timeline.h" +#include + +using namespace spine; + +spine_translate_timeline spine_translate_timeline_create(spine_size_t frameCount, spine_size_t bezierCount, int32_t boneIndex) { + TranslateTimeline *obj = new (__FILE__, __LINE__) TranslateTimeline(frameCount, bezierCount, boneIndex); + return (spine_translate_timeline) obj; +} + +void spine_translate_timeline_dispose(spine_translate_timeline obj) { + if (!obj) return; + delete (TranslateTimeline *) obj; +} + +spine_rtti spine_translate_timeline_get_rtti(spine_translate_timeline obj) { + if (!obj) return nullptr; + TranslateTimeline *_obj = (TranslateTimeline *) obj; + return (spine_rtti) &_obj->getRTTI(); +} + +void spine_translate_timeline_apply(spine_translate_timeline obj, spine_skeleton skeleton, float lastTime, float time, void * pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction, spine_bool appliedPose) { + if (!obj) return ; + TranslateTimeline *_obj = (TranslateTimeline *) obj; + _obj->apply(skeleton, lastTime, time, (Vector *) pEvents, alpha, blend, direction, appliedPose); +} + +void spine_translate_timeline_set_frame(spine_translate_timeline obj, spine_size_t frame, float time, float value1, float value2) { + if (!obj) return ; + TranslateTimeline *_obj = (TranslateTimeline *) obj; + _obj->setFrame(frame, time, value1, value2); +} + +float spine_translate_timeline_get_curve_value(spine_translate_timeline obj, float time) { + if (!obj) return 0; + TranslateTimeline *_obj = (TranslateTimeline *) obj; + return _obj->getCurveValue(time); +} + +int32_t spine_translate_timeline_get_bone_index(spine_translate_timeline obj) { + if (!obj) return 0; + TranslateTimeline *_obj = (TranslateTimeline *) obj; + return _obj->getBoneIndex(); +} + +void spine_translate_timeline_set_bone_index(spine_translate_timeline obj, int32_t value) { + if (!obj) return; + TranslateTimeline *_obj = (TranslateTimeline *) obj; + _obj->setBoneIndex(value); +} diff --git a/spine-c-new/src/generated/translate_timeline.h b/spine-c-new/src/generated/translate_timeline.h new file mode 100644 index 000000000..ed7f02fa1 --- /dev/null +++ b/spine-c-new/src/generated/translate_timeline.h @@ -0,0 +1,54 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#ifndef SPINE_C_TRANSLATETIMELINE_H +#define SPINE_C_TRANSLATETIMELINE_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include "../custom.h" + +SPINE_OPAQUE_TYPE(spine_translate_timeline) + +SPINE_C_EXPORT spine_translate_timeline spine_translate_timeline_create(spine_size_t frameCount, spine_size_t bezierCount, int32_t boneIndex); +SPINE_C_EXPORT void spine_translate_timeline_dispose(spine_translate_timeline obj); +SPINE_C_EXPORT spine_rtti spine_translate_timeline_get_rtti(spine_translate_timeline obj); +SPINE_C_EXPORT void spine_translate_timeline_apply(spine_translate_timeline obj, spine_skeleton skeleton, float lastTime, float time, void * pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction, spine_bool appliedPose); +SPINE_C_EXPORT void spine_translate_timeline_set_frame(spine_translate_timeline obj, spine_size_t frame, float time, float value1, float value2); +SPINE_C_EXPORT float spine_translate_timeline_get_curve_value(spine_translate_timeline obj, float time); +SPINE_C_EXPORT int32_t spine_translate_timeline_get_bone_index(spine_translate_timeline obj); +SPINE_C_EXPORT void spine_translate_timeline_set_bone_index(spine_translate_timeline obj, int32_t value); + +#ifdef __cplusplus +} +#endif + +#endif // SPINE_C_TRANSLATETIMELINE_H \ No newline at end of file diff --git a/spine-c-new/src/generated/translate_x_timeline.cpp b/spine-c-new/src/generated/translate_x_timeline.cpp new file mode 100644 index 000000000..d63f5f760 --- /dev/null +++ b/spine-c-new/src/generated/translate_x_timeline.cpp @@ -0,0 +1,103 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#include "translate_x_timeline.h" +#include + +using namespace spine; + +spine_translate_x_timeline spine_translate_x_timeline_create(spine_size_t frameCount, spine_size_t bezierCount, int32_t boneIndex) { + TranslateXTimeline *obj = new (__FILE__, __LINE__) TranslateXTimeline(frameCount, bezierCount, boneIndex); + return (spine_translate_x_timeline) obj; +} + +void spine_translate_x_timeline_dispose(spine_translate_x_timeline obj) { + if (!obj) return; + delete (TranslateXTimeline *) obj; +} + +spine_rtti spine_translate_x_timeline_get_rtti(spine_translate_x_timeline obj) { + if (!obj) return nullptr; + TranslateXTimeline *_obj = (TranslateXTimeline *) obj; + return (spine_rtti) &_obj->getRTTI(); +} + +void spine_translate_x_timeline_apply(spine_translate_x_timeline obj, spine_skeleton skeleton, float lastTime, float time, void * pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction, spine_bool appliedPose) { + if (!obj) return ; + TranslateXTimeline *_obj = (TranslateXTimeline *) obj; + _obj->apply(skeleton, lastTime, time, (Vector *) pEvents, alpha, blend, direction, appliedPose); +} + +void spine_translate_x_timeline_set_frame(spine_translate_x_timeline obj, spine_size_t frame, float time, float value) { + if (!obj) return ; + TranslateXTimeline *_obj = (TranslateXTimeline *) obj; + _obj->setFrame(frame, time, value); +} + +float spine_translate_x_timeline_get_curve_value(spine_translate_x_timeline obj, float time) { + if (!obj) return 0; + TranslateXTimeline *_obj = (TranslateXTimeline *) obj; + return _obj->getCurveValue(time); +} + +float spine_translate_x_timeline_get_relative_value(spine_translate_x_timeline obj, float time, float alpha, spine_mix_blend blend, float current, float setup) { + if (!obj) return 0; + TranslateXTimeline *_obj = (TranslateXTimeline *) obj; + return _obj->getRelativeValue(time, alpha, blend, current, setup); +} + +float spine_translate_x_timeline_get_absolute_value(spine_translate_x_timeline obj, float time, float alpha, spine_mix_blend blend, float current, float setup) { + if (!obj) return 0; + TranslateXTimeline *_obj = (TranslateXTimeline *) obj; + return _obj->getAbsoluteValue(time, alpha, blend, current, setup); +} + +float spine_translate_x_timeline_get_absolute_value(spine_translate_x_timeline obj, float time, float alpha, spine_mix_blend blend, float current, float setup, float value) { + if (!obj) return 0; + TranslateXTimeline *_obj = (TranslateXTimeline *) obj; + return _obj->getAbsoluteValue(time, alpha, blend, current, setup, value); +} + +float spine_translate_x_timeline_get_scale_value(spine_translate_x_timeline obj, float time, float alpha, spine_mix_blend blend, spine_mix_direction direction, float current, float setup) { + if (!obj) return 0; + TranslateXTimeline *_obj = (TranslateXTimeline *) obj; + return _obj->getScaleValue(time, alpha, blend, direction, current, setup); +} + +int32_t spine_translate_x_timeline_get_bone_index(spine_translate_x_timeline obj) { + if (!obj) return 0; + TranslateXTimeline *_obj = (TranslateXTimeline *) obj; + return _obj->getBoneIndex(); +} + +void spine_translate_x_timeline_set_bone_index(spine_translate_x_timeline obj, int32_t value) { + if (!obj) return; + TranslateXTimeline *_obj = (TranslateXTimeline *) obj; + _obj->setBoneIndex(value); +} diff --git a/spine-c-new/src/generated/translate_x_timeline.h b/spine-c-new/src/generated/translate_x_timeline.h new file mode 100644 index 000000000..17141d897 --- /dev/null +++ b/spine-c-new/src/generated/translate_x_timeline.h @@ -0,0 +1,58 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#ifndef SPINE_C_TRANSLATEXTIMELINE_H +#define SPINE_C_TRANSLATEXTIMELINE_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include "../custom.h" + +SPINE_OPAQUE_TYPE(spine_translate_x_timeline) + +SPINE_C_EXPORT spine_translate_x_timeline spine_translate_x_timeline_create(spine_size_t frameCount, spine_size_t bezierCount, int32_t boneIndex); +SPINE_C_EXPORT void spine_translate_x_timeline_dispose(spine_translate_x_timeline obj); +SPINE_C_EXPORT spine_rtti spine_translate_x_timeline_get_rtti(spine_translate_x_timeline obj); +SPINE_C_EXPORT void spine_translate_x_timeline_apply(spine_translate_x_timeline obj, spine_skeleton skeleton, float lastTime, float time, void * pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction, spine_bool appliedPose); +SPINE_C_EXPORT void spine_translate_x_timeline_set_frame(spine_translate_x_timeline obj, spine_size_t frame, float time, float value); +SPINE_C_EXPORT float spine_translate_x_timeline_get_curve_value(spine_translate_x_timeline obj, float time); +SPINE_C_EXPORT float spine_translate_x_timeline_get_relative_value(spine_translate_x_timeline obj, float time, float alpha, spine_mix_blend blend, float current, float setup); +SPINE_C_EXPORT float spine_translate_x_timeline_get_absolute_value(spine_translate_x_timeline obj, float time, float alpha, spine_mix_blend blend, float current, float setup); +SPINE_C_EXPORT float spine_translate_x_timeline_get_absolute_value(spine_translate_x_timeline obj, float time, float alpha, spine_mix_blend blend, float current, float setup, float value); +SPINE_C_EXPORT float spine_translate_x_timeline_get_scale_value(spine_translate_x_timeline obj, float time, float alpha, spine_mix_blend blend, spine_mix_direction direction, float current, float setup); +SPINE_C_EXPORT int32_t spine_translate_x_timeline_get_bone_index(spine_translate_x_timeline obj); +SPINE_C_EXPORT void spine_translate_x_timeline_set_bone_index(spine_translate_x_timeline obj, int32_t value); + +#ifdef __cplusplus +} +#endif + +#endif // SPINE_C_TRANSLATEXTIMELINE_H \ No newline at end of file diff --git a/spine-c-new/src/generated/translate_y_timeline.cpp b/spine-c-new/src/generated/translate_y_timeline.cpp new file mode 100644 index 000000000..40a94348e --- /dev/null +++ b/spine-c-new/src/generated/translate_y_timeline.cpp @@ -0,0 +1,103 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#include "translate_y_timeline.h" +#include + +using namespace spine; + +spine_translate_y_timeline spine_translate_y_timeline_create(spine_size_t frameCount, spine_size_t bezierCount, int32_t boneIndex) { + TranslateYTimeline *obj = new (__FILE__, __LINE__) TranslateYTimeline(frameCount, bezierCount, boneIndex); + return (spine_translate_y_timeline) obj; +} + +void spine_translate_y_timeline_dispose(spine_translate_y_timeline obj) { + if (!obj) return; + delete (TranslateYTimeline *) obj; +} + +spine_rtti spine_translate_y_timeline_get_rtti(spine_translate_y_timeline obj) { + if (!obj) return nullptr; + TranslateYTimeline *_obj = (TranslateYTimeline *) obj; + return (spine_rtti) &_obj->getRTTI(); +} + +void spine_translate_y_timeline_apply(spine_translate_y_timeline obj, spine_skeleton skeleton, float lastTime, float time, void * pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction, spine_bool appliedPose) { + if (!obj) return ; + TranslateYTimeline *_obj = (TranslateYTimeline *) obj; + _obj->apply(skeleton, lastTime, time, (Vector *) pEvents, alpha, blend, direction, appliedPose); +} + +void spine_translate_y_timeline_set_frame(spine_translate_y_timeline obj, spine_size_t frame, float time, float value) { + if (!obj) return ; + TranslateYTimeline *_obj = (TranslateYTimeline *) obj; + _obj->setFrame(frame, time, value); +} + +float spine_translate_y_timeline_get_curve_value(spine_translate_y_timeline obj, float time) { + if (!obj) return 0; + TranslateYTimeline *_obj = (TranslateYTimeline *) obj; + return _obj->getCurveValue(time); +} + +float spine_translate_y_timeline_get_relative_value(spine_translate_y_timeline obj, float time, float alpha, spine_mix_blend blend, float current, float setup) { + if (!obj) return 0; + TranslateYTimeline *_obj = (TranslateYTimeline *) obj; + return _obj->getRelativeValue(time, alpha, blend, current, setup); +} + +float spine_translate_y_timeline_get_absolute_value(spine_translate_y_timeline obj, float time, float alpha, spine_mix_blend blend, float current, float setup) { + if (!obj) return 0; + TranslateYTimeline *_obj = (TranslateYTimeline *) obj; + return _obj->getAbsoluteValue(time, alpha, blend, current, setup); +} + +float spine_translate_y_timeline_get_absolute_value(spine_translate_y_timeline obj, float time, float alpha, spine_mix_blend blend, float current, float setup, float value) { + if (!obj) return 0; + TranslateYTimeline *_obj = (TranslateYTimeline *) obj; + return _obj->getAbsoluteValue(time, alpha, blend, current, setup, value); +} + +float spine_translate_y_timeline_get_scale_value(spine_translate_y_timeline obj, float time, float alpha, spine_mix_blend blend, spine_mix_direction direction, float current, float setup) { + if (!obj) return 0; + TranslateYTimeline *_obj = (TranslateYTimeline *) obj; + return _obj->getScaleValue(time, alpha, blend, direction, current, setup); +} + +int32_t spine_translate_y_timeline_get_bone_index(spine_translate_y_timeline obj) { + if (!obj) return 0; + TranslateYTimeline *_obj = (TranslateYTimeline *) obj; + return _obj->getBoneIndex(); +} + +void spine_translate_y_timeline_set_bone_index(spine_translate_y_timeline obj, int32_t value) { + if (!obj) return; + TranslateYTimeline *_obj = (TranslateYTimeline *) obj; + _obj->setBoneIndex(value); +} diff --git a/spine-c-new/src/generated/translate_y_timeline.h b/spine-c-new/src/generated/translate_y_timeline.h new file mode 100644 index 000000000..526aca28e --- /dev/null +++ b/spine-c-new/src/generated/translate_y_timeline.h @@ -0,0 +1,58 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#ifndef SPINE_C_TRANSLATEYTIMELINE_H +#define SPINE_C_TRANSLATEYTIMELINE_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include "../custom.h" + +SPINE_OPAQUE_TYPE(spine_translate_y_timeline) + +SPINE_C_EXPORT spine_translate_y_timeline spine_translate_y_timeline_create(spine_size_t frameCount, spine_size_t bezierCount, int32_t boneIndex); +SPINE_C_EXPORT void spine_translate_y_timeline_dispose(spine_translate_y_timeline obj); +SPINE_C_EXPORT spine_rtti spine_translate_y_timeline_get_rtti(spine_translate_y_timeline obj); +SPINE_C_EXPORT void spine_translate_y_timeline_apply(spine_translate_y_timeline obj, spine_skeleton skeleton, float lastTime, float time, void * pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction, spine_bool appliedPose); +SPINE_C_EXPORT void spine_translate_y_timeline_set_frame(spine_translate_y_timeline obj, spine_size_t frame, float time, float value); +SPINE_C_EXPORT float spine_translate_y_timeline_get_curve_value(spine_translate_y_timeline obj, float time); +SPINE_C_EXPORT float spine_translate_y_timeline_get_relative_value(spine_translate_y_timeline obj, float time, float alpha, spine_mix_blend blend, float current, float setup); +SPINE_C_EXPORT float spine_translate_y_timeline_get_absolute_value(spine_translate_y_timeline obj, float time, float alpha, spine_mix_blend blend, float current, float setup); +SPINE_C_EXPORT float spine_translate_y_timeline_get_absolute_value(spine_translate_y_timeline obj, float time, float alpha, spine_mix_blend blend, float current, float setup, float value); +SPINE_C_EXPORT float spine_translate_y_timeline_get_scale_value(spine_translate_y_timeline obj, float time, float alpha, spine_mix_blend blend, spine_mix_direction direction, float current, float setup); +SPINE_C_EXPORT int32_t spine_translate_y_timeline_get_bone_index(spine_translate_y_timeline obj); +SPINE_C_EXPORT void spine_translate_y_timeline_set_bone_index(spine_translate_y_timeline obj, int32_t value); + +#ifdef __cplusplus +} +#endif + +#endif // SPINE_C_TRANSLATEYTIMELINE_H \ No newline at end of file diff --git a/spine-c-new/src/generated/update.cpp b/spine-c-new/src/generated/update.cpp new file mode 100644 index 000000000..a2384ed1f --- /dev/null +++ b/spine-c-new/src/generated/update.cpp @@ -0,0 +1,55 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#include "update.h" +#include + +using namespace spine; + +spine_update spine_update_create(void) { + Update *obj = new (__FILE__, __LINE__) Update(); + return (spine_update) obj; +} + +void spine_update_dispose(spine_update obj) { + if (!obj) return; + delete (Update *) obj; +} + +spine_rtti spine_update_get_rtti(spine_update obj) { + if (!obj) return nullptr; + Update *_obj = (Update *) obj; + return (spine_rtti) &_obj->getRTTI(); +} + +void spine_update_update(spine_update obj, spine_skeleton skeleton, spine_physics physics) { + if (!obj) return ; + Update *_obj = (Update *) obj; + _obj->update(skeleton, physics); +} diff --git a/spine-c-new/src/generated/update.h b/spine-c-new/src/generated/update.h new file mode 100644 index 000000000..f8fc04570 --- /dev/null +++ b/spine-c-new/src/generated/update.h @@ -0,0 +1,50 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#ifndef SPINE_C_UPDATE_H +#define SPINE_C_UPDATE_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include "../custom.h" + +SPINE_OPAQUE_TYPE(spine_update) + +SPINE_C_EXPORT spine_update spine_update_create(void); +SPINE_C_EXPORT void spine_update_dispose(spine_update obj); +SPINE_C_EXPORT spine_rtti spine_update_get_rtti(spine_update obj); +SPINE_C_EXPORT void spine_update_update(spine_update obj, spine_skeleton skeleton, spine_physics physics); + +#ifdef __cplusplus +} +#endif + +#endif // SPINE_C_UPDATE_H \ No newline at end of file diff --git a/spine-c-new/src/generated/vertex_attachment.cpp b/spine-c-new/src/generated/vertex_attachment.cpp new file mode 100644 index 000000000..26f56e9b3 --- /dev/null +++ b/spine-c-new/src/generated/vertex_attachment.cpp @@ -0,0 +1,175 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#include "vertex_attachment.h" +#include + +using namespace spine; + +spine_vertex_attachment spine_vertex_attachment_create(const utf8 * name) { + VertexAttachment *obj = new (__FILE__, __LINE__) VertexAttachment(String(name)); + return (spine_vertex_attachment) obj; +} + +void spine_vertex_attachment_dispose(spine_vertex_attachment obj) { + if (!obj) return; + delete (VertexAttachment *) obj; +} + +spine_rtti spine_vertex_attachment_get_rtti(spine_vertex_attachment obj) { + if (!obj) return nullptr; + VertexAttachment *_obj = (VertexAttachment *) obj; + return (spine_rtti) &_obj->getRTTI(); +} + +void spine_vertex_attachment_compute_world_vertices(spine_vertex_attachment obj, spine_skeleton skeleton, spine_slot slot, spine_size_t start, spine_size_t count, spine_float worldVertices, spine_size_t offset, spine_size_t stride) { + if (!obj) return ; + VertexAttachment *_obj = (VertexAttachment *) obj; + _obj->computeWorldVertices(skeleton, slot, start, count, (float *) worldVertices, offset, stride); +} + +void spine_vertex_attachment_compute_world_vertices(spine_vertex_attachment obj, spine_skeleton skeleton, spine_slot slot, spine_size_t start, spine_size_t count, void * worldVertices, spine_size_t offset, spine_size_t stride) { + if (!obj) return ; + VertexAttachment *_obj = (VertexAttachment *) obj; + _obj->computeWorldVertices(skeleton, slot, start, count, (Vector &) worldVertices, offset, stride); +} + +int32_t spine_vertex_attachment_get_id(spine_vertex_attachment obj) { + if (!obj) return 0; + VertexAttachment *_obj = (VertexAttachment *) obj; + return _obj->getId(); +} + +int32_t * spine_vertex_attachment_get_bones(spine_vertex_attachment obj) { + if (!obj) return 0; + VertexAttachment *_obj = (VertexAttachment *) obj; + return _obj->getBones(); +} + +int32_t spine_vertex_attachment_get_num_bones(spine_vertex_attachment obj) { + if (!obj) return 0; + VertexAttachment *_obj = (VertexAttachment *) obj; + return (int32_t) _obj->getBones().size(); +} + +int32_t *spine_vertex_attachment_get_bones(spine_vertex_attachment obj) { + if (!obj) return nullptr; + VertexAttachment *_obj = (VertexAttachment *) obj; + return (int32_t *) _obj->getBones().buffer(); +} + +void spine_vertex_attachment_set_bones(spine_vertex_attachment obj, int32_t * value) { + if (!obj) return; + VertexAttachment *_obj = (VertexAttachment *) obj; + _obj->setBones((Vector &) value); +} + +void * spine_vertex_attachment_get_vertices(spine_vertex_attachment obj) { + if (!obj) return nullptr; + VertexAttachment *_obj = (VertexAttachment *) obj; + return _obj->getVertices(); +} + +int32_t spine_vertex_attachment_get_num_vertices(spine_vertex_attachment obj) { + if (!obj) return 0; + VertexAttachment *_obj = (VertexAttachment *) obj; + return (int32_t) _obj->getVertices().size(); +} + +spine_float *spine_vertex_attachment_get_vertices(spine_vertex_attachment obj) { + if (!obj) return nullptr; + VertexAttachment *_obj = (VertexAttachment *) obj; + return (spine_float *) _obj->getVertices().buffer(); +} + +void spine_vertex_attachment_set_vertices(spine_vertex_attachment obj, void * value) { + if (!obj) return; + VertexAttachment *_obj = (VertexAttachment *) obj; + _obj->setVertices((Vector &) value); +} + +spine_size_t spine_vertex_attachment_get_world_vertices_length(spine_vertex_attachment obj) { + if (!obj) return nullptr; + VertexAttachment *_obj = (VertexAttachment *) obj; + return _obj->getWorldVerticesLength(); +} + +void spine_vertex_attachment_set_world_vertices_length(spine_vertex_attachment obj, spine_size_t value) { + if (!obj) return; + VertexAttachment *_obj = (VertexAttachment *) obj; + _obj->setWorldVerticesLength(value); +} + +spine_attachment spine_vertex_attachment_get_timeline_attachment(spine_vertex_attachment obj) { + if (!obj) return nullptr; + VertexAttachment *_obj = (VertexAttachment *) obj; + return (spine_attachment) _obj->getTimelineAttachment(); +} + +void spine_vertex_attachment_set_timeline_attachment(spine_vertex_attachment obj, spine_attachment value) { + if (!obj) return; + VertexAttachment *_obj = (VertexAttachment *) obj; + _obj->setTimelineAttachment((Attachment *) value); +} + +void spine_vertex_attachment_copy_to(spine_vertex_attachment obj, spine_vertex_attachment other) { + if (!obj) return ; + VertexAttachment *_obj = (VertexAttachment *) obj; + _obj->copyTo((VertexAttachment *) other); +} + +const utf8 * spine_vertex_attachment_get_name(spine_vertex_attachment obj) { + if (!obj) return nullptr; + VertexAttachment *_obj = (VertexAttachment *) obj; + return (const utf8 *) _obj->getName().buffer(); +} + +spine_attachment spine_vertex_attachment_copy(spine_vertex_attachment obj) { + if (!obj) return nullptr; + VertexAttachment *_obj = (VertexAttachment *) obj; + return (spine_attachment) _obj->copy(); +} + +int32_t spine_vertex_attachment_get_ref_count(spine_vertex_attachment obj) { + if (!obj) return 0; + VertexAttachment *_obj = (VertexAttachment *) obj; + return _obj->getRefCount(); +} + +void spine_vertex_attachment_reference(spine_vertex_attachment obj) { + if (!obj) return ; + VertexAttachment *_obj = (VertexAttachment *) obj; + _obj->reference(); +} + +void spine_vertex_attachment_dereference(spine_vertex_attachment obj) { + if (!obj) return ; + VertexAttachment *_obj = (VertexAttachment *) obj; + _obj->dereference(); +} diff --git a/spine-c-new/src/generated/vertex_attachment.h b/spine-c-new/src/generated/vertex_attachment.h new file mode 100644 index 000000000..cc6c43872 --- /dev/null +++ b/spine-c-new/src/generated/vertex_attachment.h @@ -0,0 +1,70 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#ifndef SPINE_C_VERTEXATTACHMENT_H +#define SPINE_C_VERTEXATTACHMENT_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include "../custom.h" + +SPINE_OPAQUE_TYPE(spine_vertex_attachment) + +SPINE_C_EXPORT spine_vertex_attachment spine_vertex_attachment_create(const utf8 * name); +SPINE_C_EXPORT void spine_vertex_attachment_dispose(spine_vertex_attachment obj); +SPINE_C_EXPORT spine_rtti spine_vertex_attachment_get_rtti(spine_vertex_attachment obj); +SPINE_C_EXPORT void spine_vertex_attachment_compute_world_vertices(spine_vertex_attachment obj, spine_skeleton skeleton, spine_slot slot, spine_size_t start, spine_size_t count, spine_float worldVertices, spine_size_t offset, spine_size_t stride); +SPINE_C_EXPORT void spine_vertex_attachment_compute_world_vertices(spine_vertex_attachment obj, spine_skeleton skeleton, spine_slot slot, spine_size_t start, spine_size_t count, void * worldVertices, spine_size_t offset, spine_size_t stride); +SPINE_C_EXPORT int32_t spine_vertex_attachment_get_id(spine_vertex_attachment obj); +SPINE_C_EXPORT int32_t * spine_vertex_attachment_get_bones(spine_vertex_attachment obj); +SPINE_C_EXPORT int32_t spine_vertex_attachment_get_num_bones(spine_vertex_attachment obj); +SPINE_C_EXPORT int32_t *spine_vertex_attachment_get_bones(spine_vertex_attachment obj); +SPINE_C_EXPORT void spine_vertex_attachment_set_bones(spine_vertex_attachment obj, int32_t * value); +SPINE_C_EXPORT void * spine_vertex_attachment_get_vertices(spine_vertex_attachment obj); +SPINE_C_EXPORT int32_t spine_vertex_attachment_get_num_vertices(spine_vertex_attachment obj); +SPINE_C_EXPORT spine_float *spine_vertex_attachment_get_vertices(spine_vertex_attachment obj); +SPINE_C_EXPORT void spine_vertex_attachment_set_vertices(spine_vertex_attachment obj, void * value); +SPINE_C_EXPORT spine_size_t spine_vertex_attachment_get_world_vertices_length(spine_vertex_attachment obj); +SPINE_C_EXPORT void spine_vertex_attachment_set_world_vertices_length(spine_vertex_attachment obj, spine_size_t value); +SPINE_C_EXPORT spine_attachment spine_vertex_attachment_get_timeline_attachment(spine_vertex_attachment obj); +SPINE_C_EXPORT void spine_vertex_attachment_set_timeline_attachment(spine_vertex_attachment obj, spine_attachment value); +SPINE_C_EXPORT void spine_vertex_attachment_copy_to(spine_vertex_attachment obj, spine_vertex_attachment other); +SPINE_C_EXPORT const utf8 * spine_vertex_attachment_get_name(spine_vertex_attachment obj); +SPINE_C_EXPORT spine_attachment spine_vertex_attachment_copy(spine_vertex_attachment obj); +SPINE_C_EXPORT int32_t spine_vertex_attachment_get_ref_count(spine_vertex_attachment obj); +SPINE_C_EXPORT void spine_vertex_attachment_reference(spine_vertex_attachment obj); +SPINE_C_EXPORT void spine_vertex_attachment_dereference(spine_vertex_attachment obj); + +#ifdef __cplusplus +} +#endif + +#endif // SPINE_C_VERTEXATTACHMENT_H \ No newline at end of file diff --git a/spine-c-new/src/generated/vertices.cpp b/spine-c-new/src/generated/vertices.cpp new file mode 100644 index 000000000..5fdba85ef --- /dev/null +++ b/spine-c-new/src/generated/vertices.cpp @@ -0,0 +1,38 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#include "vertices.h" +#include + +using namespace spine; + +void spine_vertices_dispose(spine_vertices obj) { + if (!obj) return; + delete (Vertices *) obj; +} diff --git a/spine-c-new/src/generated/vertices.h b/spine-c-new/src/generated/vertices.h new file mode 100644 index 000000000..61688a3f7 --- /dev/null +++ b/spine-c-new/src/generated/vertices.h @@ -0,0 +1,47 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated April 5, 2025. Replaces all prior versions. + * + * Copyright (c) 2013-2025, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software + * or otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#ifndef SPINE_C_VERTICES_H +#define SPINE_C_VERTICES_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include "../custom.h" + +SPINE_OPAQUE_TYPE(spine_vertices) + +SPINE_C_EXPORT void spine_vertices_dispose(spine_vertices obj); + +#ifdef __cplusplus +} +#endif + +#endif // SPINE_C_VERTICES_H \ No newline at end of file diff --git a/spine-c-new/test/test.c b/spine-c-new/test/test.c new file mode 100644 index 000000000..27570825d --- /dev/null +++ b/spine-c-new/test/test.c @@ -0,0 +1,24 @@ +#include +#include + +int main() { + printf("Testing spine-c-new...\n"); + + // Test version functions + printf("Spine version: %d.%d\n", spine_major_version(), spine_minor_version()); + + // Test debug extension + spine_enable_debug_extension(1); + + // Test creating bounds + spine_bounds bounds = (spine_bounds)malloc(sizeof(struct spine_bounds_wrapper)); + if (bounds) { + printf("Successfully created bounds\n"); + free(bounds); + } + + // Report any memory leaks + spine_report_leaks(); + + return 0; +} \ No newline at end of file diff --git a/spine-cpp/CMakeLists.txt b/spine-cpp/CMakeLists.txt index 9829b42cd..f3a3aeaff 100644 --- a/spine-cpp/CMakeLists.txt +++ b/spine-cpp/CMakeLists.txt @@ -10,8 +10,9 @@ file(GLOB SOURCES "spine-cpp/src/**/*.cpp") add_library(spine-cpp STATIC ${SOURCES} ${INCLUDES}) target_include_directories(spine-cpp PUBLIC spine-cpp/include) -add_library(spine-cpp-lite STATIC ${SOURCES} ${INCLUDES} spine-cpp-lite/spine-cpp-lite.cpp) -target_include_directories(spine-cpp-lite PUBLIC spine-cpp/include spine-cpp-lite) +# Commented out spine-cpp-lite build as it's not compatible with 4.3-beta API +# add_library(spine-cpp-lite STATIC ${SOURCES} ${INCLUDES} spine-cpp-lite/spine-cpp-lite.cpp) +# target_include_directories(spine-cpp-lite PUBLIC spine-cpp/include spine-cpp-lite) # Install target install(TARGETS spine-cpp EXPORT spine-cpp_TARGETS DESTINATION dist/lib) diff --git a/spine-cpp/extract-spine-cpp-types.js b/spine-cpp/extract-spine-cpp-types.js index e0aeb326a..0c0804ec7 100755 --- a/spine-cpp/extract-spine-cpp-types.js +++ b/spine-cpp/extract-spine-cpp-types.js @@ -82,9 +82,11 @@ ENUM VALUES: INHERITANCE (all-files mode only): - Methods inherited from non-template supertypes are included - Methods inherited from template supertypes have parameters substituted + - Full inheritance hierarchy is preserved (grandparent methods appear via parent) - SpineObject methods are excluded (considered noise) - - Methods are marked with "fromSupertype" field + - Methods are marked with "fromSupertype" field indicating immediate source - Template supertypes appear as "TemplateName" + - Example: If C inherits B inherits A, C gets all methods from A and B NOTES: - Only public members are extracted diff --git a/spine-cpp/spine-cpp/src/spine/Atlas.cpp b/spine-cpp/spine-cpp/src/spine/Atlas.cpp index 9258fa0c9..b317f91dd 100644 --- a/spine-cpp/spine-cpp/src/spine/Atlas.cpp +++ b/spine-cpp/spine-cpp/src/spine/Atlas.cpp @@ -268,8 +268,13 @@ void Atlas::load(const char *begin, int length, const char *dir, bool createText } else if (entry[0].equals("format")) { page->format = (Format) indexOf(formatNames, 8, &entry[1]); } else if (entry[0].equals("filter")) { - page->minFilter = (TEXTURE_FILTER_ENUM) indexOf(textureFilterNames, 8, &entry[1]); - page->magFilter = (TEXTURE_FILTER_ENUM) indexOf(textureFilterNames, 8, &entry[2]); +#ifdef SPINE_UE4 + page->minFilter = (SpineTextureFilter) indexOf(textureFilterNames, 8, &entry[1]); + page->magFilter = (SpineTextureFilter) indexOf(textureFilterNames, 8, &entry[2]); +#else + page->minFilter = (TextureFilter) indexOf(textureFilterNames, 8, &entry[1]); + page->magFilter = (TextureFilter) indexOf(textureFilterNames, 8, &entry[2]); +#endif } else if (entry[0].equals("repeat")) { page->uWrap = TextureWrap_ClampToEdge; page->vWrap = TextureWrap_ClampToEdge;