//-----------------------------------------------------------------------------
// Purpose:
// Output : int
//-----------------------------------------------------------------------------
int CBaseAnimatingOverlay::AddLayeredSequence( int sequence, int iPriority )
{
int i = AllocateLayer( iPriority );
Assert( IsValidLayer( i ) );
// No room?
if ( IsValidLayer( i ) )
{
m_AnimOverlay[i].m_flCycle = 0;
m_AnimOverlay[i].m_flPrevCycle = 0;
m_AnimOverlay[i].m_flPlaybackRate = 1.0;
m_AnimOverlay[i].m_nActivity = ACT_INVALID;
m_AnimOverlay[i].m_nSequence = sequence;
m_AnimOverlay[i].m_flWeight = 1.0f;
m_AnimOverlay[i].m_flBlendIn = 0.0f;
m_AnimOverlay[i].m_flBlendOut = 0.0f;
m_AnimOverlay[i].m_bSequenceFinished = false;
m_AnimOverlay[i].m_flLastEventCheck = 0;
m_AnimOverlay[i].m_bLooping = ((GetSequenceFlags( GetModelPtr(), sequence ) & STUDIO_LOOPING) != 0);
if (ai_sequence_debug.GetBool() == true && m_debugOverlays & OVERLAY_NPC_SELECTED_BIT)
{
Msg("%5.3f : adding %d (%d): %s : %5.3f (%.3f)\n", gpGlobals->curtime, i, m_AnimOverlay[ i ].m_nOrder.Get(), GetSequenceName( m_AnimOverlay[ i ].m_nSequence ), m_AnimOverlay[ i ].m_flCycle.Get(), m_AnimOverlay[ i ].m_flWeight.Get() );
}
}
return i;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
float CBaseAnimatingOverlay::GetLayerWeight( int iLayer )
{
if (!IsValidLayer( iLayer ))
return 0.0;
return m_AnimOverlay[iLayer].m_flWeight;
}
void CBaseAnimatingOverlay::SetLayerDuration( int iLayer, float flDuration )
{
if (IsValidLayer( iLayer ) && flDuration > 0)
{
m_AnimOverlay[iLayer].m_flPlaybackRate = SequenceDuration( m_AnimOverlay[iLayer].m_nSequence ) / flDuration;
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CBaseAnimatingOverlay::SetLayerLooping( int iLayer, bool bLooping )
{
if (!IsValidLayer( iLayer ))
return;
m_AnimOverlay[iLayer].m_bLooping = bLooping;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CBaseAnimatingOverlay::SetLayerBlendOut( int iLayer, float flBlendOut )
{
if (!IsValidLayer( iLayer ))
return;
m_AnimOverlay[iLayer].m_flBlendOut = flBlendOut;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
float CBaseAnimatingOverlay::GetLayerCycle( int iLayer )
{
if (!IsValidLayer( iLayer ))
return 0.0;
return m_AnimOverlay[iLayer].m_flCycle;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
int CBaseAnimatingOverlay::GetLayerSequence( int iLayer )
{
if (!IsValidLayer( iLayer ))
{
return ACT_INVALID;
}
return m_AnimOverlay[iLayer].m_nSequence;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CBaseAnimatingOverlay::SetLayerWeight( int iLayer, float flWeight )
{
if (!IsValidLayer( iLayer ))
return;
flWeight = clamp( flWeight, 0.0f, 1.0f );
m_AnimOverlay[iLayer].m_flWeight = flWeight;
m_AnimOverlay[iLayer].MarkActive( );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CBaseAnimatingOverlay::SetLayerPlaybackRate( int iLayer, float flPlaybackRate )
{
if (!IsValidLayer( iLayer ))
return;
Assert( flPlaybackRate > -1.0 && flPlaybackRate < 40.0);
m_AnimOverlay[iLayer].m_flPlaybackRate = flPlaybackRate;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
Activity CBaseAnimatingOverlay::GetLayerActivity( int iLayer )
{
if (!IsValidLayer( iLayer ))
{
return ACT_INVALID;
}
return m_AnimOverlay[iLayer].m_nActivity;
}
void LAYERS_MAP_DIALOG::OnSelectLayer( wxCommandEvent& event )
{
int ii;
ii = event.GetId() - ID_BUTTON_0;
if( (ii < 0) || (ii >= GERBER_DRAWLAYERS_COUNT) )
{
wxFAIL_MSG( wxT("Bad layer id") );
return;
}
LAYER_NUM jj = m_layersLookUpTable[m_buttonTable[ii]];
if( jj != UNSELECTED_LAYER && !IsValidLayer( jj ) )
jj = B_Cu; // (Defaults to "Copper" layer.)
jj = m_Parent->SelectPCBLayer( jj, m_exportBoardCopperLayersCount, true );
if( jj != UNSELECTED_LAYER && !IsValidLayer( jj ) )
return;
if( jj != m_layersLookUpTable[m_buttonTable[ii]] )
{
m_layersLookUpTable[m_buttonTable[ii]] = jj;
if( jj == UNSELECTED_LAYER )
{
m_layersList[ii]->SetLabel( _( "Do not export" ) );
// Change the text color to blue (to highlight
// that this layer is *not* being exported)
m_layersList[ii]->SetForegroundColour( *wxBLUE );
}
else
{
m_layersList[ii]->SetLabel( GetPCBDefaultLayerName( jj ) );
// Change the text color to fuchsia (to highlight
// that this layer *is* being exported)
m_layersList[ii]->SetForegroundColour( wxColour( 255, 0, 128 ) );
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
// Output : int
//-----------------------------------------------------------------------------
void CBaseAnimatingOverlay::SetLayerPriority( int iLayer, int iPriority )
{
if (!IsValidLayer( iLayer ))
{
return;
}
if (m_AnimOverlay[iLayer].m_nPriority == iPriority)
{
return;
}
// look for an open slot and for existing layers that are lower priority
int i;
for (i = 0; i < m_AnimOverlay.Count(); i++)
{
if ( m_AnimOverlay[i].IsActive() )
{
if (m_AnimOverlay[i].m_nOrder > m_AnimOverlay[iLayer].m_nOrder)
{
m_AnimOverlay[i].m_nOrder--;
}
}
}
int iNewOrder = 0;
for (i = 0; i < m_AnimOverlay.Count(); i++)
{
if ( i != iLayer && m_AnimOverlay[i].IsActive() )
{
if (m_AnimOverlay[i].m_nPriority <= iPriority)
{
iNewOrder = MAX( iNewOrder, m_AnimOverlay[i].m_nOrder + 1 );
}
}
}
for (i = 0; i < m_AnimOverlay.Count(); i++)
{
if ( i != iLayer && m_AnimOverlay[i].IsActive() )
{
if ( m_AnimOverlay[i].m_nOrder >= iNewOrder)
{
m_AnimOverlay[i].m_nOrder++;
}
}
}
m_AnimOverlay[iLayer].m_nOrder = iNewOrder;
m_AnimOverlay[iLayer].m_nPriority = iPriority;
m_AnimOverlay[iLayer].MarkActive( );
VerifyOrder();
return;
}
//-----------------------------------------------------------------------------
// Purpose:
// Output : int
//-----------------------------------------------------------------------------
int CBaseAnimatingOverlay::AddGestureSequence( int sequence, bool autokill /*= true*/ )
{
int i = AddLayeredSequence( sequence, 0 );
// No room?
if ( IsValidLayer( i ) )
{
SetLayerAutokill( i, autokill );
}
return i;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CBaseAnimatingOverlay::SetLayerCycle( int iLayer, float flCycle )
{
if (!IsValidLayer( iLayer ))
return;
if (!m_AnimOverlay[iLayer].m_bLooping)
{
flCycle = clamp( flCycle, 0.0, 1.0 );
}
m_AnimOverlay[iLayer].m_flCycle = flCycle;
m_AnimOverlay[iLayer].MarkActive( );
}
float CBaseAnimatingOverlay::GetLayerDuration( int iLayer )
{
if (IsValidLayer( iLayer ))
{
if (m_AnimOverlay[iLayer].m_flPlaybackRate != 0.0f)
{
return (1.0 - m_AnimOverlay[iLayer].m_flCycle) * SequenceDuration( m_AnimOverlay[iLayer].m_nSequence ) / m_AnimOverlay[iLayer].m_flPlaybackRate;
}
return SequenceDuration( m_AnimOverlay[iLayer].m_nSequence );
}
return 0.0;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CBaseAnimatingOverlay::SetLayerAutokill( int iLayer, bool bAutokill )
{
if (!IsValidLayer( iLayer ))
return;
if (bAutokill)
{
m_AnimOverlay[iLayer].m_fFlags |= ANIM_LAYER_AUTOKILL;
}
else
{
m_AnimOverlay[iLayer].m_fFlags &= ~ANIM_LAYER_AUTOKILL;
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CBaseAnimatingOverlay::SetLayerNoEvents( int iLayer, bool bNoEvents )
{
if (!IsValidLayer( iLayer ))
return;
if (bNoEvents)
{
m_AnimOverlay[iLayer].m_fFlags |= ANIM_LAYER_NOEVENTS;
}
else
{
m_AnimOverlay[iLayer].m_fFlags &= ~ANIM_LAYER_NOEVENTS;
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CBaseAnimatingOverlay::SetLayerNoRestore( int iLayer, bool bNoRestore )
{
if (!IsValidLayer( iLayer ))
return;
if (bNoRestore)
{
m_AnimOverlay[iLayer].m_fFlags |= ANIM_LAYER_DONTRESTORE;
}
else
{
m_AnimOverlay[iLayer].m_fFlags &= ~ANIM_LAYER_DONTRESTORE;
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CBaseAnimatingOverlay::SetLayerCycle( int iLayer, float flCycle, float flPrevCycle, float flLastEventCheck )
{
if (!IsValidLayer( iLayer ))
return;
if (!m_AnimOverlay[iLayer].m_bLooping)
{
flCycle = clamp( flCycle, 0.0f, 1.0f );
flPrevCycle = clamp( flPrevCycle, 0.0f, 1.0f );
}
m_AnimOverlay[iLayer].m_flCycle = flCycle;
m_AnimOverlay[iLayer].m_flPrevCycle = flPrevCycle;
m_AnimOverlay[iLayer].m_flLastEventCheck = flLastEventCheck;
m_AnimOverlay[iLayer].MarkActive( );
}
void CBaseAnimatingOverlay::FastRemoveLayer( int iLayer )
{
if (!IsValidLayer( iLayer ))
return;
// shift the other layers down in order
for (int j = 0; j < m_AnimOverlay.Count(); j++ )
{
if ((m_AnimOverlay[ j ].IsActive()) && m_AnimOverlay[ j ].m_nOrder > m_AnimOverlay[ iLayer ].m_nOrder)
{
m_AnimOverlay[ j ].m_nOrder--;
}
}
m_AnimOverlay[ iLayer ].Init( this );
VerifyOrder();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CBaseAnimatingOverlay::RemoveLayer( int iLayer, float flKillRate, float flKillDelay )
{
if (!IsValidLayer( iLayer ))
return;
if (flKillRate > 0)
{
m_AnimOverlay[iLayer].m_flKillRate = m_AnimOverlay[iLayer].m_flWeight / flKillRate;
}
else
{
m_AnimOverlay[iLayer].m_flKillRate = 100;
}
m_AnimOverlay[iLayer].m_flKillDelay = flKillDelay;
m_AnimOverlay[iLayer].KillMe();
}
// Function name : SetLayerZOrder
// Description : set z order of the layer
// Return type : BOOL
// Argument : int nLayer
// Argument : DWORD dwZOrder : bigger is away
BOOL CVMR9Graph::SetLayerZOrder(int nLayer, DWORD dwZOrder)
{
HRESULT hr;
if (!IsValidLayer(nLayer)) {
ReportError("Can't set order, incorect layer", E_INVALIDARG);
return FALSE;
}
if (m_pVMRMixerControl == NULL) {
ReportError("Can't set order, no VMR", E_FAIL);
return FALSE;
}
hr = m_pVMRMixerControl->SetZOrder(nLayer, dwZOrder);
if (FAILED(hr)) {
ReportError("Can't set ZOrder", hr);
return FALSE;
}
return TRUE;
}
