void Editor::restoreKey()
{
BackupElement* lastBackupElement = mBackupList[mBackupIndex];
Layer* layer = nullptr;
int frame = 0;
int layerIndex = 0;
if (lastBackupElement->type() == BackupElement::BITMAP_MODIF)
{
BackupBitmapElement* lastBackupBitmapElement = static_cast<BackupBitmapElement*>(lastBackupElement);
layerIndex = lastBackupBitmapElement->layer;
frame = lastBackupBitmapElement->frame;
layer = object()->getLayer(layerIndex);
addKeyFrame(layerIndex, frame);
dynamic_cast<LayerBitmap*>(layer)->getBitmapImageAtFrame(frame)->paste(&lastBackupBitmapElement->bitmapImage);
}
if (lastBackupElement->type() == BackupElement::VECTOR_MODIF)
{
BackupVectorElement* lastBackupVectorElement = static_cast<BackupVectorElement*>(lastBackupElement);
layerIndex = lastBackupVectorElement->layer;
frame = lastBackupVectorElement->frame;
layer = object()->getLayer(layerIndex);
addKeyFrame(layerIndex, frame);
dynamic_cast<LayerVector*>(layer)->getVectorImageAtFrame(frame)->paste(lastBackupVectorElement->vectorImage);
}
if (lastBackupElement->type() == BackupElement::SOUND_MODIF)
{
QString strSoundFile;
BackupSoundElement* lastBackupSoundElement = static_cast<BackupSoundElement*>(lastBackupElement);
layerIndex = lastBackupSoundElement->layer;
frame = lastBackupSoundElement->frame;
strSoundFile = lastBackupSoundElement->fileName;
KeyFrame* key = addKeyFrame(layerIndex, frame);
SoundClip* clip = dynamic_cast<SoundClip*>(key);
if (clip)
{
if (strSoundFile.isEmpty())
{
return;
}
else
{
//Status st = sound()->pasteSound(clip, strSoundFile);
//Q_ASSERT(st.ok());
}
}
}
}
void TimeLine::onDragDrop (ATOM_WidgetDragDropEvent *event)
{
if (event->dragSource->getProperty("Type") == "KM")
{
unsigned numSlices = _duration / _timeSlice;
unsigned width = _timeLine->getClientRect().size.w;
unsigned sliceWidth = (width - numSlices - 1) / numSlices;
unsigned space = (width - numSlices * (sliceWidth + 1) - 1) / 2;
int x = event->x - space;
int n = x / (1 + sliceWidth);
if ( n < numSlices && !isKeyFrame (n))
{
int source = event->dragSource->getProperty("SourceFrame").getI();
ATOM_AUTOPTR(ATOM_CompositionKeyFrameValue) keyFrameValue = _actor->createKeyFrameValue ();
_actor->evalKeyFrameValue (sliceIndexToTime (source), keyFrameValue.get());
if ((event->keymod & KEYMOD_SHIFT) == 0)
{
removeKeyFrame (source);
}
addKeyFrame (n, keyFrameValue.get());
setCurrentSlice (n, 0);
}
}
}
bool LayerCamera::addNewKeyFrameAt( int frameNumber )
{
QMatrix viewMatrix = getViewAtFrame( frameNumber );
Camera* pCamera = new Camera( viewMatrix );
pCamera->setPos( frameNumber );
return addKeyFrame( frameNumber, pCamera );
}
void Animation::applyIK(const QString& name)
{
BVHNode* node=bvh->bvhFindNode(frames,name);
Rotation rot=node->frameData(frame).rotation();
if(node)
{
// for (int i=0; i<3; i++) {
rot.x+=node->ikRot.x;
rot.y+=node->ikRot.y;
rot.z+=node->ikRot.z;
node->ikRot.x=0;
node->ikRot.y=0;
node->ikRot.z=0;
/*
node->frame[frame][i] += node->ikRot[i];
node->ikRot[i] = 0;
*/
// node->ikOn = false;
setDirty(true);
addKeyFrame(node);
node->setKeyframeRotation(frame,rot);
emit redrawTrack(getPartIndex(node));
// }
}
}
void scUiAlphaAnimation::createKeyFrame( u32 time, f32 alpha, scKeyFrame::InterpolationType itype /*= scKeyFrame::IT_LINEAR*/ )
{
scAssert(alpha >= 0.f && alpha <= 1.f, "Widget alpha must in range 0 to 1! Current: " + scToString(alpha));
scContinuousKeyFrame<f32>* keyFrame = new scContinuousKeyFrame<f32>(time, alpha);
keyFrame->setInterpolationType(itype);
addKeyFrame(scKeyFramePtr(keyFrame));
}
bool LayerCamera::addNewKeyAt( int frameNumber )
{
QTransform view = getViewAtFrame( frameNumber );
Camera* pCamera = new Camera( view );
pCamera->setPos( frameNumber );
return addKeyFrame( frameNumber, pCamera );
}
void TimeLine::onLButtonDown (ATOM_WidgetLButtonDownEvent *event)
{
unsigned numSlices = _duration / _timeSlice;
unsigned width = _timeLine->getClientRect().size.w;
unsigned sliceWidth = (width - numSlices - 1) / numSlices;
unsigned space = (width - numSlices * (sliceWidth + 1) - 1) / 2;
int x = event->x - space;
int n = x / (1 + sliceWidth);
if ( n < numSlices)
{
if (event->shiftState & KEYMOD_CTRL)
{
if (isKeyFrame (n))
{
removeKeyFrame (n);
}
else
{
addKeyFrame (n);
}
}
else
{
setCurrentSlice (n, 0);
}
}
}
void LayerCamera::loadImageAtFrame( int frameNumber, QTransform view )
{
if ( keyExists( frameNumber ) )
{
removeKeyFrame( frameNumber );
}
Camera* camera = new Camera( view );
camera->setPos( frameNumber );
addKeyFrame( frameNumber, camera );
}
void Animation::recursiveAddKeyFrame(BVHNode* joint)
{
if(joint->type!=BVH_END)
addKeyFrame(joint);
for(int i=0;i<joint->numChildren();i++)
recursiveAddKeyFrame(joint->child(i));
setDirty(true);
}
void LayerCamera::loadImageAtFrame(int frameNumber, QMatrix view)
{
if ( hasKeyFrameAtPosition( frameNumber ) )
{
removeKeyFrame( frameNumber );
}
Camera* camera = new Camera( view );
camera->setPos( frameNumber );
addKeyFrame( frameNumber, camera );
}
void LayerVector::loadImageAtFrame(QString path, int frameNumber)
{
if ( keyExists( frameNumber ) )
{
removeKeyFrame( frameNumber, false );
}
VectorImage* vecImg = new VectorImage;
vecImg->setPos( frameNumber );
vecImg->setObject( object() );
vecImg->read( path );
addKeyFrame( frameNumber, vecImg );
}
bool VisualOdometry::addFrame ( Frame::Ptr frame )
{
switch ( state_ )
{
case INITIALIZING:
{
state_ = OK;
curr_ = ref_ = frame;
map_->insertKeyFrame ( frame );
// extract features from first frame and add them into map
extractKeyPoints();
computeDescriptors();
setRef3DPoints();
break;
}
case OK:
{
curr_ = frame;
extractKeyPoints();
computeDescriptors();
featureMatching();
poseEstimationPnP();
if ( checkEstimatedPose() == true ) // a good estimation
{
curr_->T_c_w_ = T_c_r_estimated_ * ref_->T_c_w_; // T_c_w = T_c_r*T_r_w
ref_ = curr_;
setRef3DPoints();
num_lost_ = 0;
if ( checkKeyFrame() == true ) // is a key-frame
{
addKeyFrame();
}
}
else // bad estimation due to various reasons
{
num_lost_++;
if ( num_lost_ > max_num_lost_ )
{
state_ = LOST;
}
return false;
}
break;
}
case LOST:
{
cout<<"vo has lost."<<endl;
break;
}
}
return true;
}
int qglviewer::KeyFrameInterpolator::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
_id = QObject::qt_metacall(_c, _id, _a);
if (_id < 0)
return _id;
if (_c == QMetaObject::InvokeMetaMethod) {
switch (_id) {
case 0: interpolated(); break;
case 1: endReached(); break;
case 2: addKeyFrame((*reinterpret_cast< const Frame(*)>(_a[1]))); break;
case 3: addKeyFrame((*reinterpret_cast< const Frame(*)>(_a[1])),(*reinterpret_cast< float(*)>(_a[2]))); break;
case 4: addKeyFrame((*reinterpret_cast< const Frame*const(*)>(_a[1]))); break;
case 5: addKeyFrame((*reinterpret_cast< const Frame*const(*)>(_a[1])),(*reinterpret_cast< float(*)>(_a[2]))); break;
case 6: deletePath(); break;
case 7: setFrame((*reinterpret_cast< Frame*const(*)>(_a[1]))); break;
case 8: setInterpolationTime((*reinterpret_cast< float(*)>(_a[1]))); break;
case 9: setInterpolationSpeed((*reinterpret_cast< float(*)>(_a[1]))); break;
case 10: setInterpolationPeriod((*reinterpret_cast< int(*)>(_a[1]))); break;
case 11: setLoopInterpolation((*reinterpret_cast< bool(*)>(_a[1]))); break;
case 12: setLoopInterpolation(); break;
case 13: setClosedPath((*reinterpret_cast< bool(*)>(_a[1]))); break;
case 14: setClosedPath(); break;
case 15: startInterpolation((*reinterpret_cast< int(*)>(_a[1]))); break;
case 16: startInterpolation(); break;
case 17: stopInterpolation(); break;
case 18: resetInterpolation(); break;
case 19: toggleInterpolation(); break;
case 20: interpolateAtTime((*reinterpret_cast< float(*)>(_a[1]))); break;
case 21: update(); break;
case 22: invalidateValues(); break;
default: ;
}
_id -= 23;
}
return _id;
}
bool LHCameraActivateProperty::initWithDictionary(LHDictionary* dict, LHAnimation* anim)
{
if(dict == NULL)return true; //special case for children subproperties
if(LHAnimationProperty::initWithDictionary(dict, anim))
{
LHArray* framesInfo = dict->arrayForKey("Frames");
for(int i = 0; i < framesInfo->count(); ++i)
{
LHDictionary* frmInfo = framesInfo->dictAtIndex(i);
LHFrame* frm = LHFrame::createWithDictionary(frmInfo, this);
addKeyFrame(frm);
}
return true;
}
return false;
}
bool Animation::toggleKeyFrame(BVHNode* node)
{
// qDebug("Animation::toggleKeyFrame(node): node %ld",(unsigned long) node);
if(!node)
return toggleKeyFrameAllJoints();
else
{
if (node->isKeyframe(frame))
{
deleteKeyFrame(node,frame);
return false;
}
else
{
addKeyFrame(node);
return true;
}
}
}
//---------------------------------------------------------------------
// ● 初期化
//---------------------------------------------------------------------
void GameFrontendManager::initialize( Player* player_ )
{
mStep = GFM_PTEP_SETUP;
mFrameCount = 0;
mFloorInfoOffset = 0;
mFloorNumAnimTime = 0;
mNumberTexture1 = Assets::loadTexture("Data/Graphics/Frontend/Number_1.png");
mPlayerStateWindow = NEW PlayerStateWindow(player_);
mNamePlateFont = Font::create();
mNamePlateFont->setFamily(u"МＳ Ｐゴシック");
mNamePlateFont->setSize(10);
//mNamePlateFont->SetColor( LColor( 1, 1, 1 ) );
mNamePlateFont->setAntiAlias(false);
mGuidNamePlateFont = Font::create();
mGuidNamePlateFont->setFamily(u"МＳ Ｐゴシック");
mGuidNamePlateFont->setSize(10);
//mGuidNamePlateFont->SetColor( LColor( 1, 1, 1 ) );
//mGuidNamePlateFont->setEdgeSize( 1 );
//mGuidNamePlateFont->setEdgeColor( LColor( 0.25f, 0.25f, 0.25f ) );
mGuidNamePlateFont->setAntiAlias(false);
mDamagePop = NEW DamagePop();
mShowCharacterNamePlateCount = 0;
mGlobalFadeOpacity.start(1.0f, 1.0f, 0.1f);
mLevelupFrameCount = 0;
LTexture tex = Assets::loadTexture("Data/Graphics/Frontend/Frontend_1.png");
mLevelupSprites[0] = ln::UISprite::create(tex);//return;
mLevelupSprites[0]->setSourceRect(0, 480, 256, 16);
mLevelupSprites[0]->setCenterPoint(128, 8);
mLevelupSprites[0]->setVisible(false);
mLevelupSprites[1] = ln::UISprite::create(tex);
mLevelupSprites[1]->setSourceRect(0, 496, 256, 16);
mLevelupSprites[1]->setCenterPoint(128, 8);
mLevelupSprites[1]->setVisible(false);
mLevelEffectSprite = ln::UISprite::create(tex);
mLevelEffectSprite->setSourceRect(0, 416, 64, 64);
mLevelEffectSprite->setPosition(320, 200);
mLevelEffectSprite->setCenterPoint(32, 32);
mLevelEffectSprite->setVisible(false);
mLevelupSprites[0]->setPosition(320, 200 - 8);
mLevelupSprites[1]->setPosition(320, 200 + 8);
mPointCursor = NEW PointCursor();
auto curve1 = KeyFrameAnimationCurve::create();
curve1->addKeyFrame(0, 0.0f, TangentMode::Auto);
curve1->addKeyFrame(30, 1.0f, TangentMode::Linear);
curve1->addKeyFrame(90, 1.0f, TangentMode::Auto);
curve1->addKeyFrame(120, 2.0f, TangentMode::Auto);
mFloorNumAnim = ScalarAnimationTrack::create();
mFloorNumAnim->setCurve(curve1);
auto curve2 = KeyFrameAnimationCurve::create();
curve2->addKeyFrame(0, 0.0f, TangentMode::Auto);
curve2->addKeyFrame(30, 1.0f, TangentMode::Auto);
curve2->addKeyFrame(90, 1.0f, TangentMode::Auto);
curve2->addKeyFrame(120, 0.0f, TangentMode::Auto);
mFloorNumAnimAlpha = ScalarAnimationTrack::create();
mFloorNumAnimAlpha->setCurve(curve2);
mFloorInfoTexture = Assets::loadTexture("Data/Graphics/Frontend/FloorInfo_1.png");
for (int i = 0; i < 3; ++i)
{
mFloorInfoSprite[i] = ln::UISprite::create(mFloorInfoTexture);
mFloorInfoSprite[i]->setVisible(false);
}
mFloorInfoSprite[0]->setSourceRect(0, 0, 512, 32); // 下線
}
bool LayerSound::addNewKeyAt(int frameNumber)
{
return addKeyFrame( frameNumber, new SoundClip );
}
KeyFrame* Editor::addNewKey()
{
return addKeyFrame(layers()->currentLayerIndex(), currentFrame());
}
void Animation::addKeyFrameAllJoints()
{
addKeyFrame(getNode(0));
recursiveAddKeyFrame(frames);
}
