void SkeletonAnimationFbo::loadSkeletonAndAtlasData()
{
releaseSkeletonRelatedData();
if (mAtlasFile.isEmpty() || !mAtlasFile.isValid()){
qDebug()<<"SkeletonAnimation::loadSkeletonAndAtlasData Error: Invalid AtlasFile:"<<mAtlasFile;
return;
}
if (mSkeletonDataFile.isEmpty() || !mSkeletonDataFile.isValid()){
qDebug()<<"SkeletonAnimation::loadSkeletonAndAtlasData Error: Invalid SkeletonDataFile:"<<mSkeletonDataFile;
return;
}
std::string atlasFile = QQmlFile::urlToLocalFileOrQrc(mAtlasFile).toStdString();
mspAtlas = spAtlas_createFromFile(atlasFile.c_str(), 0);
if (!mspAtlas){
qDebug()<<"SkeletonAnimation::loadSkeletonAndAtlasData Error: Atals is null. AtlasFile:"<<mAtlasFile;
return;
}
spSkeletonJson* json = spSkeletonJson_create(mspAtlas);
json->scale = mScale;
std::string skeletonFile = QQmlFile::urlToLocalFileOrQrc(mSkeletonDataFile).toStdString();
spSkeletonData* skeletonData = spSkeletonJson_readSkeletonDataFile(json, skeletonFile.c_str());
if (!skeletonData){
qDebug()<<"SkeletonAnimation::loadSkeletonAndAtlasData Error: Failed to load json. jason error:"<<(json->error ? json->error : "null.");
releaseSkeletonRelatedData();
return;
}
spSkeletonJson_dispose(json);
mspSkeleton = spSkeleton_create(skeletonData);
mspRootBone = mspSkeleton->bones[0];
const bool res = spSkeleton_setSkinByName(mspSkeleton, mSkin.toStdString().c_str());
if (!res && !mSkin.isEmpty())
qDebug()<<"SkeletonAnimation::loadSkeletonAndAtlasData Error: Invalid skin:"<<mSkin;
mspAnimationState = spAnimationState_create(spAnimationStateData_create(mspSkeleton->data));
mspAnimationState->rendererObject = this;
mspAnimationState->listener = animationCallback;
mSkeletonLoaded = true;
mTimer.invalidate();
}
void SkeletonRenderer::initWithFile (const std::string& skeletonDataFile, const std::string& atlasFile, float scale) {
_atlas = spAtlas_createFromFile(atlasFile.c_str(), 0);
CCASSERT(_atlas, "Error reading atlas file.");
_attachmentLoader = SUPER(Cocos2dAttachmentLoader_create(_atlas));
spSkeletonJson* json = spSkeletonJson_createWithLoader(_attachmentLoader);
json->scale = scale;
spSkeletonData* skeletonData = spSkeletonJson_readSkeletonDataFile(json, skeletonDataFile.c_str());
CCASSERT(skeletonData, json->error ? json->error : "Error reading skeleton data file.");
spSkeletonJson_dispose(json);
setSkeletonData(skeletonData, true);
initialize();
}
static void LoadSpineboyExample(spAtlas* &atlas, spSkeletonData* &skeletonData, spAnimationStateData* &stateData, spSkeleton* &skeleton, spAnimationState* &state)
{
///////////////////////////////////////////////////////////////////////////
// Global Animation Information
atlas = spAtlas_createFromFile(SPINEBOY_ATLAS, 0);
ASSERT(atlas != nullptr);
skeletonData = readSkeletonJsonData(SPINEBOY_JSON, atlas);
ASSERT(skeletonData != nullptr);
stateData = spAnimationStateData_create(skeletonData);
ASSERT(stateData != nullptr);
stateData->defaultMix = 0.4f; // force mixing
///////////////////////////////////////////////////////////////////////////
// Animation Instance
skeleton = spSkeleton_create(skeletonData);
ASSERT(skeleton != nullptr);
state = spAnimationState_create(stateData);
ASSERT(state != nullptr);
}
Player::Player(Game& g, b2Vec2 p) : Character(g),swordFix(NULL), left(false), right(false), landed(true), contact(false), lastproc(0), life(100), attacking(false), attackcooldown(0)
{
bodyDef.type = b2_dynamicBody;
bodyDef.position.Set(p.x, p.y);
bodyDef.fixedRotation = true;
body = g.w.CreateBody(&bodyDef);
dynamicBox.SetAsBox(.25f, 0.9f);
fixtureDef.shape = &dynamicBox;
fixtureDef.density = 5.0f;
fixtureDef.friction = 0.0f;
fixtureDef.filter.categoryBits = PLAYER;
fixtureDef.filter.maskBits = MONSTER | TRIGGER | WALL | SWORD;
(body->CreateFixture(&fixtureDef))->SetUserData(this);
//add "feet" to detect floor
dynamicBox.SetAsBox(0.2, 0.05, b2Vec2(0, 0.9f), 0);
fixtureDef.isSensor = true;
fixtureDef.density = 0.1;
fixtureDef.filter.categoryBits = FOOT;
fixtureDef.filter.maskBits = WALL | MONSTER;
(body->CreateFixture(&fixtureDef))->SetUserData(this);
//add sword to kill monsters
dynamicBox.SetAsBox(0.4, 0.1, b2Vec2(0.65, 0), 0);
swordDef.shape = &dynamicBox;
swordDef.isSensor = true;
swordDef.density = 0.1;
swordDef.filter.categoryBits = SWORD;
swordDef.filter.maskBits = MONSTER;
// Loads the Spine model
ALLEGRO_PATH *path, *resourceDir, *file;
resourceDir= al_get_standard_path(ALLEGRO_RESOURCES_PATH);
std::cerr << al_path_cstr(resourceDir, ALLEGRO_NATIVE_PATH_SEP) << std::endl;
if (modelAtlas == NULL) {
file = al_create_path("data/animations/hero.atlas");
path = al_clone_path(resourceDir);
al_join_paths(path, file); al_destroy_path(file);
modelAtlas = spAtlas_createFromFile(al_path_cstr(path, ALLEGRO_NATIVE_PATH_SEP), NULL);
if (!modelAtlas) throw Failure("Failed to load the hero's atlas.");
al_destroy_path(path);
jsonSkel = spSkeletonJson_create(modelAtlas);
file = al_create_path("data/animations/hero.json");
path = al_clone_path(resourceDir);
al_join_paths(path, file); al_destroy_path(file);
modelData = spSkeletonJson_readSkeletonDataFile(jsonSkel, al_path_cstr(path, ALLEGRO_NATIVE_PATH_SEP));
if (!modelData) throw Failure("Failed to load the hero's data.");
al_destroy_path(path); al_destroy_path(resourceDir);
stateData = spAnimationStateData_create(modelData);
spAnimationStateData_setMixByName(stateData, "walk", "rest", 0.2f);
spAnimationStateData_setMixByName(stateData, "rest", "walk", 0.2f);
spAnimationStateData_setMixByName(stateData, "rest", "slash", 0.1f);
spAnimationStateData_setMixByName(stateData, "slash", "rest", 0.1f);
spAnimationStateData_setMixByName(stateData, "walk", "slash", 0.1f);
spAnimationStateData_setMixByName(stateData, "slash", "walk", 0.1f);
model = loadSkeleton(modelData, stateData);
if (!model) throw Failure("Failed to load the hero's skeleton.");
spAnimationState_setAnimationByName(model->state, 0, "rest", true);
}
}
SpineDrawable::SpineDrawable(const std::string& atlasFile, const std::string& skeletonFile):
Component(TYPE)
{
atlas = spAtlas_createFromFile(atlasFile.c_str(), 0);
if (!atlas)
{
ouzel::Log(ouzel::Log::Level::ERR) << "Failed to load atlas";
return;
}
if (skeletonFile.find(".json") != std::string::npos)
{
// is json format
spSkeletonJson* json = spSkeletonJson_create(atlas);
skeletonData = spSkeletonJson_readSkeletonDataFile(json, skeletonFile.c_str());
if (!skeletonData)
{
ouzel::Log(ouzel::Log::Level::ERR) << "Failed to load skeleton: " << json->error;
return;
}
spSkeletonJson_dispose(json);
}
else
{
// binary format
spSkeletonBinary* binary = spSkeletonBinary_create(atlas);
skeletonData = spSkeletonBinary_readSkeletonDataFile(binary, skeletonFile.c_str());
if (!skeletonData)
{
ouzel::Log(ouzel::Log::Level::ERR) << "Failed to load skeleton: " << binary->error;
return;
}
spSkeletonBinary_dispose(binary);
}
bounds = spSkeletonBounds_create();
skeleton = spSkeleton_create(skeletonData);
animationStateData = spAnimationStateData_create(skeletonData);
animationState = spAnimationState_create(animationStateData);
animationState->listener = listener;
animationState->rendererObject = this;
spSkeleton_setToSetupPose(skeleton);
spSkeleton_updateWorldTransform(skeleton);
updateMaterials();
updateBoundingBox();
indexBuffer = std::make_shared<ouzel::graphics::Buffer>(*ouzel::engine->getRenderer());
indexBuffer->init(ouzel::graphics::Buffer::Usage::INDEX, ouzel::graphics::Buffer::DYNAMIC);
vertexBuffer = std::make_shared<ouzel::graphics::Buffer>(*ouzel::engine->getRenderer());
vertexBuffer->init(ouzel::graphics::Buffer::Usage::VERTEX, ouzel::graphics::Buffer::DYNAMIC);
whitePixelTexture = ouzel::engine->getCache().getTexture(ouzel::TEXTURE_WHITE_PIXEL);
updateHandler.updateHandler = std::bind(&SpineDrawable::handleUpdate, this, std::placeholders::_1);
ouzel::engine->getEventDispatcher().addEventHandler(&updateHandler);
}
