/**
@pre CWsSpriteBase::CalcRedrawRegion(TRegion&,TRegion&) should have been called.
@param aRegion Is the region that will definitely be redrawn if dirty. This param should
be calculated by calling CalcRedrawRegion(TRegion&,TRegion&)
*/
void CWsSpriteBase::Redraw(MWsGraphicsContext * aGc, const TRegion& aRegion)
{
TFlashState currentState=EFlashOn;
if(IsFlashingEnabled())
{
currentState=Screen()->SpriteManager()->CurrentSpriteFlashState(this);
AnnotateSpriteFlash(*this, currentState==EFlashOn);
}
if(currentState==EFlashOn && (IsDirty() || HasAnimation()) )
{
const TRegion * pr = &aRegion;
if (pr->CheckError())
{
if(iWin)
{
if (Screen()->ChangeTracking())
pr = &iWin->WindowArea();
else
pr = &iWin->VisibleRegion();
}
else
pr = &RootWindow()->WindowArea();
}
if (!pr->IsEmpty())
{
CWsSpriteMember *member=(*iMembers)[iCurIndex];
if (member->iBitmap)
{
aGc->SetClippingRegion(*pr);
// Calculate which piece (rect) of the bitmap needs to be drawn
const TRect redrawRect = pr->BoundingRect();
TRect bitmapRect(Pos(), iSize); // sprite rect relative to screen
bitmapRect.Intersection(redrawRect);
bitmapRect.Move(-Pos()); // adjust relative to bitmap origin
if (member->iMaskBitmap)
aGc->BitBltMasked(Pos() + bitmapRect.iTl, *member->iBitmap, bitmapRect, *member->iMaskBitmap, member->iInvertMask);
else
{
aGc->SetDrawMode(BitGdiToMWsGraphicsContextMappings::LossyConvert(member->iDrawMode));
aGc->BitBlt(Pos() + bitmapRect.iTl, *member->iBitmap, bitmapRect);
aGc->SetDrawMode(MWsGraphicsContext::EDrawModePEN);
}
aGc->ResetClippingRegion();
}
}
if (Screen()->ChangeTracking())
SetDirty(EFalse);
}
//Flashing sprites need to reschedule themselves after drawing (unless they have
//an animation, because for animating sprites the rescheduling is done in CWsAnim).
if(IsFlashingEnabled() && !HasAnimation())
Screen()->SpriteManager()->Schedule(this);
}
void CGUIDialog::Close(bool forceClose /*= false*/)
{
//Lock graphic context here as it is sometimes called from non rendering threads
//maybe we should have a critical section per window instead??
CSingleLock lock(g_graphicsContext);
if (!m_bRunning) return;
// Play the window specific deinit sound
g_audioManager.PlayWindowSound(GetID(), SOUND_DEINIT);
// don't close if we should be animating
if (!forceClose && HasAnimation(ANIM_TYPE_WINDOW_CLOSE))
{
if (!m_dialogClosing && !IsAnimating(ANIM_TYPE_WINDOW_CLOSE))
{
QueueAnimation(ANIM_TYPE_WINDOW_CLOSE);
m_dialogClosing = true;
}
return;
}
CGUIMessage msg(GUI_MSG_WINDOW_DEINIT, 0, 0);
OnMessage(msg);
}
//----------------------------------------------------------------------------
bool SceneBuilder::ConvertFRGBAAttrib(IParamBlock2* paramBlock, int index,
std::string &name, PX2::Float4 &value)
{
ParamBlockDesc2 *paramDesc = paramBlock->GetDesc();
if (!paramDesc)
return false;
ParamDef ¶mDef = paramDesc->GetParamDef(paramDesc->IndextoID(index));
Point4 vectorValue;
Interval validInterval;
BOOL retrieved = false;
retrieved = paramBlock->GetValue((ParamID)index, 0 , vectorValue, validInterval);
if(retrieved)
{
TCHAR* valueName = paramDef.int_name;
if (!IsValidName(valueName))
valueName = paramBlock->GetLocalName((ParamID)index );
assertion(IsValidName(valueName), "valueName must be valuable.");
name = std::string(valueName);
value = PX2::Float4(vectorValue.x, vectorValue.y, vectorValue.z,
vectorValue.w);
if(HasAnimation(paramBlock, index))
{
}
}
return true;
}
void
Decoder::PostFrameStop(Opacity aFrameOpacity
/* = Opacity::SOME_TRANSPARENCY */,
DisposalMethod aDisposalMethod
/* = DisposalMethod::KEEP */,
int32_t aTimeout /* = 0 */,
BlendMethod aBlendMethod /* = BlendMethod::OVER */)
{
// We should be mid-frame
MOZ_ASSERT(!IsMetadataDecode(), "Stopping frame during metadata decode");
MOZ_ASSERT(mInFrame, "Stopping frame when we didn't start one");
MOZ_ASSERT(mCurrentFrame, "Stopping frame when we don't have one");
// Update our state
mInFrame = false;
mCurrentFrame->Finish(aFrameOpacity, aDisposalMethod, aTimeout, aBlendMethod);
mProgress |= FLAG_FRAME_COMPLETE;
// If we're not sending partial invalidations, then we send an invalidation
// here when the first frame is complete.
if (!ShouldSendPartialInvalidations() && mFrameCount == 1) {
mInvalidRect.UnionRect(mInvalidRect,
gfx::IntRect(gfx::IntPoint(0, 0), GetSize()));
}
// If we are going to keep decoding we should notify now about the first frame being done.
if (mImage && mFrameCount == 1 && HasAnimation()) {
MOZ_ASSERT(HasProgress());
DecodePool::Singleton()->NotifyProgress(this);
}
}
nsresult
Decoder::AllocateFrame(uint32_t aFrameNum,
const nsIntSize& aTargetSize,
const nsIntRect& aFrameRect,
gfx::SurfaceFormat aFormat,
uint8_t aPaletteDepth)
{
mCurrentFrame = AllocateFrameInternal(aFrameNum, aTargetSize, aFrameRect,
aFormat, aPaletteDepth,
mCurrentFrame.get());
if (mCurrentFrame) {
// Gather the raw pointers the decoders will use.
mCurrentFrame->GetImageData(&mImageData, &mImageDataLength);
mCurrentFrame->GetPaletteData(&mColormap, &mColormapSize);
if (aFrameNum + 1 == mFrameCount) {
// If we're past the first frame, PostIsAnimated() should've been called.
MOZ_ASSERT_IF(mFrameCount > 1, HasAnimation());
// Update our state to reflect the new frame
MOZ_ASSERT(!mInFrame, "Starting new frame but not done with old one!");
mInFrame = true;
}
} else {
PostDataError();
}
return mCurrentFrame ? NS_OK : NS_ERROR_FAILURE;
}
void
Decoder::CompleteDecode()
{
// Implementation-specific finalization
BeforeFinishInternal();
if (!HasError()) {
FinishInternal();
} else {
FinishWithErrorInternal();
}
// If the implementation left us mid-frame, finish that up.
if (mInFrame && !HasError()) {
PostFrameStop();
}
// If PostDecodeDone() has not been called, and this decoder wasn't aborted
// early because of low-memory conditions or losing a race with another
// decoder, we need to send teardown notifications (and report an error to the
// console later).
if (!IsMetadataDecode() && !mDecodeDone && !WasAborted()) {
mShouldReportError = true;
// If we only have a data error, we're usable if we have at least one
// complete frame.
if (!HasDecoderError() && GetCompleteFrameCount() > 0) {
// We're usable, so do exactly what we should have when the decoder
// completed.
// Not writing to the entire frame may have left us transparent.
PostHasTransparency();
if (mInFrame) {
PostFrameStop();
}
PostDecodeDone();
} else {
// We're not usable. Record some final progress indicating the error.
if (!IsMetadataDecode()) {
mProgress |= FLAG_DECODE_COMPLETE;
}
mProgress |= FLAG_HAS_ERROR;
}
}
if (mDecodeDone && !IsMetadataDecode()) {
MOZ_ASSERT(HasError() || mCurrentFrame, "Should have an error or a frame");
// If this image wasn't animated and isn't a transient image, mark its frame
// as optimizable. We don't support optimizing animated images and
// optimizing transient images isn't worth it.
if (!HasAnimation() &&
!(mDecoderFlags & DecoderFlags::IMAGE_IS_TRANSIENT) &&
mCurrentFrame) {
mCurrentFrame->SetOptimizable();
}
}
}
DiAnimation* DiMotion::CreateAnimation(const DiString& name, float length)
{
if (HasAnimation(name))
{
DI_WARNING("The animatin %s has already existed",name.c_str());
return nullptr;
}
DiAnimation* am = DI_NEW DiAnimation(name,length);
mAnimationList[name] = am;
return am;
}
void CModelViewRender::PlaySequence(const ANIMATIONSEQUENCE &sequence)
{
// make a copy of the requested sequence
m_PlayingAnimationSequence.clear();
std::copy(sequence.begin(), sequence.end(), std::back_inserter(m_PlayingAnimationSequence));
m_itCurrentAnimationID = m_PlayingAnimationSequence.begin();
// create all the callbacks at once for the sequence
set<int> uniqueCallbackSet;
for (ANIMATIONSEQUENCE::iterator itrAnim = m_PlayingAnimationSequence.begin(); itrAnim != m_PlayingAnimationSequence.end(); itrAnim++)
{
// skip duplicate animations (only need to make one callback per animation)
if (uniqueCallbackSet.find( *itrAnim ) != uniqueCallbackSet.end())
continue;
IArchive* pArchive = CreateMemoryArchive();
pArchive->Write(m_hszEntityName.GetString(), _T("EntityName"));
pArchive->Write(*itrAnim);
pArchive->SetIsWriting(false);
m_AnimationCallbackArchives.push_back( pArchive );
static CHashString hszCal3DRenderObject = _T("Cal3DRenderObject");
static CHashString hszCModelViewComponent(_T("CModelViewComponent"));
static CHashString hszPlayAnimationSequenceStep(_T("PlayAnimationSequenceStep"));
REGISTERCAL3DANIMATIONCALLBACK ac;
ac.AnimationId = *itrAnim;
ac.bTriggerOnComplete = true;
ac.bTriggerOnStop = false;
ac.StateObjectName = &hszCModelViewComponent;
ac.EventName = &hszPlayAnimationSequenceStep;
ac.EventParamsArchive = pArchive;
static DWORD msgHash_RegisterAnimationCallback = CHashString(_T("RegisterAnimationCallback")).GetUniqueID();
DWORD res = m_ToolBox->SendMessage(msgHash_RegisterAnimationCallback, sizeof(ac), &ac, &m_hszEntityName, &hszCal3DRenderObject);
if (MSG_HANDLED != res)
{
m_ToolBox->Log(LOGERROR, _T("%s(%i): Cannot register animation callback. \n"), __FILE__, __LINE__);
}
uniqueCallbackSet.insert( *itrAnim );
}
if (HasAnimation())
{
SINGLETONINSTANCE(CModelViewComponent)->PlayAnimation(this);
}
}
void CModelViewRender::PlayNextAnimation()
{
static CHashString hszCal3DRenderObject(_T("Cal3DRenderObject"));
static DWORD msgStopAllAnimationActions = CHashString(_T("StopAllAnimationActions")).GetUniqueID();
m_ToolBox->SendMessage( msgStopAllAnimationActions, 0, NULL, &m_hszEntityName, &hszCal3DRenderObject );
if (m_itCurrentAnimationID != m_PlayingAnimationSequence.end())
m_itCurrentAnimationID++;
if (m_bLoop && m_itCurrentAnimationID == m_PlayingAnimationSequence.end())
{
m_itCurrentAnimationID = m_PlayingAnimationSequence.begin();
}
if (HasAnimation())
{
SINGLETONINSTANCE(CModelViewComponent)->PlayAnimation(this);
}
}
void CModelViewRender::StopSequence()
{
m_bPlayNextInSequence = false;
static CHashString hszCal3DRenderObject = _T("Cal3DRenderObject");
// unregister all animation callbacks
static DWORD msgHash_UnregisterAllAnimationCallbacks = CHashString(_T("UnregisterAllAnimationCallbacks")).GetUniqueID();
DWORD res = m_ToolBox->SendMessage(msgHash_UnregisterAllAnimationCallbacks, 0, NULL, &m_hszEntityName, &hszCal3DRenderObject);
if (MSG_HANDLED != res)
{
m_ToolBox->Log(LOGERROR, _T("%s(%i): Cannot unregister animation callbacks.\n"), __FILE__, __LINE__);
}
// clean up all the callback archives
vector<IArchive*>::iterator itrCallback = m_AnimationCallbackArchives.begin();
while (itrCallback != m_AnimationCallbackArchives.end())
{
(*itrCallback)->Close();
itrCallback++;
}
m_AnimationCallbackArchives.clear();
// stop all animations
static DWORD msgStopAllAnimationActions = CHashString(_T("StopAllAnimationActions")).GetUniqueID();
m_ToolBox->SendMessage( msgStopAllAnimationActions, 0, NULL, &m_hszEntityName, &hszCal3DRenderObject );
if (HasAnimation())
{
m_PlayingAnimationSequence.clear();
m_itCurrentAnimationID = m_PlayingAnimationSequence.end();
m_bLoop = false;
// initiate delayed deletion for cal3Dmodel callbacks with Update event
// this prevents memory leaks with EventParamsArchive
// TODO. This may be fixed in cal3DModel probably
AfxGetApp()->OnIdle(2);
}
GetDockDlg()->OnStopSequence();
}
void FaerieAnimationsCollection::AddAnimation(FaerieAnimation* animation) {
assert(!HasAnimation(animation->GetName()));
_mapAnimations[animation->GetName()] = animation;
}
int CModelViewRender::GetCurrentAnimationID() const
{
ASSERT(HasAnimation());
return *m_itCurrentAnimationID;
}
