You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
2729 lines
61 KiB
2729 lines
61 KiB
//========= Copyright Valve Corporation, All rights reserved. ============// |
|
// |
|
// Purpose: |
|
// |
|
// $NoKeywords: $ |
|
//===========================================================================// |
|
#include "client_pch.h" |
|
#include "cl_demosmootherpanel.h" |
|
#include <vgui_controls/Button.h> |
|
#include <vgui_controls/CheckButton.h> |
|
#include <vgui_controls/Label.h> |
|
|
|
#include <vgui_controls/Controls.h> |
|
#include <vgui/ISystem.h> |
|
#include <vgui/ISurface.h> |
|
#include <vgui_controls/PropertySheet.h> |
|
#include <vgui/IVGui.h> |
|
#include <vgui_controls/FileOpenDialog.h> |
|
#include <vgui_controls/ProgressBar.h> |
|
#include <vgui_controls/ListPanel.h> |
|
#include <vgui_controls/MenuButton.h> |
|
#include <vgui_controls/Menu.h> |
|
#include <vgui_controls/TextEntry.h> |
|
#include <vgui/IInput.h> |
|
|
|
#include "cl_demouipanel.h" |
|
#include "demofile/demoformat.h" |
|
#include "cl_demoactionmanager.h" |
|
#include "tier2/renderutils.h" |
|
|
|
// memdbgon must be the last include file in a .cpp file!!! |
|
#include "tier0/memdbgon.h" |
|
|
|
using namespace vgui; |
|
|
|
static float Ease_In( float t ) |
|
{ |
|
float out = sqrt( t ); |
|
return out; |
|
} |
|
|
|
static float Ease_Out( float t ) |
|
{ |
|
float out = t * t; |
|
return out; |
|
} |
|
|
|
static float Ease_Both( float t ) |
|
{ |
|
return SimpleSpline( t ); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: A menu button that knows how to parse cvar/command menu data from gamedir\scripts\debugmenu.txt |
|
//----------------------------------------------------------------------------- |
|
class CSmoothingTypeButton : public vgui::MenuButton |
|
{ |
|
typedef vgui::MenuButton BaseClass; |
|
|
|
public: |
|
// Construction |
|
CSmoothingTypeButton( vgui::Panel *parent, const char *panelName, const char *text ); |
|
|
|
private: |
|
// Menu associated with this button |
|
Menu *m_pMenu; |
|
}; |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Constructor |
|
//----------------------------------------------------------------------------- |
|
CSmoothingTypeButton::CSmoothingTypeButton(Panel *parent, const char *panelName, const char *text) |
|
: BaseClass( parent, panelName, text ) |
|
{ |
|
// Assume no menu |
|
m_pMenu = new Menu( this, "DemoSmootherTypeMenu" ); |
|
|
|
m_pMenu->AddMenuItem( "Smooth Selection Angles", "smoothselectionangles", parent ); |
|
m_pMenu->AddMenuItem( "Smooth Selection Origin", "smoothselectionorigin", parent ); |
|
m_pMenu->AddMenuItem( "Linear Interp Angles", "smoothlinearinterpolateangles", parent ); |
|
m_pMenu->AddMenuItem( "Linear Interp Origin", "smoothlinearinterpolateorigin", parent ); |
|
m_pMenu->AddMenuItem( "Spline Angles", "splineangles", parent ); |
|
m_pMenu->AddMenuItem( "Spline Origin", "splineorigin", parent ); |
|
m_pMenu->AddMenuItem( "Look At Points", "lookatpoints", parent ); |
|
m_pMenu->AddMenuItem( "Look At Points Spline", "lookatpointsspline", parent ); |
|
m_pMenu->AddMenuItem( "Two Point Origin Ease Out", "origineaseout", parent ); |
|
m_pMenu->AddMenuItem( "Two Point Origin Ease In", "origineasein", parent ); |
|
m_pMenu->AddMenuItem( "Two Point Origin Ease In/Out", "origineaseboth", parent ); |
|
m_pMenu->AddMenuItem( "Auto-setup keys 1/2 second", "keyshalf", parent ); |
|
m_pMenu->AddMenuItem( "Auto-setup keys 1 second", "keys1", parent ); |
|
m_pMenu->AddMenuItem( "Auto-setup keys 2 second", "keys2", parent ); |
|
m_pMenu->AddMenuItem( "Auto-setup keys 4 second", "keys4", parent ); |
|
|
|
m_pMenu->MakePopup(); |
|
MenuButton::SetMenu(m_pMenu); |
|
SetOpenDirection(Menu::UP); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: A menu button that knows how to parse cvar/command menu data from gamedir\scripts\debugmenu.txt |
|
//----------------------------------------------------------------------------- |
|
class CFixEdgeButton : public vgui::MenuButton |
|
{ |
|
typedef vgui::MenuButton BaseClass; |
|
|
|
public: |
|
// Construction |
|
CFixEdgeButton( vgui::Panel *parent, const char *panelName, const char *text ); |
|
|
|
private: |
|
// Menu associated with this button |
|
Menu *m_pMenu; |
|
}; |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Constructor |
|
//----------------------------------------------------------------------------- |
|
CFixEdgeButton::CFixEdgeButton(Panel *parent, const char *panelName, const char *text) |
|
: BaseClass( parent, panelName, text ) |
|
{ |
|
// Assume no menu |
|
m_pMenu = new Menu( this, "DemoSmootherEdgeFixType" ); |
|
|
|
m_pMenu->AddMenuItem( "Smooth Left", "smoothleft", parent ); |
|
m_pMenu->AddMenuItem( "Smooth Right", "smoothright", parent ); |
|
m_pMenu->AddMenuItem( "Smooth Both", "smoothboth", parent ); |
|
|
|
m_pMenu->MakePopup(); |
|
MenuButton::SetMenu(m_pMenu); |
|
SetOpenDirection(Menu::UP); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Basic help dialog |
|
//----------------------------------------------------------------------------- |
|
CDemoSmootherPanel::CDemoSmootherPanel( vgui::Panel *parent ) : Frame( parent, "DemoSmootherPanel") |
|
{ |
|
int w = 440; |
|
int h = 300; |
|
|
|
SetSize( w, h ); |
|
|
|
SetTitle("Demo Smoother", true); |
|
|
|
m_pType = new CSmoothingTypeButton( this, "DemoSmootherType", "Process->" ); |
|
|
|
m_pRevert = new vgui::Button( this, "DemoSmoothRevert", "Revert" );; |
|
m_pOK = new vgui::Button( this, "DemoSmoothOk", "OK" ); |
|
m_pCancel = new vgui::Button( this, "DemoSmoothCancel", "Cancel" ); |
|
|
|
m_pSave = new vgui::Button( this, "DemoSmoothSave", "Save" ); |
|
m_pReloadFromDisk = new vgui::Button( this, "DemoSmoothReload", "Reload" ); |
|
|
|
m_pStartFrame = new vgui::TextEntry( this, "DemoSmoothStartFrame" ); |
|
m_pEndFrame = new vgui::TextEntry( this, "DemoSmoothEndFrame" ); |
|
|
|
m_pPreviewOriginal = new vgui::Button( this, "DemoSmoothPreviewOriginal", "Show Original" ); |
|
m_pPreviewProcessed = new vgui::Button( this, "DemoSmoothPreviewProcessed", "Show Processed" ); |
|
|
|
m_pBackOff = new vgui::CheckButton( this, "DemoSmoothBackoff", "Back off" ); |
|
m_pHideLegend = new vgui::CheckButton( this, "DemoSmoothHideLegend", "Hide legend" ); |
|
|
|
m_pHideOriginal = new vgui::CheckButton( this, "DemoSmoothHideOriginal", "Hide original" ); |
|
m_pHideProcessed = new vgui::CheckButton( this, "DemoSmoothHideProcessed", "Hide processed" ); |
|
|
|
m_pSelectionInfo = new vgui::Label( this, "DemoSmoothSelectionInfo", "" ); |
|
m_pShowAllSamples = new vgui::CheckButton( this, "DemoSmoothShowAll", "Show All" ); |
|
m_pSelectSamples = new vgui::Button( this, "DemoSmoothSelect", "Select" ); |
|
|
|
m_pPauseResume = new vgui::Button( this, "DemoSmoothPauseResume", "Pause" ); |
|
m_pStepForward = new vgui::Button( this, "DemoSmoothStepForward", ">>" ); |
|
m_pStepBackward = new vgui::Button( this, "DemoSmoothStepBackward", "<<" ); |
|
|
|
m_pRevertPoint = new vgui::Button( this, "DemoSmoothRevertPoint", "Revert Pt." ); |
|
m_pToggleKeyFrame = new vgui::Button( this, "DemoSmoothSetKeyFrame", "Mark Keyframe" ); |
|
m_pToggleLookTarget = new vgui::Button( this, "DemoSmoothSetLookTarget", "Mark Look Target" ); |
|
|
|
m_pUndo = new vgui::Button( this, "DemoSmoothUndo", "Undo" ); |
|
m_pRedo = new vgui::Button( this, "DemoSmoothRedo", "Redo" ); |
|
|
|
m_pNextKey = new vgui::Button( this, "DemoSmoothNextKey", "+Key" ); |
|
m_pPrevKey = new vgui::Button( this, "DemoSmoothPrevKey", "-Key" ); |
|
|
|
m_pNextTarget = new vgui::Button( this, "DemoSmoothNextTarget", "+Target" ); |
|
m_pPrevTarget = new vgui::Button( this, "DemoSmoothPrevTarget", "-Target" ); |
|
|
|
m_pMoveCameraToPoint = new vgui::Button( this, "DemoSmoothCameraAtPoint", "Set View" ); |
|
|
|
m_pFixEdges = new CFixEdgeButton( this, "DemoSmoothFixFrameButton", "Edge->" ); |
|
m_pFixEdgeFrames = new vgui::TextEntry( this, "DemoSmoothFixFrames" ); |
|
|
|
m_pProcessKey = new vgui::Button( this, "DemoSmoothSaveKey", "Save Key" ); |
|
|
|
m_pGotoFrame = new vgui::TextEntry( this, "DemoSmoothGotoFrame" ); |
|
m_pGoto = new vgui::Button( this, "DemoSmoothGoto", "Jump To" ); |
|
|
|
//m_pCurrentDemo = new vgui::Label( this, "DemoName", "" ); |
|
|
|
vgui::ivgui()->AddTickSignal( GetVPanel(), 0 ); |
|
|
|
LoadControlSettings("Resource\\DemoSmootherPanel.res"); |
|
|
|
/* |
|
int xpos, ypos; |
|
parent->GetPos( xpos, ypos ); |
|
ypos += parent->GetTall(); |
|
|
|
SetPos( xpos, ypos ); |
|
*/ |
|
|
|
OnRefresh(); |
|
|
|
SetVisible( true ); |
|
SetSizeable( false ); |
|
SetMoveable( true ); |
|
|
|
Reset(); |
|
|
|
m_vecEyeOffset = Vector( 0, 0, 64 ); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
CDemoSmootherPanel::~CDemoSmootherPanel() |
|
{ |
|
} |
|
|
|
void CDemoSmootherPanel::Reset( void ) |
|
{ |
|
ClearSmoothingInfo( m_Smoothing ); |
|
|
|
m_bPreviewing = false; |
|
m_bPreviewPaused = false; |
|
m_bPreviewOriginal = false; |
|
m_iPreviewStartTick = 0; |
|
m_fPreviewCurrentTime = 0.0f; |
|
m_nPreviewLastFrame = 0; |
|
|
|
m_bHasSelection = false; |
|
memset( m_nSelection, 0, sizeof( m_nSelection ) ); |
|
m_iSelectionTicksSpan = 0; |
|
|
|
m_bInputActive = false; |
|
memset( m_nOldCursor, 0, sizeof( m_nOldCursor ) ); |
|
|
|
WipeUndo(); |
|
WipeRedo(); |
|
m_bRedoPending = false; |
|
m_nUndoLevel = 0; |
|
m_bDirty = false; |
|
} |
|
|
|
|
|
void CDemoSmootherPanel::OnTick() |
|
{ |
|
BaseClass::OnTick(); |
|
|
|
m_pUndo->SetEnabled( CanUndo() ); |
|
m_pRedo->SetEnabled( CanRedo() ); |
|
|
|
m_pPauseResume->SetEnabled( m_bPreviewing ); |
|
m_pStepForward->SetEnabled( m_bPreviewing ); |
|
m_pStepBackward->SetEnabled( m_bPreviewing ); |
|
|
|
m_pSave->SetEnabled( m_bDirty ); |
|
|
|
demosmoothing_t *p = GetCurrent(); |
|
if ( p ) |
|
{ |
|
m_pToggleKeyFrame->SetEnabled( true ); |
|
m_pToggleLookTarget->SetEnabled( true ); |
|
|
|
m_pToggleKeyFrame->SetText( p->samplepoint ? "Delete Key" : "Make Key" ); |
|
m_pToggleLookTarget->SetText( p->targetpoint ? "Delete Target" : "Make Target" ); |
|
|
|
m_pProcessKey->SetEnabled( p->samplepoint ); |
|
} |
|
else |
|
{ |
|
m_pToggleKeyFrame->SetEnabled( false ); |
|
m_pToggleLookTarget->SetEnabled( false ); |
|
|
|
m_pProcessKey->SetEnabled( false ); |
|
} |
|
|
|
if ( m_bPreviewing ) |
|
{ |
|
m_pPauseResume->SetText( m_bPreviewPaused ? "Resume" : "Pause" ); |
|
} |
|
|
|
if ( !m_Smoothing.active ) |
|
{ |
|
m_pSelectionInfo->SetText( "No smoothing info loaded" ); |
|
return; |
|
} |
|
|
|
if ( !demoplayer->IsPlayingBack() ) |
|
{ |
|
m_pSelectionInfo->SetText( "Not playing back .dem" ); |
|
return; |
|
} |
|
|
|
if ( !m_bHasSelection ) |
|
{ |
|
m_pSelectionInfo->SetText( "No selection." ); |
|
return; |
|
} |
|
|
|
char sz[ 512 ]; |
|
if ( m_bPreviewing ) |
|
{ |
|
Q_snprintf( sz, sizeof( sz ), "%.3f at tick %i (%.3f s)", |
|
m_fPreviewCurrentTime, |
|
GetTickForFrame( m_nPreviewLastFrame ), |
|
TICKS_TO_TIME( m_iSelectionTicksSpan ) ); |
|
} |
|
else |
|
{ |
|
Q_snprintf( sz, sizeof( sz ), "%i to %i (%.3f s)", |
|
m_Smoothing.smooth[ m_nSelection[ 0 ] ].frametick, |
|
m_Smoothing.smooth[ m_nSelection[ 1 ] ].frametick, |
|
TICKS_TO_TIME( m_iSelectionTicksSpan ) ); |
|
} |
|
m_pSelectionInfo->SetText( sz ); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
// Output : Returns true on success, false on failure. |
|
//----------------------------------------------------------------------------- |
|
bool CDemoSmootherPanel::CanEdit() |
|
{ |
|
if ( !m_Smoothing.active ) |
|
return false; |
|
|
|
if ( !demoplayer->IsPlayingBack() ) |
|
return false; |
|
|
|
return true; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
// Input : *command - |
|
//----------------------------------------------------------------------------- |
|
void CDemoSmootherPanel::OnCommand(const char *command) |
|
{ |
|
if ( !Q_strcasecmp( command, "cancel" ) ) |
|
{ |
|
OnRevert(); |
|
MarkForDeletion(); |
|
Reset(); |
|
OnClose(); |
|
} |
|
else if ( !Q_strcasecmp( command, "close" ) ) |
|
{ |
|
OnSave(); |
|
MarkForDeletion(); |
|
Reset(); |
|
OnClose(); |
|
} |
|
else if ( !Q_strcasecmp( command, "gotoframe" ) ) |
|
{ |
|
OnGotoFrame(); |
|
} |
|
else if ( !Q_strcasecmp( command, "undo" ) ) |
|
{ |
|
Undo(); |
|
} |
|
else if ( !Q_strcasecmp( command, "redo" ) ) |
|
{ |
|
Redo(); |
|
} |
|
else if ( !Q_strcasecmp( command, "revert" ) ) |
|
{ |
|
OnRevert(); |
|
} |
|
else if ( !Q_strcasecmp( command, "original" ) ) |
|
{ |
|
OnPreview( true ); |
|
} |
|
else if ( !Q_strcasecmp( command, "processed" ) ) |
|
{ |
|
OnPreview( false ); |
|
} |
|
else if ( !Q_strcasecmp( command, "save" ) ) |
|
{ |
|
OnSave(); |
|
} |
|
else if ( !Q_strcasecmp( command, "reload" ) ) |
|
{ |
|
OnReload(); |
|
} |
|
else if ( !Q_strcasecmp( command, "select" ) ) |
|
{ |
|
OnSelect(); |
|
} |
|
else if ( !Q_strcasecmp( command, "togglepause" ) ) |
|
{ |
|
OnTogglePause(); |
|
} |
|
else if ( !Q_strcasecmp( command, "stepforward" ) ) |
|
{ |
|
OnStep( true ); |
|
} |
|
else if ( !Q_strcasecmp( command, "stepbackward" ) ) |
|
{ |
|
OnStep( false ); |
|
} |
|
else if ( !Q_strcasecmp( command, "revertpoint" ) ) |
|
{ |
|
OnRevertPoint(); |
|
} |
|
else if ( !Q_strcasecmp( command, "keyframe" ) ) |
|
{ |
|
OnToggleKeyFrame(); |
|
} |
|
else if ( !Q_strcasecmp( command, "looktarget" ) ) |
|
{ |
|
OnToggleLookTarget(); |
|
} |
|
else if ( !Q_strcasecmp( command, "nextkey" ) ) |
|
{ |
|
OnNextKey(); |
|
} |
|
else if ( !Q_strcasecmp( command, "prevkey" ) ) |
|
{ |
|
OnPrevKey(); |
|
} |
|
else if ( !Q_strcasecmp( command, "nexttarget" ) ) |
|
{ |
|
OnNextTarget(); |
|
} |
|
else if ( !Q_strcasecmp( command, "prevtarget" ) ) |
|
{ |
|
OnPrevTarget(); |
|
} |
|
else if ( !Q_strcasecmp( command, "smoothselectionangles" ) ) |
|
{ |
|
OnSmoothSelectionAngles(); |
|
} |
|
else if ( !Q_strcasecmp( command, "keyshalf" ) ) |
|
{ |
|
OnSetKeys( 0.5f ); |
|
} |
|
else if ( !Q_strcasecmp( command, "keys1" ) ) |
|
{ |
|
OnSetKeys( 1.0f ); |
|
} |
|
else if ( !Q_strcasecmp( command, "keys2" ) ) |
|
{ |
|
OnSetKeys( 2.0f ); |
|
} |
|
else if ( !Q_strcasecmp( command, "keys4" ) ) |
|
{ |
|
OnSetKeys( 4.0f ); |
|
} |
|
else if ( !Q_strcasecmp( command, "smoothselectionorigin" ) ) |
|
{ |
|
OnSmoothSelectionOrigin(); |
|
} |
|
else if ( !Q_strcasecmp( command, "smoothlinearinterpolateangles" ) ) |
|
{ |
|
OnLinearInterpolateAnglesBasedOnEndpoints(); |
|
} |
|
else if ( !Q_strcasecmp( command, "smoothlinearinterpolateorigin" ) ) |
|
{ |
|
OnLinearInterpolateOriginBasedOnEndpoints(); |
|
} |
|
else if ( !Q_strcasecmp( command, "splineorigin" ) ) |
|
{ |
|
OnSplineSampleOrigin(); |
|
} |
|
else if ( !Q_strcasecmp( command, "splineangles" ) ) |
|
{ |
|
OnSplineSampleAngles(); |
|
} |
|
else if ( !Q_strcasecmp( command, "lookatpoints" ) ) |
|
{ |
|
OnLookAtPoints( false ); |
|
} |
|
else if ( !Q_strcasecmp( command, "lookatpointsspline" ) ) |
|
{ |
|
OnLookAtPoints( true ); |
|
} |
|
else if ( !Q_strcasecmp( command, "smoothleft" ) ) |
|
{ |
|
OnSmoothEdges( true, false ); |
|
} |
|
else if ( !Q_strcasecmp( command, "smoothright" ) ) |
|
{ |
|
OnSmoothEdges( false, true ); |
|
} |
|
else if ( !Q_strcasecmp( command, "smoothboth" ) ) |
|
{ |
|
OnSmoothEdges( true, true ); |
|
} |
|
else if ( !Q_strcasecmp( command, "origineasein" ) ) |
|
{ |
|
OnOriginEaseCurve( Ease_In ); |
|
} |
|
else if ( !Q_strcasecmp( command, "origineaseout" ) ) |
|
{ |
|
OnOriginEaseCurve( Ease_Out ); |
|
} |
|
else if ( !Q_strcasecmp( command, "origineaseboth" ) ) |
|
{ |
|
OnOriginEaseCurve( Ease_Both ); |
|
} |
|
else if ( !Q_strcasecmp( command, "processkey" ) ) |
|
{ |
|
OnSaveKey(); |
|
} |
|
else if ( !Q_strcasecmp( command, "setview" ) ) |
|
{ |
|
OnSetView(); |
|
} |
|
else |
|
{ |
|
BaseClass::OnCommand( command ); |
|
} |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CDemoSmootherPanel::OnSave() |
|
{ |
|
if ( !m_Smoothing.active ) |
|
return; |
|
|
|
SaveSmoothingInfo( demoaction->GetCurrentDemoFile(), m_Smoothing ); |
|
WipeUndo(); |
|
m_bDirty = false; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CDemoSmootherPanel::OnReload() |
|
{ |
|
WipeUndo(); |
|
WipeRedo(); |
|
LoadSmoothingInfo( demoaction->GetCurrentDemoFile(), m_Smoothing ); |
|
m_bDirty = false; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CDemoSmootherPanel::OnVDMChanged( void ) |
|
{ |
|
if ( IsVisible() ) |
|
{ |
|
OnReload(); |
|
} |
|
else |
|
{ |
|
Reset(); |
|
} |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CDemoSmootherPanel::OnRevert() |
|
{ |
|
OnRefresh(); |
|
if ( !m_Smoothing.active ) |
|
{ |
|
LoadSmoothingInfo( demoaction->GetCurrentDemoFile(), m_Smoothing ); |
|
WipeUndo(); |
|
WipeRedo(); |
|
} |
|
else |
|
{ |
|
ClearSmoothingInfo( m_Smoothing ); |
|
WipeUndo(); |
|
WipeRedo(); |
|
} |
|
|
|
m_bDirty = false; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CDemoSmootherPanel::OnRefresh() |
|
{ |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
// Input : *pScheme - |
|
//----------------------------------------------------------------------------- |
|
void CDemoSmootherPanel::ApplySchemeSettings( vgui::IScheme *pScheme ) |
|
{ |
|
BaseClass::ApplySchemeSettings( pScheme ); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
// Output : int |
|
//----------------------------------------------------------------------------- |
|
int CDemoSmootherPanel::GetStartFrame() |
|
{ |
|
char text[ 32 ]; |
|
m_pStartFrame->GetText( text, sizeof( text ) ); |
|
int tick = atoi( text ); |
|
return GetFrameForTick( tick ); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
// Output : int |
|
//----------------------------------------------------------------------------- |
|
int CDemoSmootherPanel::GetEndFrame() |
|
{ |
|
char text[ 32 ]; |
|
m_pEndFrame->GetText( text, sizeof( text ) ); |
|
int tick = atoi( text ); |
|
return GetFrameForTick( tick ); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
// Input : original - |
|
//----------------------------------------------------------------------------- |
|
void CDemoSmootherPanel::OnPreview( bool original ) |
|
{ |
|
if ( !CanEdit() ) |
|
return; |
|
|
|
if ( !m_bHasSelection ) |
|
{ |
|
ConMsg( "Must have smoothing selection active\n" ); |
|
return; |
|
} |
|
|
|
m_bPreviewing = true; |
|
m_bPreviewPaused = false; |
|
m_bPreviewOriginal = original; |
|
SetLastFrame( false, max( 0, m_nSelection[0] - 10 ) ); |
|
m_iPreviewStartTick = GetTickForFrame( m_nPreviewLastFrame ); |
|
m_fPreviewCurrentTime = TICKS_TO_TIME( m_iPreviewStartTick ); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
// Input : frame - |
|
// elapsed - |
|
// info - |
|
// Output : Returns true on success, false on failure. |
|
//----------------------------------------------------------------------------- |
|
bool CDemoSmootherPanel::OverrideView( democmdinfo_t& info, int tick ) |
|
{ |
|
if ( !CanEdit() ) |
|
return false; |
|
|
|
if ( !demoplayer->IsPlaybackPaused() ) |
|
return false; |
|
|
|
if ( m_bPreviewing ) |
|
{ |
|
if ( m_bPreviewPaused && GetCurrent() && GetCurrent()->samplepoint ) |
|
{ |
|
info.viewOrigin = GetCurrent()->vecmoved; |
|
info.viewAngles = GetCurrent()->angmoved; |
|
info.localViewAngles = info.viewAngles; |
|
|
|
bool back_off = m_pBackOff->IsSelected(); |
|
if ( back_off ) |
|
{ |
|
Vector fwd; |
|
AngleVectors( info.viewAngles, &fwd, NULL, NULL ); |
|
|
|
info.viewOrigin -= fwd * 75.0f; |
|
} |
|
|
|
return true; |
|
} |
|
|
|
// TODO: Hook up previewing view |
|
if ( !m_bPreviewPaused ) |
|
{ |
|
m_fPreviewCurrentTime += host_frametime; |
|
} |
|
|
|
if ( GetInterpolatedViewPoint( info.viewOrigin, info.viewAngles ) ) |
|
{ |
|
info.localViewAngles = info.viewAngles; |
|
return true; |
|
} |
|
else |
|
{ |
|
return false; |
|
} |
|
} |
|
|
|
bool back_off = m_pBackOff->IsSelected(); |
|
if ( back_off ) |
|
{ |
|
int useframe = GetFrameForTick( tick ); |
|
|
|
if ( useframe < m_Smoothing.smooth.Count() && useframe >= 0 ) |
|
{ |
|
demosmoothing_t *p = &m_Smoothing.smooth[ useframe ]; |
|
Vector fwd; |
|
AngleVectors( p->info.viewAngles, &fwd, NULL, NULL ); |
|
|
|
info.viewOrigin = p->info.viewOrigin - fwd * 75.0f; |
|
} |
|
} |
|
|
|
return false; |
|
} |
|
|
|
void DrawVecForward( bool active, const Vector& origin, const QAngle& angles, int r, int g, int b ) |
|
{ |
|
Vector fwd; |
|
AngleVectors( angles, &fwd, NULL, NULL ); |
|
|
|
Vector end; |
|
end = origin + fwd * ( active ? 64 : 16 ); |
|
|
|
RenderLine( origin, end, Color( r, g, b, 255 ), true ); |
|
} |
|
|
|
void GetColorForSample( bool original, bool samplepoint, bool targetpoint, demosmoothing_t *sample, int& r, int& g, int& b ) |
|
{ |
|
if ( samplepoint && sample->samplepoint ) |
|
{ |
|
r = 0; |
|
g = 255; |
|
b = 0; |
|
return; |
|
} |
|
|
|
if ( targetpoint && sample->targetpoint ) |
|
{ |
|
r = 255; |
|
g = 0; |
|
b = 0; |
|
return; |
|
} |
|
|
|
if ( sample->selected ) |
|
{ |
|
if( original ) |
|
{ |
|
r = 255; |
|
g = 200; |
|
b = 100; |
|
} |
|
else |
|
{ |
|
r = 200; |
|
g = 100; |
|
b = 255; |
|
} |
|
|
|
if ( sample->samplepoint || sample->targetpoint ) |
|
{ |
|
r = 255; |
|
g = 255; |
|
b = 0; |
|
} |
|
|
|
return; |
|
} |
|
|
|
if ( original ) |
|
{ |
|
r = g = b = 255; |
|
} |
|
else |
|
{ |
|
r = 150; |
|
g = 255; |
|
b = 100; |
|
} |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
// Input : origin - |
|
// mins - |
|
// maxs - |
|
// angles - |
|
// r - |
|
// g - |
|
// b - |
|
// a - |
|
//----------------------------------------------------------------------------- |
|
void Draw_Box( const Vector& origin, const Vector& mins, const Vector& maxs, const QAngle& angles, int r, int g, int b, int a ) |
|
{ |
|
RenderBox( origin, angles, mins, maxs, Color( r, g, b, a ), false ); |
|
RenderWireframeBox( origin, angles, mins, maxs, Color( r, g, b, a ), true ); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
// Input : *sample - |
|
// *next - |
|
//----------------------------------------------------------------------------- |
|
void CDemoSmootherPanel::DrawSmoothingSample( bool original, bool processed, int samplenumber, demosmoothing_t *sample, demosmoothing_t *next ) |
|
{ |
|
int r, g, b; |
|
|
|
if ( original ) |
|
{ |
|
RenderLine( sample->info.viewOrigin + m_vecEyeOffset, next->info.viewOrigin + m_vecEyeOffset, |
|
Color( 180, 180, 180, 255 ), true ); |
|
|
|
GetColorForSample( true, false, false, sample, r, g, b ); |
|
|
|
DrawVecForward( false, sample->info.viewOrigin + m_vecEyeOffset, sample->info.viewAngles, r, g, b ); |
|
} |
|
|
|
if ( processed && sample->info.flags != 0 ) |
|
{ |
|
RenderLine( sample->info.GetViewOrigin() + m_vecEyeOffset, next->info.GetViewOrigin() + m_vecEyeOffset, |
|
Color( 255, 255, 180, 255 ), true ); |
|
|
|
GetColorForSample( false, false, false, sample, r, g, b ); |
|
|
|
DrawVecForward( false, sample->info.GetViewOrigin() + m_vecEyeOffset, sample->info.GetViewAngles(), r, g, b ); |
|
} |
|
if ( sample->samplepoint ) |
|
{ |
|
GetColorForSample( false, true, false, sample, r, g, b ); |
|
RenderBox( sample->vecmoved + m_vecEyeOffset, sample->angmoved, Vector( -2, -2, -2 ), Vector( 2, 2, 2 ), Color( r, g, b, 127 ), false ); |
|
DrawVecForward( false, sample->vecmoved + m_vecEyeOffset, sample->angmoved, r, g, b ); |
|
} |
|
|
|
if ( sample->targetpoint ) |
|
{ |
|
GetColorForSample( false, false, true, sample, r, g, b ); |
|
RenderBox( sample->vectarget, vec3_angle, Vector( -2, -2, -2 ), Vector( 2, 2, 2 ), Color( r, g, b, 127 ), false ); |
|
} |
|
|
|
if ( samplenumber == m_nPreviewLastFrame + 1 ) |
|
{ |
|
r = 50; |
|
g = 100; |
|
b = 250; |
|
RenderBox( sample->info.GetViewOrigin() + m_vecEyeOffset, sample->info.GetViewAngles(), Vector( -2, -2, -2 ), Vector( 2, 2, 2 ), Color( r, g, b, 92 ), false ); |
|
} |
|
|
|
if ( sample->targetpoint ) |
|
{ |
|
r = 200; |
|
g = 200; |
|
b = 220; |
|
|
|
RenderLine( sample->info.GetViewOrigin() + m_vecEyeOffset, sample->vectarget, Color( r, g, b, 255 ), true ); |
|
} |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CDemoSmootherPanel::DrawDebuggingInfo( int frame, float elapsed ) |
|
{ |
|
if ( !CanEdit() ) |
|
return; |
|
|
|
if ( !IsVisible() ) |
|
return; |
|
|
|
int c = m_Smoothing.smooth.Count(); |
|
if ( c < 2 ) |
|
return; |
|
|
|
int start = 0; |
|
int end = c - 1; |
|
|
|
bool showall = m_pShowAllSamples->IsSelected(); |
|
if ( !showall ) |
|
{ |
|
start = max( frame - 200, 0 ); |
|
end = min( frame + 200, c - 1 ); |
|
} |
|
|
|
if ( m_bHasSelection && !showall ) |
|
{ |
|
start = max( m_nSelection[ 0 ] - 10, 0 ); |
|
end = min( m_nSelection[ 1 ] + 10, c - 1 ); |
|
} |
|
|
|
bool draworiginal = !m_pHideOriginal->IsSelected(); |
|
bool drawprocessed = !m_pHideProcessed->IsSelected(); |
|
int i; |
|
|
|
demosmoothing_t *p = NULL; |
|
demosmoothing_t *prev = NULL; |
|
for ( i = start; i < end; i++ ) |
|
{ |
|
p = &m_Smoothing.smooth[ i ]; |
|
if ( prev && p ) |
|
{ |
|
DrawSmoothingSample( draworiginal, drawprocessed, i, prev, p ); |
|
} |
|
prev = p; |
|
} |
|
|
|
Vector org; |
|
QAngle ang; |
|
|
|
if ( m_bPreviewing ) |
|
{ |
|
if ( GetInterpolatedOriginAndAngles( true, org, ang ) ) |
|
{ |
|
DrawVecForward( true, org + m_vecEyeOffset, ang, 200, 10, 50 ); |
|
} |
|
} |
|
|
|
int useframe = frame; |
|
|
|
useframe = clamp( useframe, 0, c - 1 ); |
|
if ( useframe < c ) |
|
{ |
|
p = &m_Smoothing.smooth[ useframe ]; |
|
org = p->info.GetViewOrigin(); |
|
ang = p->info.GetViewAngles(); |
|
|
|
DrawVecForward( true, org + m_vecEyeOffset, ang, 100, 220, 250 ); |
|
Draw_Box( org + m_vecEyeOffset, Vector( -1, -1, -1 ), Vector( 1, 1, 1 ), ang, 100, 220, 250, 127 ); |
|
} |
|
|
|
DrawKeySpline(); |
|
DrawTargetSpline(); |
|
|
|
|
|
if ( !m_pHideLegend->IsSelected() ) |
|
{ |
|
DrawLegend( start, end ); |
|
} |
|
} |
|
|
|
void CDemoSmootherPanel::OnSelect() |
|
{ |
|
if ( !CanEdit() ) |
|
return; |
|
|
|
m_bHasSelection = false; |
|
m_iSelectionTicksSpan = 0; |
|
memset( m_nSelection, 0, sizeof( m_nSelection ) ); |
|
|
|
int start, end; |
|
start = GetStartFrame(); |
|
end = GetEndFrame(); |
|
|
|
int c = m_Smoothing.smooth.Count(); |
|
if ( c < 2 ) |
|
return; |
|
|
|
start = clamp( start, 0, c - 1 ); |
|
end = clamp( end, 0, c - 1 ); |
|
|
|
if ( start >= end ) |
|
return; |
|
|
|
m_nSelection[ 0 ] = start; |
|
m_nSelection[ 1 ] = end; |
|
m_bHasSelection = true; |
|
|
|
demosmoothing_t *startsample = &m_Smoothing.smooth[ start ]; |
|
demosmoothing_t *endsample = &m_Smoothing.smooth[ end ]; |
|
|
|
m_bDirty = true; |
|
PushUndo( "select" ); |
|
|
|
int i = 0; |
|
for ( i = 0; i < c; i++ ) |
|
{ |
|
if ( i >= start && i <= end ) |
|
{ |
|
m_Smoothing.smooth[ i ].selected = true; |
|
} |
|
else |
|
{ |
|
m_Smoothing.smooth[ i ].selected = false; |
|
} |
|
} |
|
|
|
PushRedo( "select" ); |
|
|
|
m_iSelectionTicksSpan = endsample->frametick - startsample->frametick; |
|
} |
|
|
|
int CDemoSmootherPanel::GetFrameForTick( int tick ) |
|
{ |
|
int count = m_Smoothing.smooth.Count(); |
|
int last = count - 1; |
|
int first = m_Smoothing.m_nFirstSelectableSample; |
|
|
|
if ( first > last ) |
|
return -1; |
|
|
|
if ( count <= 0 ) |
|
{ |
|
return -1; // no valid index |
|
} |
|
else if ( count == 1 ) |
|
{ |
|
return 0; // return the one and only frame we have |
|
} |
|
|
|
if ( tick <= m_Smoothing.smooth[ first ].frametick ) |
|
return first; |
|
|
|
if ( tick >= m_Smoothing.smooth[ last ].frametick ) |
|
return last; |
|
|
|
// binary search |
|
int middle; |
|
|
|
while ( true ) |
|
{ |
|
middle = (first+last)/2; |
|
|
|
int middleTick = m_Smoothing.smooth[ middle ].frametick; |
|
|
|
if ( tick == middleTick ) |
|
return middle; |
|
|
|
if ( tick > middleTick ) |
|
{ |
|
if ( first == middle ) |
|
return first; |
|
|
|
first = middle; |
|
} |
|
else |
|
{ |
|
if ( last == middle ) |
|
return last; |
|
|
|
last = middle; |
|
} |
|
} |
|
|
|
|
|
} |
|
|
|
|
|
int CDemoSmootherPanel::GetTickForFrame( int frame ) |
|
{ |
|
if ( !CanEdit() ) |
|
return -1; |
|
|
|
int c = m_Smoothing.smooth.Count(); |
|
if ( c < 1 ) |
|
return -1; |
|
|
|
if ( frame < 0 ) |
|
return m_Smoothing.smooth[ 0 ].frametick; |
|
|
|
if ( frame >= c ) |
|
return m_Smoothing.smooth[ c - 1 ].frametick; |
|
|
|
|
|
return m_Smoothing.smooth[ frame ].frametick; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Interpolate Euler angles using quaternions to avoid singularities |
|
// Input : start - |
|
// end - |
|
// output - |
|
// frac - |
|
//----------------------------------------------------------------------------- |
|
static void InterpolateAngles( const QAngle& start, const QAngle& end, QAngle& output, float frac ) |
|
{ |
|
Quaternion src, dest; |
|
|
|
// Convert to quaternions |
|
AngleQuaternion( start, src ); |
|
AngleQuaternion( end, dest ); |
|
|
|
Quaternion result; |
|
|
|
// Slerp |
|
QuaternionSlerp( src, dest, frac, result ); |
|
|
|
// Convert to euler |
|
QuaternionAngles( result, output ); |
|
} |
|
|
|
bool CDemoSmootherPanel::GetInterpolatedOriginAndAngles( bool readonly, Vector& origin, QAngle& angles ) |
|
{ |
|
origin.Init(); |
|
angles.Init(); |
|
|
|
Assert( m_bPreviewing ); |
|
|
|
// Figure out the best samples |
|
int startframe = m_nPreviewLastFrame; |
|
int nextframe = startframe + 1; |
|
|
|
float time = m_fPreviewCurrentTime; |
|
|
|
int c = m_Smoothing.smooth.Count(); |
|
|
|
do |
|
{ |
|
if ( startframe >= c || nextframe >= c ) |
|
{ |
|
if ( !readonly ) |
|
{ |
|
//m_bPreviewing = false; |
|
} |
|
return false; |
|
} |
|
|
|
demosmoothing_t *startsample = &m_Smoothing.smooth[ startframe ]; |
|
demosmoothing_t *endsample = &m_Smoothing.smooth[ nextframe ]; |
|
|
|
if ( nextframe >= min( m_nSelection[1] + 10, c - 1 ) ) |
|
{ |
|
if ( !readonly ) |
|
{ |
|
OnPreview( m_bPreviewOriginal ); |
|
} |
|
return false; |
|
} |
|
|
|
// If large dt, then jump ahead quickly in time |
|
float dt = TICKS_TO_TIME( endsample->frametick - startsample->frametick ); |
|
if ( dt > 1.0f ) |
|
{ |
|
startframe++; |
|
nextframe++; |
|
continue; |
|
} |
|
|
|
if ( TICKS_TO_TIME( endsample->frametick ) >= time ) |
|
{ |
|
// Found a spot |
|
dt = TICKS_TO_TIME( endsample->frametick - startsample->frametick ); |
|
// Should never occur!!! |
|
if ( dt <= 0.0f ) |
|
{ |
|
return false; |
|
} |
|
|
|
float frac = (float)( time - TICKS_TO_TIME(startsample->frametick) ) / dt; |
|
|
|
frac = clamp( frac, 0.0f, 1.0f ); |
|
|
|
// Compute render origin/angles |
|
Vector renderOrigin; |
|
QAngle renderAngles; |
|
|
|
if ( m_bPreviewOriginal ) |
|
{ |
|
VectorLerp( startsample->info.viewOrigin, endsample->info.viewOrigin, frac, renderOrigin ); |
|
InterpolateAngles( startsample->info.viewAngles, endsample->info.viewAngles, renderAngles, frac ); |
|
} |
|
else |
|
{ |
|
VectorLerp( startsample->info.GetViewOrigin(), endsample->info.GetViewOrigin(), frac, renderOrigin ); |
|
InterpolateAngles( startsample->info.GetViewAngles(), endsample->info.GetViewAngles(), renderAngles, frac ); |
|
} |
|
|
|
origin = renderOrigin; |
|
angles = renderAngles; |
|
|
|
if ( !readonly ) |
|
{ |
|
SetLastFrame( false, startframe ); |
|
} |
|
|
|
break; |
|
} |
|
|
|
startframe++; |
|
nextframe++; |
|
|
|
} while ( true ); |
|
|
|
return true; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
// Input : t - |
|
//----------------------------------------------------------------------------- |
|
bool CDemoSmootherPanel::GetInterpolatedViewPoint( Vector& origin, QAngle& angles ) |
|
{ |
|
Assert( m_bPreviewing ); |
|
|
|
if ( !GetInterpolatedOriginAndAngles( false, origin, angles ) ) |
|
return false; |
|
|
|
bool back_off = m_pBackOff->IsSelected(); |
|
if ( back_off ) |
|
{ |
|
Vector fwd; |
|
AngleVectors( angles, &fwd, NULL, NULL ); |
|
|
|
origin = origin - fwd * 75.0f; |
|
} |
|
|
|
return true; |
|
} |
|
|
|
void CDemoSmootherPanel::OnTogglePause() |
|
{ |
|
if ( !m_bPreviewing ) |
|
return; |
|
|
|
m_bPreviewPaused = !m_bPreviewPaused; |
|
} |
|
|
|
void CDemoSmootherPanel::OnStep( bool forward ) |
|
{ |
|
if ( !m_bPreviewing ) |
|
return; |
|
|
|
if ( !m_bPreviewPaused ) |
|
return; |
|
|
|
int c = m_Smoothing.smooth.Count(); |
|
|
|
SetLastFrame( false, m_nPreviewLastFrame + ( forward ? 1 : -1 ) ); |
|
SetLastFrame( false, clamp( m_nPreviewLastFrame, max( m_nSelection[ 0 ] - 10, 0 ), min( m_nSelection[ 1 ] + 10, c - 1 ) ) ); |
|
m_fPreviewCurrentTime = TICKS_TO_TIME( GetTickForFrame( m_nPreviewLastFrame ) ); |
|
} |
|
|
|
void CDemoSmootherPanel::DrawLegend( int startframe, int endframe ) |
|
{ |
|
int i; |
|
int skip = 20; |
|
|
|
bool back_off = m_pBackOff->IsSelected(); |
|
|
|
for ( i = startframe; i <= endframe; i++ ) |
|
{ |
|
bool show = ( i % skip ) == 0; |
|
demosmoothing_t *sample = &m_Smoothing.smooth[ i ]; |
|
|
|
if ( sample->samplepoint || sample->targetpoint ) |
|
show = true; |
|
|
|
if ( !show ) |
|
continue; |
|
|
|
char sz[ 512 ]; |
|
Q_snprintf( sz, sizeof( sz ), "%.3f", TICKS_TO_TIME(sample->frametick) ); |
|
|
|
Vector fwd; |
|
AngleVectors( sample->info.GetViewAngles(), &fwd, NULL, NULL ); |
|
|
|
CDebugOverlay::AddTextOverlay( sample->info.GetViewOrigin() + m_vecEyeOffset + fwd * ( back_off ? 5.0f : 50.0f ), 0, -1.0f, sz ); |
|
} |
|
} |
|
|
|
#define EASE_TIME 0.2f |
|
|
|
Quaternion SmoothAngles( CUtlVector< Quaternion >& stack ) |
|
{ |
|
int c = stack.Count(); |
|
Assert( c >= 1 ); |
|
|
|
float weight = 1.0f / (float)c; |
|
|
|
Quaternion output; |
|
output.Init(); |
|
|
|
int i; |
|
for ( i = 0; i < c; i++ ) |
|
{ |
|
Quaternion t = stack[ i ]; |
|
QuaternionBlend( output, t, weight, output ); |
|
} |
|
|
|
return output; |
|
} |
|
|
|
Vector SmoothOrigin( CUtlVector< Vector >& stack ) |
|
{ |
|
int c = stack.Count(); |
|
Assert( c >= 1 ); |
|
|
|
Vector output; |
|
output.Init(); |
|
|
|
int i; |
|
for ( i = 0; i < c; i++ ) |
|
{ |
|
Vector t = stack[ i ]; |
|
VectorAdd( output, t, output ); |
|
} |
|
|
|
VectorScale( output, 1.0f / (float)c, output ); |
|
|
|
return output; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CDemoSmootherPanel::OnSetKeys(float interval) |
|
{ |
|
if ( !m_bHasSelection ) |
|
return; |
|
|
|
m_bDirty = true; |
|
PushUndo( "OnSetKeys" ); |
|
|
|
int c = m_Smoothing.smooth.Count(); |
|
int i; |
|
|
|
demosmoothing_t *lastkey = NULL; |
|
|
|
for ( i = 0; i < c; i++ ) |
|
{ |
|
demosmoothing_t *p = &m_Smoothing.smooth[ i ]; |
|
if ( !p->selected ) |
|
continue; |
|
|
|
p->angmoved = p->info.GetViewAngles();; |
|
p->vecmoved = p->info.GetViewOrigin(); |
|
p->samplepoint = false; |
|
|
|
if ( !lastkey || |
|
TICKS_TO_TIME( p->frametick - lastkey->frametick ) >= interval ) |
|
{ |
|
lastkey = p; |
|
p->samplepoint = true; |
|
} |
|
} |
|
|
|
PushRedo( "OnSetKeys" ); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CDemoSmootherPanel::OnSmoothSelectionAngles( void ) |
|
{ |
|
if ( !m_bHasSelection ) |
|
return; |
|
|
|
int c = m_Smoothing.smooth.Count(); |
|
int i; |
|
|
|
CUtlVector< Quaternion > stack; |
|
|
|
m_bDirty = true; |
|
PushUndo( "smooth angles" ); |
|
|
|
for ( i = 0; i < c; i++ ) |
|
{ |
|
demosmoothing_t *p = &m_Smoothing.smooth[ i ]; |
|
if ( !p->selected ) |
|
continue; |
|
|
|
while ( stack.Count() > 10 ) |
|
{ |
|
stack.Remove( 0 ); |
|
} |
|
|
|
Quaternion q; |
|
AngleQuaternion( p->info.GetViewAngles(), q ); |
|
stack.AddToTail( q ); |
|
|
|
p->info.flags |= FDEMO_USE_ANGLES2; |
|
|
|
Quaternion aveq = SmoothAngles( stack ); |
|
|
|
QAngle outangles; |
|
QuaternionAngles( aveq, outangles ); |
|
|
|
p->info.viewAngles2 = outangles; |
|
p->info.localViewAngles2 = outangles; |
|
} |
|
|
|
PushRedo( "smooth angles" ); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CDemoSmootherPanel::OnSmoothSelectionOrigin( void ) |
|
{ |
|
if ( !m_bHasSelection ) |
|
return; |
|
|
|
int c = m_Smoothing.smooth.Count(); |
|
int i; |
|
|
|
CUtlVector< Vector > stack; |
|
|
|
m_bDirty = true; |
|
PushUndo( "smooth origin" ); |
|
|
|
for ( i = 0; i < c; i++ ) |
|
{ |
|
demosmoothing_t *p = &m_Smoothing.smooth[ i ]; |
|
if ( !p->selected ) |
|
continue; |
|
|
|
if ( i < 2 ) |
|
continue; |
|
|
|
if ( i >= c - 2 ) |
|
continue; |
|
|
|
stack.RemoveAll(); |
|
|
|
for ( int j = -2; j <= 2; j++ ) |
|
{ |
|
stack.AddToTail( m_Smoothing.smooth[ i + j ].info.GetViewOrigin() ); |
|
} |
|
|
|
p->info.flags |= FDEMO_USE_ORIGIN2; |
|
|
|
Vector org = SmoothOrigin( stack ); |
|
|
|
p->info.viewOrigin2 = org; |
|
} |
|
|
|
PushRedo( "smooth origin" ); |
|
} |
|
|
|
void CDemoSmootherPanel::PerformLinearInterpolatedAngleSmoothing( int startframe, int endframe ) |
|
{ |
|
demosmoothing_t *pstart = &m_Smoothing.smooth[ startframe ]; |
|
demosmoothing_t *pend = &m_Smoothing.smooth[ endframe ]; |
|
|
|
int dt = pend->frametick - pstart->frametick; |
|
if ( dt <= 0 ) |
|
{ |
|
dt = 1; |
|
} |
|
|
|
CUtlVector< Quaternion > stack; |
|
|
|
Quaternion qstart, qend; |
|
AngleQuaternion( pstart->info.GetViewAngles(), qstart ); |
|
AngleQuaternion( pend->info.GetViewAngles(), qend ); |
|
|
|
for ( int i = startframe; i <= endframe; i++ ) |
|
{ |
|
demosmoothing_t *p = &m_Smoothing.smooth[ i ]; |
|
|
|
int elapsed = p->frametick - pstart->frametick; |
|
float frac = (float)elapsed / (float)dt; |
|
|
|
frac = clamp( frac, 0.0f, 1.0f ); |
|
|
|
p->info.flags |= FDEMO_USE_ANGLES2; |
|
|
|
Quaternion interpolated; |
|
|
|
QuaternionSlerp( qstart, qend, frac, interpolated ); |
|
|
|
QAngle outangles; |
|
QuaternionAngles( interpolated, outangles ); |
|
|
|
p->info.viewAngles2 = outangles; |
|
p->info.localViewAngles2 = outangles; |
|
} |
|
} |
|
|
|
void CDemoSmootherPanel::OnLinearInterpolateAnglesBasedOnEndpoints( void ) |
|
{ |
|
if ( !m_bHasSelection ) |
|
return; |
|
|
|
int c = m_Smoothing.smooth.Count(); |
|
if ( c < 2 ) |
|
return; |
|
|
|
m_bDirty = true; |
|
PushUndo( "linear interp angles" ); |
|
|
|
PerformLinearInterpolatedAngleSmoothing( m_nSelection[ 0 ], m_nSelection[ 1 ] ); |
|
|
|
PushRedo( "linear interp angles" ); |
|
} |
|
|
|
void CDemoSmootherPanel::OnLinearInterpolateOriginBasedOnEndpoints( void ) |
|
{ |
|
if ( !m_bHasSelection ) |
|
return; |
|
|
|
int c = m_Smoothing.smooth.Count(); |
|
|
|
if ( c < 2 ) |
|
return; |
|
|
|
demosmoothing_t *pstart = &m_Smoothing.smooth[ m_nSelection[ 0 ] ]; |
|
demosmoothing_t *pend = &m_Smoothing.smooth[ m_nSelection[ 1 ] ]; |
|
|
|
int dt = pend->frametick - pstart->frametick; |
|
if ( dt <= 0 ) |
|
return; |
|
|
|
m_bDirty = true; |
|
PushUndo( "linear interp origin" ); |
|
|
|
Vector vstart, vend; |
|
vstart = pstart->info.GetViewOrigin(); |
|
vend = pend->info.GetViewOrigin(); |
|
|
|
for ( int i = m_nSelection[0]; i <= m_nSelection[1]; i++ ) |
|
{ |
|
demosmoothing_t *p = &m_Smoothing.smooth[ i ]; |
|
|
|
float elapsed = p->frametick - pstart->frametick; |
|
float frac = elapsed / (float)dt; |
|
|
|
frac = clamp( frac, 0.0f, 1.0f ); |
|
|
|
p->info.flags |= FDEMO_USE_ORIGIN2; |
|
|
|
Vector interpolated; |
|
|
|
VectorLerp( vstart, vend, frac, interpolated ); |
|
|
|
p->info.viewOrigin2 = interpolated; |
|
} |
|
|
|
PushRedo( "linear interp origin" ); |
|
|
|
} |
|
|
|
void CDemoSmootherPanel::OnRevertPoint( void ) |
|
{ |
|
demosmoothing_t *p = GetCurrent(); |
|
if ( !p ) |
|
return; |
|
|
|
m_bDirty = true; |
|
PushUndo( "revert point" ); |
|
|
|
p->angmoved = p->info.GetViewAngles(); |
|
p->vecmoved = p->info.GetViewOrigin(); |
|
p->samplepoint = false; |
|
|
|
p->vectarget = p->info.GetViewOrigin(); |
|
p->targetpoint = false; |
|
|
|
// m_ViewOrigin = p->info.viewOrigin; |
|
// m_ViewAngles = p->info.viewAngles; |
|
|
|
PushRedo( "revert point" ); |
|
} |
|
|
|
demosmoothing_t *CDemoSmootherPanel::GetCurrent( void ) |
|
{ |
|
if ( !CanEdit() ) |
|
return NULL; |
|
|
|
int c = m_Smoothing.smooth.Count(); |
|
if ( c < 1 ) |
|
return NULL; |
|
|
|
int frame = clamp( m_nPreviewLastFrame, 0, c - 1 ); |
|
|
|
return &m_Smoothing.smooth[ frame ]; |
|
} |
|
|
|
void CDemoSmootherPanel::AddSamplePoints( bool usetarget, bool includeboundaries, CUtlVector< demosmoothing_t * >& points, int start, int end ) |
|
{ |
|
points.RemoveAll(); |
|
|
|
int i; |
|
for ( i = start; i <= end; i++ ) |
|
{ |
|
demosmoothing_t *p = &m_Smoothing.smooth[ i ]; |
|
|
|
if ( includeboundaries ) |
|
{ |
|
if ( i == start ) |
|
{ |
|
// Add it twice |
|
points.AddToTail( p ); |
|
continue; |
|
} |
|
else if ( i == end ) |
|
{ |
|
// Add twice |
|
points.AddToTail( p ); |
|
continue; |
|
} |
|
} |
|
|
|
if ( usetarget && p->targetpoint ) |
|
{ |
|
points.AddToTail( p ); |
|
} |
|
if ( !usetarget && p->samplepoint ) |
|
{ |
|
points.AddToTail( p ); |
|
} |
|
} |
|
} |
|
|
|
demosmoothing_t *CDemoSmootherPanel::GetBoundedSample( CUtlVector< demosmoothing_t * >& points, int sample ) |
|
{ |
|
int c = points.Count(); |
|
if ( sample < 0 ) |
|
return points[ 0 ]; |
|
else if ( sample >= c ) |
|
return points[ c - 1 ]; |
|
return points[ sample ]; |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
// Input : t - |
|
// points - |
|
// prev - |
|
// next - |
|
//----------------------------------------------------------------------------- |
|
void CDemoSmootherPanel::FindSpanningPoints( int tick, CUtlVector< demosmoothing_t * >& points, int& prev, int& next ) |
|
{ |
|
prev = -1; |
|
next = 0; |
|
int c = points.Count(); |
|
int i; |
|
|
|
for ( i = 0; i < c; i++ ) |
|
{ |
|
demosmoothing_t *p = points[ i ]; |
|
|
|
if ( tick < p->frametick ) |
|
break; |
|
} |
|
|
|
next = i; |
|
prev = i - 1; |
|
|
|
next = clamp( next, 0, c - 1 ); |
|
prev = clamp( prev, 0, c - 1 ); |
|
} |
|
|
|
void CDemoSmootherPanel::OnSplineSampleOrigin( void ) |
|
{ |
|
if ( !m_bHasSelection ) |
|
return; |
|
|
|
int c = m_Smoothing.smooth.Count(); |
|
|
|
if ( c < 2 ) |
|
return; |
|
|
|
demosmoothing_t *pstart = &m_Smoothing.smooth[ m_nSelection[ 0 ] ]; |
|
demosmoothing_t *pend = &m_Smoothing.smooth[ m_nSelection[ 1 ] ]; |
|
|
|
if ( pend->frametick - pstart->frametick <= 0 ) |
|
return; |
|
|
|
CUtlVector< demosmoothing_t * > points; |
|
AddSamplePoints( false, false, points, m_nSelection[ 0 ], m_nSelection[ 1 ] ); |
|
|
|
if ( points.Count() <= 0 ) |
|
return; |
|
|
|
m_bDirty = true; |
|
PushUndo( "spline origin" ); |
|
|
|
for ( int i = m_nSelection[0]; i <= m_nSelection[1]; i++ ) |
|
{ |
|
demosmoothing_t *p = &m_Smoothing.smooth[ i ]; |
|
|
|
demosmoothing_t *earliest; |
|
demosmoothing_t *current; |
|
demosmoothing_t *next; |
|
demosmoothing_t *latest; |
|
|
|
int cur; |
|
int cur2; |
|
|
|
FindSpanningPoints( p->frametick, points, cur, cur2 ); |
|
|
|
earliest = GetBoundedSample( points, cur - 1 ); |
|
current = GetBoundedSample( points, cur ); |
|
next = GetBoundedSample( points, cur2 ); |
|
latest = GetBoundedSample( points, cur2 + 1 ); |
|
|
|
float frac = 0.0f; |
|
float dt = next->frametick - current->frametick; |
|
if ( dt > 0.0f ) |
|
{ |
|
frac = (float)( p->frametick - current->frametick ) / dt; |
|
} |
|
|
|
frac = clamp( frac, 0.0f, 1.0f ); |
|
|
|
Vector splined; |
|
|
|
Catmull_Rom_Spline_Normalize( earliest->vecmoved, current->vecmoved, next->vecmoved, latest->vecmoved, frac, splined ); |
|
|
|
p->info.flags |= FDEMO_USE_ORIGIN2; |
|
p->info.viewOrigin2 = splined; |
|
} |
|
|
|
PushRedo( "spline origin" ); |
|
|
|
} |
|
|
|
void CDemoSmootherPanel::OnSplineSampleAngles( void ) |
|
{ |
|
if ( !m_bHasSelection ) |
|
return; |
|
|
|
int c = m_Smoothing.smooth.Count(); |
|
|
|
if ( c < 2 ) |
|
return; |
|
|
|
demosmoothing_t *pstart = &m_Smoothing.smooth[ m_nSelection[ 0 ] ]; |
|
demosmoothing_t *pend = &m_Smoothing.smooth[ m_nSelection[ 1 ] ]; |
|
|
|
if ( pend->frametick - pstart->frametick <= 0 ) |
|
return; |
|
|
|
CUtlVector< demosmoothing_t * > points; |
|
AddSamplePoints( false, false, points, m_nSelection[ 0 ], m_nSelection[ 1 ] ); |
|
|
|
if ( points.Count() <= 0 ) |
|
return; |
|
|
|
m_bDirty = true; |
|
PushUndo( "spline angles" ); |
|
|
|
for ( int i = m_nSelection[0]; i <= m_nSelection[1]; i++ ) |
|
{ |
|
demosmoothing_t *p = &m_Smoothing.smooth[ i ]; |
|
|
|
demosmoothing_t *current; |
|
demosmoothing_t *next; |
|
|
|
int cur; |
|
int cur2; |
|
|
|
FindSpanningPoints( p->frametick, points, cur, cur2 ); |
|
|
|
current = GetBoundedSample( points, cur ); |
|
next = GetBoundedSample( points, cur2 ); |
|
|
|
float frac = 0.0f; |
|
float dt = next->frametick - current->frametick; |
|
if ( dt > 0.0f ) |
|
{ |
|
frac = (float)( p->frametick - current->frametick ) / dt; |
|
} |
|
|
|
frac = clamp( frac, 0.0f, 1.0f ); |
|
|
|
frac = SimpleSpline( frac ); |
|
|
|
QAngle splined; |
|
|
|
InterpolateAngles( current->angmoved, next->angmoved, splined, frac ); |
|
|
|
p->info.flags |= FDEMO_USE_ANGLES2; |
|
p->info.viewAngles2 = splined; |
|
p->info.localViewAngles2 = splined; |
|
} |
|
|
|
PushRedo( "spline angles" ); |
|
} |
|
|
|
void CDemoSmootherPanel::OnLookAtPoints( bool spline ) |
|
{ |
|
if ( !m_bHasSelection ) |
|
return; |
|
|
|
int c = m_Smoothing.smooth.Count(); |
|
int i; |
|
|
|
if ( c < 2 ) |
|
return; |
|
|
|
demosmoothing_t *pstart = &m_Smoothing.smooth[ m_nSelection[ 0 ] ]; |
|
demosmoothing_t *pend = &m_Smoothing.smooth[ m_nSelection[ 1 ] ]; |
|
|
|
if ( pend->frametick - pstart->frametick <= 0 ) |
|
return; |
|
|
|
CUtlVector< demosmoothing_t * > points; |
|
AddSamplePoints( true, false, points, m_nSelection[ 0 ], m_nSelection[ 1 ] ); |
|
|
|
if ( points.Count() < 1 ) |
|
return; |
|
|
|
m_bDirty = true; |
|
PushUndo( "lookat points" ); |
|
|
|
for ( i = m_nSelection[0]; i <= m_nSelection[1]; i++ ) |
|
{ |
|
demosmoothing_t *p = &m_Smoothing.smooth[ i ]; |
|
|
|
demosmoothing_t *earliest; |
|
demosmoothing_t *current; |
|
demosmoothing_t *next; |
|
demosmoothing_t *latest; |
|
|
|
int cur; |
|
int cur2; |
|
|
|
FindSpanningPoints( p->frametick, points, cur, cur2 ); |
|
|
|
earliest = GetBoundedSample( points, cur - 1 ); |
|
current = GetBoundedSample( points, cur ); |
|
next = GetBoundedSample( points, cur2 ); |
|
latest = GetBoundedSample( points, cur2 + 1 ); |
|
|
|
float frac = 0.0f; |
|
float dt = next->frametick - current->frametick; |
|
if ( dt > 0.0f ) |
|
{ |
|
frac = (float)( p->frametick - current->frametick ) / dt; |
|
} |
|
|
|
frac = clamp( frac, 0.0f, 1.0f ); |
|
|
|
Vector splined; |
|
|
|
if ( spline ) |
|
{ |
|
Catmull_Rom_Spline_Normalize( earliest->vectarget, current->vectarget, next->vectarget, latest->vectarget, frac, splined ); |
|
} |
|
else |
|
{ |
|
Vector d = next->vectarget - current->vectarget; |
|
VectorMA( current->vectarget, frac, d, splined ); |
|
} |
|
|
|
Vector vecToTarget = splined - ( p->info.GetViewOrigin() + m_vecEyeOffset ); |
|
VectorNormalize( vecToTarget ); |
|
|
|
QAngle angles; |
|
VectorAngles( vecToTarget, angles ); |
|
|
|
p->info.flags |= FDEMO_USE_ANGLES2; |
|
p->info.viewAngles2 = angles; |
|
p->info.localViewAngles2 = angles; |
|
} |
|
|
|
PushRedo( "lookat points" ); |
|
} |
|
|
|
void CDemoSmootherPanel::SetLastFrame( bool jumptotarget, int frame ) |
|
{ |
|
// bool changed = frame != m_nPreviewLastFrame; |
|
|
|
int useFrame = max( m_Smoothing.m_nFirstSelectableSample, frame ); |
|
|
|
m_nPreviewLastFrame = useFrame; |
|
|
|
/* if ( changed && !m_pLockCamera->IsSelected() ) |
|
{ |
|
// Reset default view/angles |
|
demosmoothing_t *p = GetCurrent(); |
|
if ( p ) |
|
{ |
|
if ( p->samplepoint && !jumptotarget ) |
|
{ |
|
m_ViewOrigin = p->vecmoved; |
|
m_ViewAngles = p->angmoved; |
|
} |
|
else if ( p->targetpoint && jumptotarget ) |
|
{ |
|
m_ViewOrigin = p->vectarget - m_vecEyeOffset; |
|
} |
|
else |
|
{ |
|
if ( m_bPreviewing && m_bPreviewOriginal ) |
|
{ |
|
m_ViewOrigin = p->info.viewOrigin; |
|
m_ViewAngles = p->info.viewAngles; |
|
} |
|
else |
|
{ |
|
m_ViewOrigin = p->info.GetViewOrigin(); |
|
m_ViewAngles = p->info.GetViewAngles(); |
|
} |
|
} |
|
} |
|
} */ |
|
} |
|
|
|
// Undo/Redo |
|
void CDemoSmootherPanel::Undo( void ) |
|
{ |
|
if ( m_UndoStack.Size() > 0 && m_nUndoLevel > 0 ) |
|
{ |
|
m_nUndoLevel--; |
|
DemoSmoothUndo *u = m_UndoStack[ m_nUndoLevel ]; |
|
Assert( u->undo ); |
|
|
|
m_Smoothing = *(u->undo); |
|
} |
|
InvalidateLayout(); |
|
} |
|
|
|
void CDemoSmootherPanel::Redo( void ) |
|
{ |
|
if ( m_UndoStack.Size() > 0 && m_nUndoLevel <= m_UndoStack.Size() - 1 ) |
|
{ |
|
DemoSmoothUndo *u = m_UndoStack[ m_nUndoLevel ]; |
|
Assert( u->redo ); |
|
|
|
m_Smoothing = *(u->redo); |
|
m_nUndoLevel++; |
|
} |
|
|
|
InvalidateLayout(); |
|
} |
|
|
|
void CDemoSmootherPanel::PushUndo( const char *description ) |
|
{ |
|
Assert( !m_bRedoPending ); |
|
m_bRedoPending = true; |
|
WipeRedo(); |
|
|
|
// Copy current data |
|
CSmoothingContext *u = new CSmoothingContext; |
|
*u = m_Smoothing; |
|
DemoSmoothUndo *undo = new DemoSmoothUndo; |
|
undo->undo = u; |
|
undo->redo = NULL; |
|
undo->udescription = COM_StringCopy( description ); |
|
undo->rdescription = NULL; |
|
m_UndoStack.AddToTail( undo ); |
|
m_nUndoLevel++; |
|
} |
|
|
|
void CDemoSmootherPanel::PushRedo( const char *description ) |
|
{ |
|
Assert( m_bRedoPending ); |
|
m_bRedoPending = false; |
|
|
|
// Copy current data |
|
CSmoothingContext *r = new CSmoothingContext; |
|
*r = m_Smoothing; |
|
DemoSmoothUndo *undo = m_UndoStack[ m_nUndoLevel - 1 ]; |
|
undo->redo = r; |
|
undo->rdescription = COM_StringCopy( description ); |
|
} |
|
|
|
void CDemoSmootherPanel::WipeUndo( void ) |
|
{ |
|
while ( m_UndoStack.Size() > 0 ) |
|
{ |
|
DemoSmoothUndo *u = m_UndoStack[ 0 ]; |
|
delete u->undo; |
|
delete u->redo; |
|
delete[] u->udescription; |
|
delete[] u->rdescription; |
|
delete u; |
|
m_UndoStack.Remove( 0 ); |
|
} |
|
m_nUndoLevel = 0; |
|
} |
|
|
|
void CDemoSmootherPanel::WipeRedo( void ) |
|
{ |
|
// Wipe everything above level |
|
while ( m_UndoStack.Size() > m_nUndoLevel ) |
|
{ |
|
DemoSmoothUndo *u = m_UndoStack[ m_nUndoLevel ]; |
|
delete u->undo; |
|
delete u->redo; |
|
delete[] u->udescription; |
|
delete[] u->rdescription; |
|
delete u; |
|
m_UndoStack.Remove( m_nUndoLevel ); |
|
} |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
// Output : const char |
|
//----------------------------------------------------------------------------- |
|
const char *CDemoSmootherPanel::GetUndoDescription( void ) |
|
{ |
|
if ( m_nUndoLevel != 0 ) |
|
{ |
|
DemoSmoothUndo *u = m_UndoStack[ m_nUndoLevel - 1 ]; |
|
return u->udescription; |
|
} |
|
return "???undo"; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
// Output : const char |
|
//----------------------------------------------------------------------------- |
|
const char *CDemoSmootherPanel::GetRedoDescription( void ) |
|
{ |
|
if ( m_nUndoLevel != m_UndoStack.Size() ) |
|
{ |
|
DemoSmoothUndo *u = m_UndoStack[ m_nUndoLevel ]; |
|
return u->rdescription; |
|
} |
|
return "???redo"; |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
// Output : Returns true on success, false on failure. |
|
//----------------------------------------------------------------------------- |
|
bool CDemoSmootherPanel::CanRedo( void ) |
|
{ |
|
if ( !m_UndoStack.Count() ) |
|
return false; |
|
|
|
if ( m_nUndoLevel == m_UndoStack.Count() ) |
|
return false; |
|
|
|
return true; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
// Output : Returns true on success, false on failure. |
|
//----------------------------------------------------------------------------- |
|
bool CDemoSmootherPanel::CanUndo( void ) |
|
{ |
|
if ( !m_UndoStack.Count() ) |
|
return false; |
|
|
|
if ( m_nUndoLevel == 0 ) |
|
return false; |
|
|
|
return true; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CDemoSmootherPanel::OnToggleKeyFrame( void ) |
|
{ |
|
demosmoothing_t *p = GetCurrent(); |
|
if ( !p ) |
|
return; |
|
|
|
m_bDirty = true; |
|
PushUndo( "toggle keyframe" ); |
|
|
|
// use orginal data by default |
|
p->angmoved = p->info.GetViewAngles(); |
|
p->vecmoved = p->info.GetViewOrigin(); |
|
|
|
if ( !p->samplepoint ) |
|
{ |
|
if ( g_pDemoUI->IsInDriveMode() ) |
|
{ |
|
g_pDemoUI->GetDriveViewPoint( p->vecmoved, p->angmoved ); |
|
} |
|
|
|
if ( g_pDemoUI2->IsInDriveMode() ) |
|
{ |
|
g_pDemoUI2->GetDriveViewPoint( p->vecmoved, p->angmoved ); |
|
} |
|
|
|
p->samplepoint = true; |
|
} |
|
else |
|
{ |
|
p->samplepoint = false; |
|
} |
|
|
|
PushRedo( "toggle keyframe" ); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CDemoSmootherPanel::OnToggleLookTarget( void ) |
|
{ |
|
demosmoothing_t *p = GetCurrent(); |
|
if ( !p ) |
|
return; |
|
|
|
m_bDirty = true; |
|
PushUndo( "toggle look target" ); |
|
|
|
// use orginal data by default |
|
p->vectarget = p->info.GetViewOrigin(); |
|
|
|
if ( !p->targetpoint ) |
|
{ |
|
QAngle angles; |
|
g_pDemoUI->GetDriveViewPoint( p->vectarget, angles ); |
|
g_pDemoUI2->GetDriveViewPoint( p->vectarget, angles ); |
|
|
|
p->targetpoint = true; |
|
} |
|
else |
|
{ |
|
p->targetpoint = false; |
|
} |
|
|
|
PushRedo( "toggle look target" ); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CDemoSmootherPanel::OnNextKey() |
|
{ |
|
if( !m_bHasSelection ) |
|
return; |
|
|
|
int start = m_nPreviewLastFrame + 1; |
|
int maxmove = m_nSelection[1] - m_nSelection[0] + 1; |
|
|
|
int moved = 0; |
|
|
|
while ( moved < maxmove ) |
|
{ |
|
demosmoothing_t *p = &m_Smoothing.smooth[ start ]; |
|
if ( p->samplepoint ) |
|
{ |
|
SetLastFrame( false, start ); |
|
break; |
|
} |
|
|
|
start++; |
|
|
|
if ( start > m_nSelection[1] ) |
|
start = m_nSelection[0]; |
|
|
|
moved++; |
|
} |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CDemoSmootherPanel::OnPrevKey() |
|
{ |
|
if( !m_bHasSelection ) |
|
return; |
|
|
|
int start = m_nPreviewLastFrame - 1; |
|
int maxmove = m_nSelection[1] - m_nSelection[0] + 1; |
|
|
|
int moved = 0; |
|
|
|
while ( moved < maxmove && start >= 0 ) |
|
{ |
|
demosmoothing_t *p = &m_Smoothing.smooth[ start ]; |
|
if ( p->samplepoint ) |
|
{ |
|
SetLastFrame( false, start ); |
|
break; |
|
} |
|
|
|
start--; |
|
|
|
if ( start < m_nSelection[0] ) |
|
start = m_nSelection[1]; |
|
|
|
moved++; |
|
} |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CDemoSmootherPanel::OnNextTarget() |
|
{ |
|
if( !m_bHasSelection ) |
|
return; |
|
|
|
int start = m_nPreviewLastFrame + 1; |
|
int maxmove = m_nSelection[1] - m_nSelection[0] + 1; |
|
|
|
int moved = 0; |
|
|
|
while ( moved < maxmove ) |
|
{ |
|
demosmoothing_t *p = &m_Smoothing.smooth[ start ]; |
|
if ( p->targetpoint ) |
|
{ |
|
SetLastFrame( true, start ); |
|
break; |
|
} |
|
|
|
start++; |
|
|
|
if ( start > m_nSelection[1] ) |
|
start = m_nSelection[0]; |
|
|
|
moved++; |
|
} |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CDemoSmootherPanel::OnPrevTarget() |
|
{ |
|
if( !m_bHasSelection ) |
|
return; |
|
|
|
int start = m_nPreviewLastFrame - 1; |
|
int maxmove = m_nSelection[1] - m_nSelection[0] + 1; |
|
|
|
int moved = 0; |
|
|
|
while ( moved < maxmove ) |
|
{ |
|
demosmoothing_t *p = &m_Smoothing.smooth[ start ]; |
|
if ( p->targetpoint ) |
|
{ |
|
SetLastFrame( true, start ); |
|
break; |
|
} |
|
|
|
start--; |
|
|
|
if ( start < m_nSelection[0] ) |
|
start = m_nSelection[1]; |
|
|
|
moved++; |
|
} |
|
} |
|
|
|
void CDemoSmootherPanel::DrawTargetSpline() |
|
{ |
|
if ( !m_bHasSelection ) |
|
return; |
|
|
|
int c = m_Smoothing.smooth.Count(); |
|
int i; |
|
|
|
if ( c < 2 ) |
|
return; |
|
|
|
demosmoothing_t *pstart = &m_Smoothing.smooth[ m_nSelection[ 0 ] ]; |
|
demosmoothing_t *pend = &m_Smoothing.smooth[ m_nSelection[ 1 ] ]; |
|
|
|
if ( pend->frametick - pstart->frametick <= 0 ) |
|
return; |
|
|
|
CUtlVector< demosmoothing_t * > points; |
|
AddSamplePoints( true, false, points, m_nSelection[ 0 ], m_nSelection[ 1 ] ); |
|
|
|
if ( points.Count() < 1 ) |
|
return; |
|
|
|
Vector previous(0,0,0); |
|
|
|
for ( i = m_nSelection[0]; i <= m_nSelection[1]; i++ ) |
|
{ |
|
demosmoothing_t *p = &m_Smoothing.smooth[ i ]; |
|
|
|
demosmoothing_t *earliest; |
|
demosmoothing_t *current; |
|
demosmoothing_t *next; |
|
demosmoothing_t *latest; |
|
|
|
int cur; |
|
int cur2; |
|
|
|
FindSpanningPoints( p->frametick, points, cur, cur2 ); |
|
|
|
earliest = GetBoundedSample( points, cur - 1 ); |
|
current = GetBoundedSample( points, cur ); |
|
next = GetBoundedSample( points, cur2 ); |
|
latest = GetBoundedSample( points, cur2 + 1 ); |
|
|
|
float frac = 0.0f; |
|
float dt = next->frametick - current->frametick; |
|
if ( dt > 0.0f ) |
|
{ |
|
frac = (float)( p->frametick - current->frametick ) / dt; |
|
} |
|
|
|
frac = clamp( frac, 0.0f, 1.0f ); |
|
|
|
Vector splined; |
|
|
|
Catmull_Rom_Spline_Normalize( earliest->vectarget, current->vectarget, next->vectarget, latest->vectarget, frac, splined ); |
|
|
|
if ( i > m_nSelection[0] ) |
|
{ |
|
RenderLine( previous, splined, Color( 0, 255, 0, 255 ), true ); |
|
} |
|
|
|
previous = splined; |
|
} |
|
} |
|
|
|
void CDemoSmootherPanel::DrawKeySpline() |
|
{ |
|
if ( !m_bHasSelection ) |
|
return; |
|
|
|
int c = m_Smoothing.smooth.Count(); |
|
int i; |
|
|
|
if ( c < 2 ) |
|
return; |
|
|
|
demosmoothing_t *pstart = &m_Smoothing.smooth[ m_nSelection[ 0 ] ]; |
|
demosmoothing_t *pend = &m_Smoothing.smooth[ m_nSelection[ 1 ] ]; |
|
|
|
if ( pend->frametick - pstart->frametick <= 0 ) |
|
return; |
|
|
|
CUtlVector< demosmoothing_t * > points; |
|
AddSamplePoints( false, false, points, m_nSelection[ 0 ], m_nSelection[ 1 ] ); |
|
|
|
if ( points.Count() < 1 ) |
|
return; |
|
|
|
Vector previous(0,0,0); |
|
|
|
for ( i = m_nSelection[0]; i <= m_nSelection[1]; i++ ) |
|
{ |
|
demosmoothing_t *p = &m_Smoothing.smooth[ i ]; |
|
|
|
demosmoothing_t *earliest; |
|
demosmoothing_t *current; |
|
demosmoothing_t *next; |
|
demosmoothing_t *latest; |
|
|
|
int cur; |
|
int cur2; |
|
|
|
FindSpanningPoints( p->frametick, points, cur, cur2 ); |
|
|
|
earliest = GetBoundedSample( points, cur - 1 ); |
|
current = GetBoundedSample( points, cur ); |
|
next = GetBoundedSample( points, cur2 ); |
|
latest = GetBoundedSample( points, cur2 + 1 ); |
|
|
|
float frac = 0.0f; |
|
float dt = next->frametick - current->frametick; |
|
if ( dt > 0.0f ) |
|
{ |
|
frac = (float)( p->frametick - current->frametick ) / dt; |
|
} |
|
|
|
frac = clamp( frac, 0.0f, 1.0f ); |
|
|
|
Vector splined; |
|
|
|
Catmull_Rom_Spline_Normalize( earliest->vecmoved, current->vecmoved, next->vecmoved, latest->vecmoved, frac, splined ); |
|
|
|
splined += m_vecEyeOffset; |
|
|
|
if ( i > m_nSelection[0] ) |
|
{ |
|
RenderLine( previous, splined, Color( 0, 255, 0, 255 ), true ); |
|
} |
|
|
|
previous = splined; |
|
} |
|
} |
|
|
|
void CDemoSmootherPanel::OnSmoothEdges( bool left, bool right ) |
|
{ |
|
if ( !m_bHasSelection ) |
|
return; |
|
|
|
if ( !left && !right ) |
|
return; |
|
|
|
int c = m_Smoothing.smooth.Count(); |
|
|
|
// Get number of frames |
|
char sz[ 512 ]; |
|
m_pFixEdgeFrames->GetText( sz, sizeof( sz ) ); |
|
|
|
int frames = atoi( sz ); |
|
if ( frames <= 2 ) |
|
return; |
|
|
|
m_bDirty = true; |
|
PushUndo( "smooth edges" ); |
|
|
|
if ( left && m_nSelection[0] > 0 ) |
|
{ |
|
PerformLinearInterpolatedAngleSmoothing( m_nSelection[ 0 ] - 1, m_nSelection[ 0 ] + frames ); |
|
} |
|
if ( right && m_nSelection[1] < c - 1 ) |
|
{ |
|
PerformLinearInterpolatedAngleSmoothing( m_nSelection[ 1 ] - frames, m_nSelection[ 1 ] + 1 ); |
|
} |
|
|
|
PushRedo( "smooth edges" ); |
|
} |
|
|
|
void CDemoSmootherPanel::OnSaveKey() |
|
{ |
|
if ( !m_bHasSelection ) |
|
return; |
|
|
|
demosmoothing_t *p = GetCurrent(); |
|
if ( !p ) |
|
return; |
|
|
|
if ( !p->samplepoint ) |
|
return; |
|
|
|
m_bDirty = true; |
|
PushUndo( "save key" ); |
|
|
|
p->info.viewAngles2 = p->angmoved; |
|
p->info.localViewAngles2 = p->angmoved; |
|
p->info.viewOrigin2 = p->vecmoved; |
|
p->info.flags |= FDEMO_USE_ORIGIN2; |
|
p->info.flags |= FDEMO_USE_ANGLES2; |
|
|
|
PushRedo( "save key" ); |
|
} |
|
|
|
void CDemoSmootherPanel::OnSetView() |
|
{ |
|
if ( !m_bHasSelection ) |
|
return; |
|
|
|
demosmoothing_t *p = GetCurrent(); |
|
if ( !p ) |
|
return; |
|
|
|
Vector origin = p->info.GetViewOrigin(); |
|
QAngle angle = p->info.GetViewAngles(); |
|
|
|
g_pDemoUI->SetDriveViewPoint( origin, angle ); |
|
g_pDemoUI2->SetDriveViewPoint( origin, angle ); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CDemoSmootherPanel::OnGotoFrame() |
|
{ |
|
int c = m_Smoothing.smooth.Count(); |
|
if ( c < 2 ) |
|
return; |
|
|
|
char sz[ 256 ]; |
|
m_pGotoFrame->GetText( sz, sizeof( sz ) ); |
|
int frame = atoi( sz ); |
|
|
|
if ( !m_bPreviewing ) |
|
{ |
|
if ( !m_bHasSelection ) |
|
{ |
|
m_pStartFrame->SetText( va( "%i", 0 ) ); |
|
m_pEndFrame->SetText( va( "%i", c - 1 ) ); |
|
OnSelect(); |
|
} |
|
OnPreview( false ); |
|
OnTogglePause(); |
|
} |
|
|
|
if ( !m_bPreviewing ) |
|
return; |
|
|
|
SetLastFrame( false, frame ); |
|
m_iPreviewStartTick = GetTickForFrame( m_nPreviewLastFrame ); |
|
m_fPreviewCurrentTime = TICKS_TO_TIME( m_iPreviewStartTick ); |
|
} |
|
|
|
void CDemoSmootherPanel::OnOriginEaseCurve( EASEFUNC easefunc ) |
|
{ |
|
if ( !m_bHasSelection ) |
|
return; |
|
|
|
int c = m_Smoothing.smooth.Count(); |
|
|
|
if ( c < 2 ) |
|
return; |
|
|
|
demosmoothing_t *pstart = &m_Smoothing.smooth[ m_nSelection[ 0 ] ]; |
|
demosmoothing_t *pend = &m_Smoothing.smooth[ m_nSelection[ 1 ] ]; |
|
|
|
float dt = pend->frametick - pstart->frametick; |
|
if ( dt <= 0.0f ) |
|
return; |
|
|
|
m_bDirty = true; |
|
PushUndo( "ease origin" ); |
|
|
|
Vector vstart, vend; |
|
vstart = pstart->info.GetViewOrigin(); |
|
vend = pend->info.GetViewOrigin(); |
|
|
|
for ( int i = m_nSelection[0]; i <= m_nSelection[1]; i++ ) |
|
{ |
|
demosmoothing_t *p = &m_Smoothing.smooth[ i ]; |
|
|
|
float elapsed = p->frametick - pstart->frametick; |
|
float frac = elapsed / dt; |
|
|
|
// Apply ease function |
|
frac = (*easefunc)( frac ); |
|
|
|
frac = clamp( frac, 0.0f, 1.0f ); |
|
|
|
p->info.flags |= FDEMO_USE_ORIGIN2; |
|
|
|
Vector interpolated; |
|
|
|
VectorLerp( vstart, vend, frac, interpolated ); |
|
|
|
p->info.viewOrigin2 = interpolated; |
|
} |
|
|
|
PushRedo( "ease origin" ); |
|
} |
|
|
|
void CDemoSmootherPanel::ParseSmoothingInfo( CDemoFile &demoFile, CSmoothingContext& smoothing ) |
|
{ |
|
democmdinfo_t info; |
|
int dummy; |
|
|
|
bool foundFirstSelectable = false; |
|
|
|
bool demofinished = false; |
|
while ( !demofinished ) |
|
{ |
|
int tick = 0; |
|
byte cmd; |
|
|
|
bool swallowmessages = true; |
|
do |
|
{ |
|
demoFile.ReadCmdHeader( cmd, tick ); |
|
|
|
// COMMAND HANDLERS |
|
switch ( cmd ) |
|
{ |
|
case dem_synctick: |
|
break; |
|
case dem_stop: |
|
{ |
|
swallowmessages = false; |
|
demofinished = true; |
|
} |
|
break; |
|
case dem_consolecmd: |
|
{ |
|
demoFile.ReadConsoleCommand(); |
|
} |
|
break; |
|
case dem_datatables: |
|
{ |
|
demoFile.ReadNetworkDataTables( NULL ); |
|
} |
|
break; |
|
case dem_stringtables: |
|
{ |
|
demoFile.ReadStringTables( NULL ); |
|
} |
|
break; |
|
case dem_usercmd: |
|
{ |
|
demoFile.ReadUserCmd( NULL, dummy ); |
|
|
|
} |
|
break; |
|
default: |
|
{ |
|
swallowmessages = false; |
|
} |
|
break; |
|
} |
|
} |
|
while ( swallowmessages ); |
|
|
|
if ( demofinished ) |
|
{ |
|
// StopPlayback(); |
|
return; |
|
} |
|
|
|
int curpos = demoFile.GetCurPos( true ); |
|
|
|
demoFile.ReadCmdInfo( info ); |
|
demoFile.ReadSequenceInfo( dummy, dummy ); |
|
demoFile.ReadRawData( NULL, 0 ); |
|
|
|
// Add to end of list |
|
demosmoothing_t smoothing_entry; |
|
|
|
smoothing_entry.file_offset = curpos; |
|
smoothing_entry.frametick = tick; |
|
smoothing_entry.info = info; |
|
smoothing_entry.samplepoint = false; |
|
smoothing_entry.vecmoved = info.GetViewOrigin(); |
|
smoothing_entry.angmoved = info.GetViewAngles(); |
|
smoothing_entry.targetpoint = false; |
|
smoothing_entry.vectarget = info.GetViewOrigin(); |
|
|
|
int sampleIndex = smoothing.smooth.AddToTail( smoothing_entry ); |
|
|
|
if ( !foundFirstSelectable && |
|
smoothing_entry.vecmoved.LengthSqr() > 0.0f ) |
|
{ |
|
foundFirstSelectable = true; |
|
smoothing.m_nFirstSelectableSample = sampleIndex; |
|
} |
|
} |
|
} |
|
|
|
void CDemoSmootherPanel::LoadSmoothingInfo( const char *filename, CSmoothingContext& smoothing ) |
|
{ |
|
char name[ MAX_OSPATH ]; |
|
Q_strncpy (name, filename, sizeof(name) ); |
|
Q_DefaultExtension( name, ".dem", sizeof( name ) ); |
|
|
|
CDemoFile demoFile; |
|
|
|
if ( !demoFile.Open( filename, true ) ) |
|
{ |
|
ConMsg( "ERROR: couldn't open %s.\n", name ); |
|
return; |
|
} |
|
|
|
demoheader_t * header = demoFile.ReadDemoHeader(); |
|
|
|
if ( !header ) |
|
{ |
|
demoFile.Close(); |
|
return; |
|
} |
|
|
|
ConMsg ("Smoothing demo from %s ...", name ); |
|
|
|
smoothing.active = true; |
|
Q_strncpy( smoothing.filename, name, sizeof(smoothing.filename) ); |
|
|
|
smoothing.smooth.RemoveAll(); |
|
|
|
ClearSmoothingInfo( smoothing ); |
|
|
|
ParseSmoothingInfo( demoFile, smoothing ); |
|
|
|
demoFile.Close(); |
|
|
|
//Performsmoothing( smooth ); |
|
//SaveSmoothedDemo( name, smooth ); |
|
|
|
ConMsg ( " done.\n" ); |
|
} |
|
|
|
void CDemoSmootherPanel::ClearSmoothingInfo( CSmoothingContext& smoothing ) |
|
{ |
|
int c = smoothing.smooth.Count(); |
|
int i; |
|
|
|
for ( i = 0; i < c; i++ ) |
|
{ |
|
demosmoothing_t *p = &smoothing.smooth[ i ]; |
|
p->info.Reset(); |
|
p->vecmoved = p->info.GetViewOrigin(); |
|
p->angmoved = p->info.GetViewAngles(); |
|
p->samplepoint = false; |
|
p->vectarget = p->info.GetViewOrigin(); |
|
p->targetpoint = false; |
|
} |
|
} |
|
|
|
void CDemoSmootherPanel::SaveSmoothingInfo( char const *filename, CSmoothingContext& smoothing ) |
|
{ |
|
// Nothing to do |
|
int c = smoothing.smooth.Count(); |
|
if ( !c ) |
|
return; |
|
|
|
IFileSystem *fs = g_pFileSystem; |
|
|
|
FileHandle_t infile, outfile; |
|
|
|
COM_OpenFile( filename, &infile ); |
|
if ( infile == FILESYSTEM_INVALID_HANDLE ) |
|
return; |
|
|
|
int filesize = fs->Size( infile ); |
|
|
|
char outfilename[ 512 ]; |
|
Q_StripExtension( filename, outfilename, sizeof( outfilename ) ); |
|
Q_strncat( outfilename, "_smooth", sizeof(outfilename), COPY_ALL_CHARACTERS ); |
|
Q_DefaultExtension( outfilename, ".dem", sizeof( outfilename ) ); |
|
outfile = fs->Open( outfilename, "wb" ); |
|
if ( outfile == FILESYSTEM_INVALID_HANDLE ) |
|
{ |
|
fs->Close( infile ); |
|
return; |
|
} |
|
|
|
int i; |
|
|
|
int lastwritepos = 0; |
|
for ( i = 0; i < c; i++ ) |
|
{ |
|
demosmoothing_t *p = &smoothing.smooth[ i ]; |
|
|
|
int copyamount = p->file_offset - lastwritepos; |
|
|
|
COM_CopyFileChunk( outfile, infile, copyamount ); |
|
|
|
fs->Seek( infile, p->file_offset, FILESYSTEM_SEEK_HEAD ); |
|
|
|
// wacky hacky overwriting |
|
fs->Write( &p->info, sizeof( democmdinfo_t ), outfile ); |
|
|
|
lastwritepos = fs->Tell( outfile ); |
|
fs->Seek( infile, p->file_offset + sizeof( democmdinfo_t ), FILESYSTEM_SEEK_HEAD ); |
|
} |
|
|
|
int final = filesize - lastwritepos; |
|
|
|
COM_CopyFileChunk( outfile, infile, final ); |
|
|
|
fs->Close( outfile ); |
|
fs->Close( infile ); |
|
}
|
|
|