mirror of
https://github.com/kevinbentley/Descent3.git
synced 2025-01-22 19:55:23 +00:00
558 lines
15 KiB
C++
558 lines
15 KiB
C++
/*
|
|
* 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);
|
|
}
|
|
}
|