khanat-opennel-code/code/nel/tools/3d/object_viewer/slot_dlg.cpp
2012-07-23 12:26:38 -05:00

888 lines
24 KiB
C++

// NeL - MMORPG Framework <http://dev.ryzom.com/projects/nel/>
// Copyright (C) 2010 Winch Gate Property Limited
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as
// published by the Free Software Foundation, either version 3 of the
// License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
#include "std_afx.h"
#include "object_viewer.h"
#include "select_string.h"
#include "slot_dlg.h"
#include <nel/misc/common.h>
#define DELTA_BLEND 0.1f
#define DELTA_TIME (getTimeIncrement ())
#define DELTA_MUL 0.1f
using namespace NLMISC;
using namespace NL3D;
/////////////////////////////////////////////////////////////////////////////
// CSlotDlg dialog
CSlotDlg::CSlotDlg(CWnd* pParent /*=NULL*/)
: CDialog(CSlotDlg::IDD, pParent)
{
//{{AFX_DATA_INIT(CSlotDlg)
EndBlend = 1.0f;
Smoothness = 0.0f;
SpeedFactor = 1.0f;
StartBlend = 1.0f;
ClampMode = 0;
SkeletonWeightInverted = FALSE;
Offset = 0;
StartTime = 0;
EndTime = 0;
StartAnimTime=0.f;
EndAnimTime=1.f;
enable = TRUE;
//}}AFX_DATA_INIT
MainDlg=NULL;
}
void CSlotDlg::init (uint id, CObjectViewer* mainDlg)
{
Id=id;
MainDlg=mainDlg;
}
void CSlotDlg::DoDataExchange(CDataExchange* pDX)
{
CDialog::DoDataExchange(pDX);
//{{AFX_DATA_MAP(CSlotDlg)
DDX_Control(pDX, IDC_INVERT_SKELETON_WEIGHT, InvertSkeletonWeightCtrl);
DDX_Control(pDX, IDC_ALIGN_BLEND, AlignBlendCtrl);
DDX_Control(pDX, IDC_CLAMP, ClampCtrl);
DDX_Control(pDX, IDC_SCROLLBAR, ScrollBarCtrl);
DDX_Control(pDX, IDC_OFFSET_SPIN, OffsetSpinCtrl);
DDX_Control(pDX, IDC_OFFSET, OffsetCtrl);
DDX_Control(pDX, IDC_START_TIME_SPIN, StartTimeSpinCtrl);
DDX_Control(pDX, IDC_START_BLEND_SPIN, StartBlendSpinCtrl);
DDX_Control(pDX, IDC_SPEED_FACTOR_SPIN, SpeedFactorSpinCtrl);
DDX_Control(pDX, IDC_SMOOTHNESS_SPIN, SmoothnessSpinCtrl);
DDX_Control(pDX, IDC_END_TIME_SPIN, EndTimeSpinCtrl);
DDX_Control(pDX, IDC_END_BLEND_SPIN, EndBlendSpinCtrl);
DDX_Control(pDX, IDC_START_TIME, StartTimeCtrl);
DDX_Control(pDX, IDC_START_BLEND, StartBlendCtrl);
DDX_Control(pDX, IDC_SPEED_FACTOR, SpeddFactorCtrl);
DDX_Control(pDX, IDC_SMOOTHNESS, SmoothnessCtrl);
DDX_Control(pDX, IDC_END_TIME, EndTimeCtrl);
DDX_Control(pDX, IDC_END_BLEND, EndBlendCtrl);
DDX_Text(pDX, IDC_END_BLEND, EndBlend);
DDX_Text(pDX, IDC_SMOOTHNESS, Smoothness);
DDV_MinMaxFloat(pDX, Smoothness, 0.f, 1.f);
DDX_Text(pDX, IDC_SPEED_FACTOR, SpeedFactor);
DDV_MinMaxFloat(pDX, SpeedFactor, 1.e-002f, 100.f);
DDX_Text(pDX, IDC_START_BLEND, StartBlend);
DDV_MinMaxFloat(pDX, StartBlend, 0.f, 1.f);
DDX_Radio(pDX, IDC_CLAMP, ClampMode);
DDX_Check(pDX, IDC_INVERT_SKELETON_WEIGHT, SkeletonWeightInverted);
DDX_Text(pDX, IDC_OFFSET, Offset);
DDX_Text(pDX, IDC_START_TIME, StartTime);
DDX_Text(pDX, IDC_END_TIME, EndTime);
DDX_Check(pDX, IDC_ENABLE, enable);
//}}AFX_DATA_MAP
}
BEGIN_MESSAGE_MAP(CSlotDlg, CDialog)
//{{AFX_MSG_MAP(CSlotDlg)
ON_WM_PAINT()
ON_NOTIFY(UDN_DELTAPOS, IDC_END_BLEND_SPIN, OnDeltaposEndBlendSpin)
ON_NOTIFY(UDN_DELTAPOS, IDC_END_TIME_SPIN, OnDeltaposEndTimeSpin)
ON_NOTIFY(UDN_DELTAPOS, IDC_SMOOTHNESS_SPIN, OnDeltaposSmoothnessSpin)
ON_NOTIFY(UDN_DELTAPOS, IDC_SPEED_FACTOR_SPIN, OnDeltaposSpeedFactorSpin)
ON_NOTIFY(UDN_DELTAPOS, IDC_START_BLEND_SPIN, OnDeltaposStartBlendSpin)
ON_NOTIFY(UDN_DELTAPOS, IDC_START_TIME_SPIN, OnDeltaposStartTimeSpin)
ON_EN_CHANGE(IDC_END_BLEND, OnChangeEndBlend)
ON_EN_CHANGE(IDC_END_TIME, OnChangeEndTime)
ON_EN_CHANGE(IDC_SMOOTHNESS, OnChangeSmoothness)
ON_EN_CHANGE(IDC_SPEED_FACTOR, OnChangeSpeedFactor)
ON_EN_CHANGE(IDC_START_BLEND, OnChangeStartBlend)
ON_EN_CHANGE(IDC_START_TIME, OnChangeStartTime)
ON_BN_CLICKED(IDC_SET_ANIMATION, OnSetAnimation)
ON_BN_CLICKED(IDC_SET_SKELETON, OnSetSkeleton)
ON_EN_CHANGE(IDC_OFFSET, OnChangeOffset)
ON_NOTIFY(UDN_DELTAPOS, IDC_OFFSET_SPIN, OnDeltaposOffsetSpin)
ON_WM_HSCROLL()
ON_BN_CLICKED(IDC_CLAMP, OnClamp)
ON_BN_CLICKED(IDC_REPEAT, OnRepeat)
ON_BN_CLICKED(IDC_DISABLE, OnDisable)
ON_BN_CLICKED(IDC_ALIGN_BLEND, OnAlignBlend)
ON_WM_DESTROY()
ON_BN_CLICKED(IDC_ENABLE, OnEnable)
ON_BN_CLICKED(IDC_INVERT_SKELETON_WEIGHT, OnInvertSkeletonWeight)
//}}AFX_MSG_MAP
END_MESSAGE_MAP()
/////////////////////////////////////////////////////////////////////////////
// CSlotDlg message handlers
BOOL CSlotDlg::OnInitDialog()
{
CDialog::OnInitDialog();
// Init the blend window
setWindowName ();
return TRUE; // return TRUE unless you set the focus to a control
// EXCEPTION: OCX Property Pages should return FALSE
}
// ***************************************************************************
void CSlotDlg::OnPaint()
{
//CPaintDC dc(this); // device context for painting
PAINTSTRUCT paint;
CDC* pDc=BeginPaint(&paint);
// TODO: Add your message handler code here
// Draw the blend
RECT rect;
GetDlgItem (IDC_DOOMY_BLEND)->GetWindowRect (&rect);
ScreenToClient (&rect);
Blend.OnPaint (rect, pDc, StartBlend, EndBlend, (float)StartTime, (float)EndTime,
Smoothness, StartAnimTime, EndAnimTime, !isEmpty());
// Do not call CDialog::OnPaint() for painting messages
EndPaint(&paint);
}
// ***************************************************************************
void CSlotDlg::OnDeltaposEndBlendSpin(NMHDR* pNMHDR, LRESULT* pResult)
{
NM_UPDOWN* pNMUpDown = (NM_UPDOWN*)pNMHDR;
// TODO: Add your control notification handler code here
*pResult = 0;
UpdateData ();
if (pNMUpDown->iDelta<0)
EndBlend+=DELTA_BLEND;
if (pNMUpDown->iDelta>0)
EndBlend-=DELTA_BLEND;
clamp (EndBlend, 0.f, 1.f);
refresh (FALSE);
}
// ***************************************************************************
void CSlotDlg::OnDeltaposEndTimeSpin(NMHDR* pNMHDR, LRESULT* pResult)
{
NM_UPDOWN* pNMUpDown = (NM_UPDOWN*)pNMHDR;
// TODO: Add your control notification handler code here
*pResult = 0;
UpdateData ();
if (pNMUpDown->iDelta<0)
EndTime++;
if (pNMUpDown->iDelta>0)
EndTime--;
clamp (EndTime, (int)StartAnimTime, (int)EndAnimTime);
if (EndTime<StartTime)
StartTime=EndTime;
refresh (FALSE);
}
// ***************************************************************************
void CSlotDlg::OnDeltaposSmoothnessSpin(NMHDR* pNMHDR, LRESULT* pResult)
{
NM_UPDOWN* pNMUpDown = (NM_UPDOWN*)pNMHDR;
// TODO: Add your control notification handler code here
*pResult = 0;
UpdateData ();
if (pNMUpDown->iDelta<0)
Smoothness+=DELTA_BLEND;
if (pNMUpDown->iDelta>0)
Smoothness-=DELTA_BLEND;
clamp (Smoothness, 0.f, 1.f);
refresh (FALSE);
}
// ***************************************************************************
void CSlotDlg::OnDeltaposSpeedFactorSpin(NMHDR* pNMHDR, LRESULT* pResult)
{
NM_UPDOWN* pNMUpDown = (NM_UPDOWN*)pNMHDR;
// TODO: Add your control notification handler code here
*pResult = 0;
UpdateData ();
if (pNMUpDown->iDelta<0)
SpeedFactor+=DELTA_MUL;
if (pNMUpDown->iDelta>0)
SpeedFactor-=DELTA_MUL;
clamp (SpeedFactor, 0.01f, 100.f);
refresh (FALSE);
validateTime ();
updateScrollBar ();
}
// ***************************************************************************
void CSlotDlg::OnDeltaposStartBlendSpin(NMHDR* pNMHDR, LRESULT* pResult)
{
NM_UPDOWN* pNMUpDown = (NM_UPDOWN*)pNMHDR;
// TODO: Add your control notification handler code here
*pResult = 0;
UpdateData ();
if (pNMUpDown->iDelta<0)
StartBlend+=DELTA_BLEND;
if (pNMUpDown->iDelta>0)
StartBlend-=DELTA_BLEND;
clamp (StartBlend, 0.f, 1.f);
refresh (FALSE);
}
// ***************************************************************************
void CSlotDlg::OnDeltaposStartTimeSpin(NMHDR* pNMHDR, LRESULT* pResult)
{
NM_UPDOWN* pNMUpDown = (NM_UPDOWN*)pNMHDR;
// TODO: Add your control notification handler code here
*pResult = 0;
UpdateData ();
if (pNMUpDown->iDelta<0)
StartTime++;
if (pNMUpDown->iDelta>0)
StartTime--;
clamp (StartTime, (int)StartAnimTime, (int)EndAnimTime);
if (EndTime<StartTime)
EndTime=StartTime;
refresh (FALSE);
}
// ***************************************************************************
void CSlotDlg::OnChangeEndBlend()
{
// TODO: If this is a RICHEDIT control, the control will not
// send this notification unless you override the CDialog::OnInitDialog()
// function and call CRichEditCtrl().SetEventMask()
// with the ENM_CHANGE flag ORed into the mask.
// TODO: Add your control notification handler code here
UpdateData ();
clamp (EndBlend, 0.f, 1.f);
refresh (FALSE);
}
// ***************************************************************************
void CSlotDlg::OnChangeEndTime()
{
// TODO: If this is a RICHEDIT control, the control will not
// send this notification unless you override the CDialog::OnInitDialog()
// function and call CRichEditCtrl().SetEventMask()
// with the ENM_CHANGE flag ORed into the mask.
// TODO: Add your control notification handler code here
UpdateData ();
clamp (EndTime, (int)StartAnimTime, (int)EndAnimTime);
if (EndTime<StartTime)
StartTime=EndTime;
refresh (FALSE);
}
// ***************************************************************************
void CSlotDlg::OnChangeSmoothness()
{
// TODO: If this is a RICHEDIT control, the control will not
// send this notification unless you override the CDialog::OnInitDialog()
// function and call CRichEditCtrl().SetEventMask()
// with the ENM_CHANGE flag ORed into the mask.
// TODO: Add your control notification handler code here
UpdateData ();
clamp (Smoothness, 0.f, 1.f);
refresh (FALSE);
}
// ***************************************************************************
void CSlotDlg::OnChangeSpeedFactor()
{
// TODO: If this is a RICHEDIT control, the control will not
// send this notification unless you override the CDialog::OnInitDialog()
// function and call CRichEditCtrl().SetEventMask()
// with the ENM_CHANGE flag ORed into the mask.
// TODO: Add your control notification handler code here
UpdateData ();
clamp (SpeedFactor, 0.01f, 100.f);
refresh (FALSE);
validateTime ();
updateScrollBar ();
}
// ***************************************************************************
void CSlotDlg::OnChangeStartBlend()
{
// TODO: If this is a RICHEDIT control, the control will not
// send this notification unless you override the CDialog::OnInitDialog()
// function and call CRichEditCtrl().SetEventMask()
// with the ENM_CHANGE flag ORed into the mask.
// TODO: Add your control notification handler code here
UpdateData ();
clamp (StartBlend, 0.f, 1.f);
refresh (FALSE);
}
// ***************************************************************************
void CSlotDlg::OnChangeStartTime()
{
// TODO: If this is a RICHEDIT control, the control will not
// send this notification unless you override the CDialog::OnInitDialog()
// function and call CRichEditCtrl().SetEventMask()
// with the ENM_CHANGE flag ORed into the mask.
// TODO: Add your control notification handler code here
UpdateData ();
clamp (StartTime, (int)StartAnimTime, (int)EndAnimTime);
if (EndTime<StartTime)
EndTime=StartTime;
refresh (FALSE);
}
// ***************************************************************************
void CSlotDlg::OnSetAnimation()
{
// List of string
std::vector<std::string> vectString;
// Build a list of string
for (uint a=0; a<getAnimationSetPointer()->getNumAnimation (); a++)
vectString.push_back (getAnimationSetPointer()->getAnimationName (a));
// Select a string
CSelectString select (vectString, "Select your animation", this, true);
if (select.DoModal ()==IDOK)
{
// Set the animation
if (select.Selection!=-1)
{
getSlotInformation ()->Animation = vectString[select.Selection];
validateTime ();
updateScrollBar ();
}
else
getSlotInformation ()->Animation = "";
}
refresh (TRUE);
}
// ***************************************************************************
void CSlotDlg::OnSetSkeleton()
{
// List of string
std::vector<std::string> vectString;
// Build a list of string
for (uint s=0; s<getAnimationSetPointer()->getNumSkeletonWeight (); s++)
vectString.push_back (getAnimationSetPointer()->getSkeletonWeightName (s));
// Select a string
CSelectString select (vectString, "Select your skeleton weight template", this, true);
if (select.DoModal ()==IDOK)
{
// Set the animation
if (select.Selection!=-1)
getSlotInformation ()->Skeleton = vectString[select.Selection].c_str();
else
getSlotInformation ()->Skeleton = "";
setWindowName ();
Invalidate ();
}
}
// ***************************************************************************
void CSlotDlg::setWindowName ()
{
char tmp[512];
_snprintf (tmp, 512, "Slot %d : ", Id);
if (isEmpty())
strcat (tmp, "empty");
else
strcat (tmp, getSlotInformation ()->Animation .c_str());
CSlotInfo *information = getSlotInformation ();
if (information)
{
std::string SkeletonName = information->Skeleton;
if (SkeletonName != "")
{
strcat (tmp, " (");
strcat (tmp, SkeletonName.c_str());
strcat (tmp, ")");
}
}
GetDlgItem (IDC_SLOT_NAME)->SetWindowText (tmp);
}
// ***************************************************************************
void CSlotDlg::OnChangeOffset()
{
// TODO: If this is a RICHEDIT control, the control will not
// send this notification unless you override the CDialog::OnInitDialog()
// function and call CRichEditCtrl().SetEventMask()
// with the ENM_CHANGE flag ORed into the mask.
// TODO: Add your control notification handler code here
validateTime ();
updateScrollBar ();
refresh (FALSE);
}
// ***************************************************************************
void CSlotDlg::OnDeltaposOffsetSpin(NMHDR* pNMHDR, LRESULT* pResult)
{
NM_UPDOWN* pNMUpDown = (NM_UPDOWN*)pNMHDR;
// TODO: Add your control notification handler code here
UpdateData ();
if (pNMUpDown->iDelta<0)
Offset++;
if (pNMUpDown->iDelta>0)
Offset--;
validateTime ();
updateScrollBar ();
*pResult = 0;
refresh (FALSE);
}
// ***************************************************************************
void CSlotDlg::validateTime ()
{
bool reinit=false;
if ((float)Offset<StartAnimTime)
{
StartAnimTime=(float)Offset;
reinit=true;
}
if ((float)Offset+AnimationLength/SpeedFactor>EndAnimTime)
{
EndAnimTime=(float)Offset+AnimationLength/SpeedFactor;
reinit=true;
}
if (reinit)
MainDlg->setAnimTime (StartAnimTime, EndAnimTime);
}
// ***************************************************************************
void CSlotDlg::updateScrollBar ()
{
// Scroll info
SCROLLINFO info;
memset (&info, 0, sizeof (info));
// Fill the infos
info.fMask=SIF_ALL;
info.nMin=0;
info.nMax=10000;
if (fabs(EndAnimTime-StartAnimTime)<0.00001f)
{
info.nPage=1;
info.nPos=0;
}
else
{
info.nPage=(int)(10000.f*(AnimationLength/SpeedFactor)/(EndAnimTime-StartAnimTime));
info.nPos=(int)(10000.f*((float)Offset-StartAnimTime)/(EndAnimTime-StartAnimTime));
}
// Set scrollbar infos
ScrollBarCtrl.SetScrollInfo (&info, TRUE);
// Invalidate blend bar
RECT bar;
GetDlgItem (IDC_DOOMY_BLEND)->GetWindowRect (&bar);
ScreenToClient (&bar);
InvalidateRect (&bar);
}
// ***************************************************************************
void CSlotDlg::OnHScroll(UINT nSBCode, UINT nPos, CScrollBar* pScrollBar)
{
// TODO: Add your message handler code here and/or call default
if (pScrollBar==GetDlgItem (IDC_SCROLLBAR))
{
// Only drag and drop
if (nSBCode==SB_THUMBTRACK)
{
int DeltaOffset=Offset;
UpdateData ();
Offset=(int)((EndAnimTime-StartAnimTime)*(float)nPos/10000.f+StartAnimTime);
DeltaOffset=Offset-DeltaOffset;
StartTime+=DeltaOffset;
EndTime+=DeltaOffset;
refresh (FALSE);
updateScrollBar ();
}
}
CDialog::OnHScroll(nSBCode, nPos, pScrollBar);
}
// ***************************************************************************
void CSlotDlg::setAnimTime (float animStart, float animEnd)
{
StartAnimTime=animStart;
EndAnimTime=animEnd;
updateScrollBar ();
computeLength ();
}
// ***************************************************************************
float CSlotDlg::getTimeIncrement ()
{
return (EndAnimTime-StartAnimTime)/100.f;
}
// ***************************************************************************
void CSlotDlg::OnClamp()
{
refresh (FALSE);
}
// ***************************************************************************
void CSlotDlg::OnRepeat()
{
refresh (FALSE);
}
// ***************************************************************************
void CSlotDlg::OnDisable()
{
refresh (FALSE);
}
// ***************************************************************************
void CSlotDlg::OnAlignBlend()
{
// Refresh data
UpdateData ();
// Change some of them
StartTime=Offset;
EndTime=(int)((float)Offset+AnimationLength/SpeedFactor);
// Invalidate UI
refresh (FALSE);
// Invalidate blend bar
RECT bar;
GetDlgItem (IDC_DOOMY_BLEND)->GetWindowRect (&bar);
ScreenToClient (&bar);
InvalidateRect (&bar);
}
// ***************************************************************************
float CSlotDlg::getStartTime ()
{
return (float)StartTime/MainDlg->getFrameRate ();
}
// ***************************************************************************
float CSlotDlg::getEndTime ()
{
return (float)EndTime/MainDlg->getFrameRate ();
}
// ***************************************************************************
void CSlotDlg::computeLength ()
{
if (getAnimationPointer())
AnimationLength=(getAnimationPointer()->getEndTime()-getAnimationPointer()->getBeginTime())*MainDlg->getFrameRate();
}
// ***************************************************************************
void CSlotDlg::OnDestroy()
{
// TODO: Add your message handler code here
CDialog::OnDestroy();
}
// ***************************************************************************
void CSlotDlg::refresh (BOOL update)
{
CSlotInfo *slotInfo = getSlotInformation ();
if (update)
{
CDialog::UpdateData (update);
// Update from slot information
if (slotInfo)
{
EndBlend = slotInfo->EndBlend;
Smoothness = slotInfo->Smoothness;
SpeedFactor = slotInfo->SpeedFactor;
StartBlend = slotInfo->StartBlend;
ClampMode = slotInfo->ClampMode;
SkeletonWeightInverted = slotInfo->SkeletonInverted?TRUE:FALSE;
StartTime = slotInfo->StartTime;
Offset = slotInfo->Offset;
EndTime = slotInfo->EndTime;
enable = slotInfo->Enable?TRUE:FALSE;
}
else
{
EndBlend = 1;
Smoothness = 1;
SpeedFactor = 1;
StartBlend = 1;
ClampMode = 0;
SkeletonWeightInverted = FALSE;
StartTime = 0;
Offset = 0;
EndTime = 0;
enable = TRUE;
}
// Compute length
computeLength ();
// Slot frozen
bool frozen = (slotInfo == NULL) || (getAnimationPointer () == NULL);
// Enable / disable windows
OffsetCtrl.EnableWindow (!frozen);
StartTimeCtrl.EnableWindow (!frozen);
StartBlendCtrl.EnableWindow (!frozen);
SpeddFactorCtrl.EnableWindow (!frozen);
SmoothnessCtrl.EnableWindow (!frozen);
EndTimeCtrl.EnableWindow (!frozen);
EndBlendCtrl.EnableWindow (!frozen);
OffsetSpinCtrl.EnableWindow (!frozen);
StartTimeSpinCtrl.EnableWindow (!frozen);
StartBlendSpinCtrl.EnableWindow (!frozen);
SpeedFactorSpinCtrl.EnableWindow (!frozen);
SmoothnessSpinCtrl.EnableWindow (!frozen);
EndTimeSpinCtrl.EnableWindow (!frozen);
EndBlendSpinCtrl.EnableWindow (!frozen);
ScrollBarCtrl.EnableWindow (!frozen);
AlignBlendCtrl.EnableWindow (!frozen);
InvertSkeletonWeightCtrl.EnableWindow (!frozen);
GetDlgItem (IDC_CLAMP)->EnableWindow (!frozen);
GetDlgItem (IDC_REPEAT)->EnableWindow (!frozen);
GetDlgItem (IDC_DISABLE)->EnableWindow (!frozen);
setWindowName ();
updateScrollBar ();
RECT bar;
GetDlgItem (IDC_DOOMY_BLEND)->GetWindowRect (&bar);
ScreenToClient (&bar);
InvalidateRect (&bar);
CDialog::UpdateData (FALSE);
}
else
{
CDialog::UpdateData (TRUE);
// Update from slot information
slotInfo->EndBlend = EndBlend;
slotInfo->Smoothness = Smoothness;
slotInfo->SpeedFactor = SpeedFactor;
slotInfo->StartBlend = StartBlend;
slotInfo->ClampMode = ClampMode;
slotInfo->SkeletonInverted = SkeletonWeightInverted?true:false;
slotInfo->StartTime = StartTime;
slotInfo->Offset = Offset;
slotInfo->EndTime = EndTime;
slotInfo->Enable = enable?true:false;
CDialog::UpdateData (update);
RECT bar;
GetDlgItem (IDC_DOOMY_BLEND)->GetWindowRect (&bar);
ScreenToClient (&bar);
InvalidateRect (&bar);
}
}
// ***************************************************************************
const CAnimation *CSlotDlg::getAnimationPointer () const
{
// The animation pointer
const CAnimation *pointer = NULL;
// Get an instance pointer
CInstanceInfo *instance = getInstanceInformation ();
if (instance)
{
// Get a slot pointer
CSlotInfo *slot = getSlotInformation ();
uint animId = instance->AnimationSet.getAnimationIdByName (slot->Animation);
if (animId != CAnimationSet::NotFound)
{
// Get the animation pointer
pointer = instance->AnimationSet.getAnimation (animId);
}
}
// Return the pointer
return pointer;
}
// ***************************************************************************
const CSkeletonWeight *CSlotDlg::getSkeletonPointer () const
{
// The skeleton pointer
const CSkeletonWeight *pointer = NULL;
// Get an instance pointer
CInstanceInfo *instance = getInstanceInformation ();
if (instance)
{
// Get a slot pointer
CSlotInfo *slot = getSlotInformation ();
uint animId = instance->AnimationSet.getSkeletonWeightIdByName (slot->Skeleton);
if (animId != CAnimationSet::NotFound)
{
// Get the skeleton pointer
pointer = instance->AnimationSet.getSkeletonWeight (animId);
}
}
// Return the pointer
return pointer;
}
// ***************************************************************************
const NL3D::CAnimationSet *CSlotDlg::getAnimationSetPointer () const
{
// Get an instance pointer
CInstanceInfo *instance = getInstanceInformation ();
if (instance)
return &instance->AnimationSet;
else
return NULL;
}
// ***************************************************************************
CSlotInfo *CSlotDlg::getSlotInformation () const
{
// Get the instance
CInstanceInfo *instance = getInstanceInformation ();
if (instance)
{
return &instance->Saved.SlotInfo[Id];
}
else
return NULL;
}
// ***************************************************************************
CInstanceInfo *CSlotDlg::getInstanceInformation () const
{
if (MainDlg)
{
uint instance = MainDlg->getEditedObject ();
if (instance != 0xffffffff)
return MainDlg->getInstance (instance);
}
return NULL;
}
// ***************************************************************************
bool CSlotDlg::isEmpty()
{
return (getInstanceInformation () == NULL) || (getAnimationPointer () == NULL);
}
// ***************************************************************************
void CSlotDlg::OnEnable()
{
refresh (FALSE);
}
// ***************************************************************************
void CSlotDlg::OnInvertSkeletonWeight()
{
refresh (FALSE);
}