Cronocide/Descent3
1
0
Fork 0
mirror of https://github.com/kevinbentley/Descent3.git synced 2025-01-22 19:55:23 +00:00
Code Issues Packages Projects Releases Wiki Activity
15dce81bd1
Descent3/legacy/editor/PropertyPhysicsDlg.cpp
Louis Gombert 31b63bb79f Add license to legacy utilities 
Generated using script:
for file in \$(find ./legacy -type f | \grep -E "\.cpp|\.h")
do
  mv $file temp.xxx
  cp gplheader $file
  cat temp.xxx >> $file
done
2024-04-20 18:33:12 +02:00

582 lines
15 KiB
C++
Raw Blame History

/*
* Descent 3
* Copyright (C) 2024 Parallax Software
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU 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 General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
// PropertyPhysicsDlg.cpp : implementation file
//
#include "stdafx.h"
#include "editor.h"
#include "PropertyPhysicsDlg.h"
#include "object.h"
#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif
/////////////////////////////////////////////////////////////////////////////
// CPropertyPhysicsDlg dialog
CPropertyPhysicsDlg::CPropertyPhysicsDlg(CWnd* pParent /*=NULL*/)
: CKeypadDialog(CPropertyPhysicsDlg::IDD, pParent)
{
//{{AFX_DATA_INIT(CPropertyPhysicsDlg)
m_bBounce = FALSE;
m_fDrag = 0.0f;
m_fFullRotThrust = 0.0f;
m_fFullThrust = 0.0f;
m_bGravity = FALSE;
m_bLevelling = FALSE;
m_bMagnetism = FALSE;
m_fMass = 0.0f;
m_fMaxTurnrollrate = 0.0f;
m_iNumBounces = 0;
m_bPersistent = FALSE;
m_fRotDrag = 0.0f;
m_fRotThrustX = 0.0f;
m_fRotThrustY = 0.0f;
m_fRotThrustZ = 0.0f;
m_fRotVelX = 0.0f;
m_fRotVelY = 0.0f;
m_fRotVelZ = 0.0f;
m_bSticks = FALSE;
m_fThrustX = 0.0f;
m_fThrustY = 0.0f;
m_fThrustZ = 0.0f;
m_bTurnroll = FALSE;
m_fTurnrollRatio = 0.0f;
m_sTurnrollAngle = 0;
m_bUsesThrust = FALSE;
m_fVelocityX = 0.0f;
m_fVelocityY = 0.0f;
m_fVelocityZ = 0.0f;
m_bWiggle = FALSE;
m_fWiggleAmplitude = 0.0f;
m_fWigglesPerSecond = 0.0f;
m_bWind = FALSE;
m_bUnlimitedBounce = FALSE;
//}}AFX_DATA_INIT
}
void CPropertyPhysicsDlg::DoDataExchange(CDataExchange* pDX)
{
CDialog::DoDataExchange(pDX);
//{{AFX_DATA_MAP(CPropertyPhysicsDlg)
DDX_Check(pDX, IDC_PBOUNCE, m_bBounce);
DDX_Text(pDX, IDC_PDRAG, m_fDrag);
DDX_Text(pDX, IDC_PFULL_ROTTHRUST, m_fFullRotThrust);
DDX_Text(pDX, IDC_PFULL_THRUST, m_fFullThrust);
DDX_Check(pDX, IDC_PGRAVITY, m_bGravity);
DDX_Check(pDX, IDC_PLEVELLING, m_bLevelling);
DDX_Check(pDX, IDC_PMAGNETISM, m_bMagnetism);
DDX_Text(pDX, IDC_PMASS, m_fMass);
DDX_Text(pDX, IDC_PMAX_TURNROLL_RATE, m_fMaxTurnrollrate);
DDX_Text(pDX, IDC_PNUM_BOUNCES, m_iNumBounces);
DDX_Check(pDX, IDC_PPERSISTENT, m_bPersistent);
DDX_Text(pDX, IDC_PROTDRAG, m_fRotDrag);
DDX_Text(pDX, IDC_PROTTHRUST_X, m_fRotThrustX);
DDX_Text(pDX, IDC_PROTTHRUST_Y, m_fRotThrustY);
DDX_Text(pDX, IDC_PROTTHRUST_Z, m_fRotThrustZ);
DDX_Text(pDX, IDC_PROTVEL_X, m_fRotVelX);
DDX_Text(pDX, IDC_PROTVEL_Y, m_fRotVelY);
DDX_Text(pDX, IDC_PROTVEL_Z, m_fRotVelZ);
DDX_Check(pDX, IDC_PSTICKS, m_bSticks);
DDX_Text(pDX, IDC_PTHRUST_X, m_fThrustX);
DDX_Text(pDX, IDC_PTHRUST_Y, m_fThrustY);
DDX_Text(pDX, IDC_PTHRUST_Z, m_fThrustZ);
DDX_Check(pDX, IDC_PTURNROLL, m_bTurnroll);
DDX_Text(pDX, IDC_PTURNROLL_RATIO, m_fTurnrollRatio);
DDX_Text(pDX, IDC_PTURNROLLANGLE, m_sTurnrollAngle);
DDX_Check(pDX, IDC_PUSESTHRUST, m_bUsesThrust);
DDX_Text(pDX, IDC_PVELOCITY_X, m_fVelocityX);
DDX_Text(pDX, IDC_PVELOCITY_Y, m_fVelocityY);
DDX_Text(pDX, IDC_PVELOCITY_Z, m_fVelocityZ);
DDX_Check(pDX, IDC_PWIGGLE, m_bWiggle);
DDX_Text(pDX, IDC_PWIGGLE_AMPLITUDE, m_fWiggleAmplitude);
DDX_Text(pDX, IDC_PWIGGLES_PER_SECOND, m_fWigglesPerSecond);
DDX_Check(pDX, IDC_PWIND, m_bWind);
DDX_Check(pDX, IDC_PUNLIMBOUNCE, m_bUnlimitedBounce);
//}}AFX_DATA_MAP
}
BEGIN_MESSAGE_MAP(CPropertyPhysicsDlg, CDialog)
//{{AFX_MSG_MAP(CPropertyPhysicsDlg)
ON_BN_CLICKED(IDC_PTURNROLL, OnPturnroll)
ON_BN_CLICKED(IDC_PLEVELLING, OnPlevelling)
ON_BN_CLICKED(IDC_PBOUNCE, OnPbounce)
ON_BN_CLICKED(IDC_PWIGGLE, OnPwiggle)
ON_BN_CLICKED(IDC_PSTICKS, OnPsticks)
ON_BN_CLICKED(IDC_PPERSISTENT, OnPpersistent)
ON_BN_CLICKED(IDC_PUSESTHRUST, OnPusesthrust)
ON_BN_CLICKED(IDC_PGRAVITY, OnPgravity)
ON_BN_CLICKED(IDC_PMAGNETISM, OnPmagnetism)
ON_BN_CLICKED(IDC_PWIND, OnPwind)
ON_BN_CLICKED(IDC_PUNLIMBOUNCE, OnPunlimbounce)
//}}AFX_MSG_MAP
END_MESSAGE_MAP()
/////////////////////////////////////////////////////////////////////////////
// CPropertyPhysicsDlg message handlers
void CPropertyPhysicsDlg::OnPturnroll()
{
// TODO: Add your control notification handler code here
if(m_bTurnroll)
{
m_bTurnroll=false;
Disable(IDC_PTURNROLL);
}
else
{
m_bTurnroll=true;
Enable(IDC_PTURNROLL);
}
}
void CPropertyPhysicsDlg::OnPlevelling()
{
// TODO: Add your control notification handler code here
if(m_bLevelling)
{
m_bLevelling=false;
Disable(IDC_PLEVELLING);
}
else
{
m_bLevelling=true;
Enable(IDC_PLEVELLING);
}
}
void CPropertyPhysicsDlg::OnPbounce()
{
// TODO: Add your control notification handler code here
if(m_bBounce)
{
m_bBounce=false;
Disable(IDC_PBOUNCE);
}
else
{
m_bBounce=true;
Enable(IDC_PBOUNCE);
}
}
void CPropertyPhysicsDlg::OnPwiggle()
{
// TODO: Add your control notification handler code here
if(m_bWiggle)
{
m_bWiggle=false;
Disable(IDC_PWIGGLE);
}
else
{
m_bWiggle=true;
Enable(IDC_PWIGGLE);
}
}
void CPropertyPhysicsDlg::OnPsticks()
{
// TODO: Add your control notification handler code here
if(m_bSticks)
{
m_bSticks=false;
Disable(IDC_PSTICKS);
}
else
{
m_bSticks=true;
Enable(IDC_PSTICKS);
}
}
void CPropertyPhysicsDlg::OnPpersistent()
{
// TODO: Add your control notification handler code here
if(m_bPersistent)
{
m_bPersistent=false;
Disable(IDC_PPERSISTENT);
}
else
{
m_bPersistent=true;
Enable(IDC_PPERSISTENT);
}
}
void CPropertyPhysicsDlg::OnPusesthrust()
{
// TODO: Add your control notification handler code here
if(m_bUsesThrust)
{
m_bUsesThrust=false;
Disable(IDC_PUSESTHRUST);
}
else
{
m_bUsesThrust=true;
Enable(IDC_PUSESTHRUST);
}
}
void CPropertyPhysicsDlg::OnPgravity()
{
// TODO: Add your control notification handler code here
if(m_bGravity)
{
m_bGravity=false;
Disable(IDC_PGRAVITY);
}
else
{
m_bGravity=true;
Enable(IDC_PGRAVITY);
}
}
void CPropertyPhysicsDlg::OnPmagnetism()
{
// TODO: Add your control notification handler code here
if(m_bMagnetism)
{
m_bMagnetism=false;
Disable(IDC_PMAGNETISM);
}
else
{
m_bMagnetism=true;
Enable(IDC_PMAGNETISM);
}
}
void CPropertyPhysicsDlg::OnPwind()
{
// TODO: Add your control notification handler code here
if(m_bWind)
{
m_bWind=false;
Disable(IDC_PWIND);
}
else
{
m_bWind=true;
Enable(IDC_PWIND);
}
}
BOOL CPropertyPhysicsDlg::OnInitDialog()
{
// TODO: Add extra initialization here
object *curobj;
curobj=&Objects[Cur_object_index];
m_fVelocityX=curobj->mtype.phys_info.velocity.x;
m_fVelocityY=curobj->mtype.phys_info.velocity.y;
m_fVelocityZ=curobj->mtype.phys_info.velocity.z;
m_fThrustX=curobj->mtype.phys_info.thrust.x;
m_fThrustY=curobj->mtype.phys_info.thrust.y;
m_fThrustZ=curobj->mtype.phys_info.thrust.z;
m_fRotVelX=curobj->mtype.phys_info.rotvel.x;
m_fRotVelY=curobj->mtype.phys_info.rotvel.y;
m_fRotVelZ=curobj->mtype.phys_info.rotvel.z;
m_fRotThrustX=curobj->mtype.phys_info.rotthrust.x;
m_fRotThrustY=curobj->mtype.phys_info.rotthrust.y;
m_fRotThrustZ=curobj->mtype.phys_info.rotthrust.z;
m_sTurnrollAngle=curobj->mtype.phys_info.turnroll;
m_iNumBounces=curobj->mtype.phys_info.num_bounces;
if(m_iNumBounces==-1) m_bUnlimitedBounce=true;
m_fMass=curobj->mtype.phys_info.mass;
m_fDrag=curobj->mtype.phys_info.drag;
m_fRotDrag=curobj->mtype.phys_info.rotdrag;
m_fFullThrust=curobj->mtype.phys_info.full_thrust;
m_fFullRotThrust=curobj->mtype.phys_info.full_rotthrust;
m_fMaxTurnrollrate=curobj->mtype.phys_info.max_turnroll_rate;
m_fTurnrollRatio=curobj->mtype.phys_info.turnroll_ratio;
m_fWiggleAmplitude=curobj->mtype.phys_info.wiggle_amplitude;
m_fWigglesPerSecond=curobj->mtype.phys_info.wiggles_per_sec;
if(curobj->mtype.phys_info.flags&PF_TURNROLL) m_bTurnroll=true;
if(curobj->mtype.phys_info.flags&PF_LEVELING) m_bLevelling=true;
if(curobj->mtype.phys_info.flags&PF_BOUNCE) m_bBounce=true;
if(curobj->mtype.phys_info.flags&PF_WIGGLE) m_bWiggle=true;
if(curobj->mtype.phys_info.flags&PF_STICK) if(m_bBounce) m_bSticks=false; else m_bSticks=true;
if(curobj->mtype.phys_info.flags&PF_PERSISTENT) m_bPersistent=true;
if(curobj->mtype.phys_info.flags&PF_USES_THRUST) m_bUsesThrust=true;
if(curobj->mtype.phys_info.flags&PF_GRAVITY) m_bGravity=true;
if(curobj->mtype.phys_info.flags&PF_IGNORE_OWN_CONC_FORCES) m_bMagnetism=true;
if(curobj->mtype.phys_info.flags&PF_WIND) m_bWind=true;
CDialog::OnInitDialog();
UpdateCheckBoxes();
return TRUE; // return TRUE unless you set the focus to a control
// EXCEPTION: OCX Property Pages should return FALSE
}
void CPropertyPhysicsDlg::Enable(UINT control)
{
CWnd *box;
switch(control)
{
case IDC_PTURNROLL:
{
box=(CWnd *)GetDlgItem(IDC_PTURNROLLANGLE);
box->EnableWindow(true);
box=(CWnd *)GetDlgItem(IDC_PMAX_TURNROLL_RATE);
box->EnableWindow(true);
box=(CWnd *)GetDlgItem(IDC_PTURNROLL_RATIO);
box->EnableWindow(true);
break;
}
case IDC_PLEVELLING: break;
case IDC_PBOUNCE:
{
box=(CWnd *)GetDlgItem(IDC_PUNLIMBOUNCE);
box->EnableWindow(true);
if(!m_bUnlimitedBounce)
{
box=(CWnd *)GetDlgItem(IDC_PNUM_BOUNCES);
box->EnableWindow(true);
}
else
{
box=(CWnd *)GetDlgItem(IDC_PNUM_BOUNCES);
box->EnableWindow(false);
}
box=(CWnd *)GetDlgItem(IDC_PSTICKS);
box->EnableWindow(false);
break;
}
case IDC_PWIGGLE:
{
box=(CWnd *)GetDlgItem(IDC_PWIGGLE_AMPLITUDE);
box->EnableWindow(true);
box=(CWnd *)GetDlgItem(IDC_PWIGGLES_PER_SECOND);
box->EnableWindow(true);
break;
}
case IDC_PSTICKS:
{
box=(CWnd *)GetDlgItem(IDC_PSTICKS);
box->EnableWindow(true);
box=(CWnd *)GetDlgItem(IDC_PBOUNCE);
box->EnableWindow(false);
box=(CWnd *)GetDlgItem(IDC_PNUM_BOUNCES);
box->EnableWindow(false);
box=(CWnd *)GetDlgItem(IDC_PUNLIMBOUNCE);
box->EnableWindow(false);
break;
}
case IDC_PPERSISTENT: break;
case IDC_PUSESTHRUST:
{
box=(CWnd *)GetDlgItem(IDC_PTHRUST_X);
box->EnableWindow(true);
box=(CWnd *)GetDlgItem(IDC_PTHRUST_Y);
box->EnableWindow(true);
box=(CWnd *)GetDlgItem(IDC_PTHRUST_Z);
box->EnableWindow(true);
box=(CWnd *)GetDlgItem(IDC_PROTTHRUST_X);
box->EnableWindow(true);
box=(CWnd *)GetDlgItem(IDC_PROTTHRUST_Y);
box->EnableWindow(true);
box=(CWnd *)GetDlgItem(IDC_PROTTHRUST_Z);
box->EnableWindow(true);
box=(CWnd *)GetDlgItem(IDC_PFULL_THRUST);
box->EnableWindow(true);
box=(CWnd *)GetDlgItem(IDC_PFULL_ROTTHRUST);
box->EnableWindow(true);
box=(CWnd *)GetDlgItem(IDC_PTURNROLL);
box->EnableWindow(true);
if(m_bTurnroll)
{
box=(CWnd *)GetDlgItem(IDC_PTURNROLLANGLE);
box->EnableWindow(true);
box=(CWnd *)GetDlgItem(IDC_PMAX_TURNROLL_RATE);
box->EnableWindow(true);
box=(CWnd *)GetDlgItem(IDC_PTURNROLL_RATIO);
box->EnableWindow(true);
}
break;
}
case IDC_PGRAVITY: break;
case IDC_PMAGNETISM: break;
case IDC_PWIND: break;
case IDC_PUNLIMBOUNCE:
{
if(m_bUnlimitedBounce)
{
box=(CWnd *)GetDlgItem(IDC_PNUM_BOUNCES);
box->EnableWindow(false);
}
else
{
box=(CWnd *)GetDlgItem(IDC_PNUM_BOUNCES);
box->EnableWindow(true);
}
break;
}
}
}
void CPropertyPhysicsDlg::Disable(UINT control)
{
CWnd *box;
switch(control)
{
case IDC_PTURNROLL:
{
box=(CWnd *)GetDlgItem(IDC_PTURNROLLANGLE);
box->EnableWindow(false);
box=(CWnd *)GetDlgItem(IDC_PMAX_TURNROLL_RATE);
box->EnableWindow(false);
box=(CWnd *)GetDlgItem(IDC_PTURNROLL_RATIO);
box->EnableWindow(false);
break;
}
case IDC_PLEVELLING: break;
case IDC_PBOUNCE:
{
box=(CWnd *)GetDlgItem(IDC_PUNLIMBOUNCE);
box->EnableWindow(false);
box=(CWnd *)GetDlgItem(IDC_PNUM_BOUNCES);
box->EnableWindow(false);
box=(CWnd *)GetDlgItem(IDC_PSTICKS);
box->EnableWindow(true);
break;
}
case IDC_PWIGGLE:
{
box=(CWnd *)GetDlgItem(IDC_PWIGGLE_AMPLITUDE);
box->EnableWindow(false);
box=(CWnd *)GetDlgItem(IDC_PWIGGLES_PER_SECOND);
box->EnableWindow(false);
break;
}
case IDC_PSTICKS:
{
box=(CWnd *)GetDlgItem(IDC_PBOUNCE);
box->EnableWindow(true);
if(m_bBounce)
{
box=(CWnd *)GetDlgItem(IDC_PNUM_BOUNCES);
box->EnableWindow(true);
}
else
{
box=(CWnd *)GetDlgItem(IDC_PNUM_BOUNCES);
box->EnableWindow(false);
}
break;
}
case IDC_PPERSISTENT: break;
case IDC_PUSESTHRUST:
{
box=(CWnd *)GetDlgItem(IDC_PTHRUST_X);
box->EnableWindow(false);
box=(CWnd *)GetDlgItem(IDC_PTHRUST_Y);
box->EnableWindow(false);
box=(CWnd *)GetDlgItem(IDC_PTHRUST_Z);
box->EnableWindow(false);
box=(CWnd *)GetDlgItem(IDC_PROTTHRUST_X);
box->EnableWindow(false);
box=(CWnd *)GetDlgItem(IDC_PROTTHRUST_Y);
box->EnableWindow(false);
box=(CWnd *)GetDlgItem(IDC_PROTTHRUST_Z);
box->EnableWindow(false);
box=(CWnd *)GetDlgItem(IDC_PFULL_THRUST);
box->EnableWindow(false);
box=(CWnd *)GetDlgItem(IDC_PFULL_ROTTHRUST);
box->EnableWindow(false);
box=(CWnd *)GetDlgItem(IDC_PTURNROLL);
box->EnableWindow(false);
box=(CWnd *)GetDlgItem(IDC_PTURNROLLANGLE);
box->EnableWindow(false);
box=(CWnd *)GetDlgItem(IDC_PMAX_TURNROLL_RATE);
box->EnableWindow(false);
box=(CWnd *)GetDlgItem(IDC_PTURNROLL_RATIO);
box->EnableWindow(false);
break;
}
case IDC_PGRAVITY: break;
case IDC_PMAGNETISM: break;
case IDC_PWIND: break;
case IDC_PUNLIMBOUNCE:
{
box=(CWnd *)GetDlgItem(IDC_PNUM_BOUNCES);
box->EnableWindow(true);
break;
}
}
}
void CPropertyPhysicsDlg::UpdateCheckBoxes()
{
if(m_bTurnroll) Enable(IDC_PTURNROLL); else Disable(IDC_PTURNROLL);
if(m_bLevelling) Enable(IDC_PLEVELLING); else Disable(IDC_PLEVELLING);
if(m_bBounce) Enable(IDC_PBOUNCE); else Disable(IDC_PBOUNCE);
if(m_bWiggle) Enable(IDC_PWIGGLE); else Disable(IDC_PWIGGLE);
if(m_bSticks) Enable(IDC_PSTICKS); else Disable(IDC_PSTICKS);
if(m_bPersistent) Enable(IDC_PPERSISTENT); else Disable(IDC_PPERSISTENT);
if(m_bUsesThrust) Enable(IDC_PUSESTHRUST); else Disable(IDC_PUSESTHRUST);
if(m_bGravity) Enable(IDC_PGRAVITY); else Disable(IDC_PGRAVITY);
if(m_bMagnetism) Enable(IDC_PMAGNETISM); else Disable(IDC_PMAGNETISM);
if(m_bWind) Enable(IDC_PWIND); else Disable(IDC_PWIND);
if(m_bUnlimitedBounce) Enable(IDC_PUNLIMBOUNCE); else Disable(IDC_PUNLIMBOUNCE);
}
void CPropertyPhysicsDlg::OnPunlimbounce()
{
// TODO: Add your control notification handler code here
if(m_bUnlimitedBounce)
{
m_bUnlimitedBounce=false;
Disable(IDC_PUNLIMBOUNCE);
}
else
{
m_bUnlimitedBounce=true;
Enable(IDC_PUNLIMBOUNCE);
}
}
Reference in New Issue View Git Blame Copy Permalink