dhewm3/neo/tools/particle/DialogParticleEditor.cpp

/*
===========================================================================

Doom 3 GPL Source Code
Copyright (C) 1999-2011 id Software LLC, a ZeniMax Media company.

This file is part of the Doom 3 GPL Source Code ("Doom 3 Source Code").

Doom 3 Source Code 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.

Doom 3 Source Code 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 Doom 3 Source Code.  If not, see <http://www.gnu.org/licenses/>.

In addition, the Doom 3 Source Code is also subject to certain additional terms. You should have received a copy of these additional terms immediately following the terms and conditions of the GNU General Public License which accompanied the Doom 3 Source Code.  If not, please request a copy in writing from id Software at the address below.

If you have questions concerning this license or the applicable additional terms, you may contact in writing id Software LLC, c/o ZeniMax Media Inc., Suite 120, Rockville, Maryland 20850 USA.

===========================================================================
*/

#include "../../idlib/precompiled.h"
#pragma hdrstop

#include "../../game/game.h"
#include "../../sys/win32/win_local.h"
#include "../../sys/win32/rc/common_resource.h"
#include "../../sys/win32/rc/Radiant_resource.h"
#include "../../sys/win32/rc/ParticleEditor_resource.h"
#include "../comafx/DialogName.h"
#include "../comafx/VectorCtl.h"
#include "../comafx/DialogColorPicker.h"
#include "../radiant/GLWidget.h"
#include "../radiant/PreviewDlg.h"

#include "DialogParticleEditor.h"

#ifdef ID_DEBUG_MEMORY
#undef new
#undef DEBUG_NEW
#define DEBUG_NEW new
#endif

const int StageEnableID[] = {
	IDC_EDIT_MATERIAL,
	IDC_BUTTON_BROWSEMATERIAL,
	IDC_EDIT_ANIMFRAMES,
	IDC_EDIT_ANIMRATE,
	IDC_EDIT_COLOR,
	IDC_BUTTON_BROWSECOLOR,
	IDC_EDIT_FADECOLOR,
	IDC_BUTTON_BROWSEFADECOLOR,
	IDC_EDIT_FADEIN,
	IDC_SLIDER_FADEIN,
	IDC_EDIT_FADEOUT,
	IDC_EDIT_FADEFRACTION,
	IDC_SLIDER_FADEOUT,
	IDC_SLIDER_FADEFRACTION,
	IDC_EDIT_BUNCHING,
	IDC_SLIDER_BUNCHING,
	IDC_EDIT_COUNT,
	IDC_SLIDER_COUNT,
	IDC_EDIT_TIME,
	IDC_SLIDER_TIME,
	IDC_EDIT_CYCLES,
	IDC_EDIT_TIMEOFFSET,
	IDC_EDIT_DEADTIME,
	IDC_CHECK_WORLDGRAVITY,
	IDC_EDIT_GRAVITY,
	IDC_SLIDER_GRAVITY,
	IDC_RADIO_RECT,
	IDC_RADIO_CYLINDER,
	IDC_RADIO_SPHERE,
	IDC_EDIT_OFFSET,
	IDC_EDIT_XSIZE,
	IDC_EDIT_YSIZE,
	IDC_EDIT_ZSIZE,
	IDC_EDIT_RINGOFFSET,
	IDC_RADIO_CONE,
	IDC_RADIO_OUTWARD,
	IDC_EDIT_DIRECTIONPARM,
	IDC_RADIO_AIMED,
	IDC_RADIO_VIEW,
	IDC_RADIO_X,
	IDC_RADIO_Y,
	IDC_RADIO_Z,
	IDC_EDIT_ORIENTATIONPARM1,
	IDC_EDIT_ORIENTATIONPARM2,
	IDC_SLIDER_SPEEDFROM,
	IDC_EDIT_SPEEDFROM,
	IDC_EDIT_SPEEDTO,
	IDC_SLIDER_SPEEDTO,
	IDC_SLIDER_ROTATIONFROM,
	IDC_EDIT_ROTATIONFROM,
	IDC_EDIT_ROTATIONTO,
	IDC_SLIDER_ROTATIONTO,
	IDC_SLIDER_SIZEFROM,
	IDC_EDIT_SIZEFROM,
	IDC_EDIT_SIZETO,
	IDC_SLIDER_SIZETO,
	IDC_SLIDER_ASPECTFROM,
	IDC_EDIT_ASPECTFROM,
	IDC_EDIT_ASPECTTO,
	IDC_SLIDER_ASPECTTO,
	IDC_COMBO_CUSTOMPATH,
	IDC_CHECK_ENTITYCOLOR,
};

const int StageIDCount = sizeof( StageEnableID ) / sizeof ( const int );

const int EditEnableID[] = {
	IDC_BUTTON_XDN,
	IDC_BUTTON_XUP,
	IDC_BUTTON_YUP,
	IDC_BUTTON_YDN,
	IDC_BUTTON_ZUP,
	IDC_BUTTON_ZDN,
	IDC_BUTTON_DROPEMITTER,
	IDC_BUTTON_VECTOR,
	IDC_BUTTON_BROWSECOLOR_ENTITY
};

const int EditIDCount = sizeof ( EditEnableID ) / sizeof ( const int );


CDialogParticleEditor *g_ParticleDialog = NULL;


/*
================
ParticleEditorInit
================
*/
void ParticleEditorInit( const idDict *spawnArgs ) {

	if ( renderSystem->IsFullScreen() ) {
		common->Printf( "Cannot run the particle editor in fullscreen mode.\n"
			"Set r_fullscreen to 0 and vid_restart.\n" );
		return;
	}

	if ( g_ParticleDialog == NULL ) {
		InitAfx();
		g_ParticleDialog = new CDialogParticleEditor();
	}

	if ( g_ParticleDialog->GetSafeHwnd() == NULL) {
		g_ParticleDialog->Create( IDD_DIALOG_PARTICLE_EDITOR );
		/*
		// FIXME: restore position
		CRect rct;
		g_AFDialog->SetWindowPos( NULL, rct.left, rct.top, 0, 0, SWP_NOSIZE );
		*/
	}

	idKeyInput::ClearStates();

	g_ParticleDialog->ShowWindow( SW_SHOW );
	g_ParticleDialog->SetFocus();

	if ( spawnArgs ) {
		idStr str = spawnArgs->GetString( "model" );
		str.StripFileExtension();
		g_ParticleDialog->SelectParticle( str );
		g_ParticleDialog->SetParticleVisualization( static_cast<int>( CDialogParticleEditor::SELECTED ) );
	}

	cvarSystem->SetCVarBool( "r_useCachedDynamicModels", false );
}


/*
================
ParticleEditorRun
================
*/
void ParticleEditorRun( void ) {
#if _MSC_VER >= 1300
	MSG *msg = AfxGetCurrentMessage();			// TODO Robert fix me!!
#else
	MSG *msg = &m_msgCur;
#endif

	while( ::PeekMessage(msg, NULL, NULL, NULL, PM_NOREMOVE) ) {
		// pump message
		if ( !AfxGetApp()->PumpMessage() ) {
		}
	}
}

/*
================
ParticleEditorShutdown
================
*/
void ParticleEditorShutdown( void ) {
	delete g_ParticleDialog;
	g_ParticleDialog = NULL;
}


// CDialogParticleEditor dialog

IMPLEMENT_DYNAMIC(CDialogParticleEditor, CDialog)
CDialogParticleEditor::CDialogParticleEditor(CWnd* pParent /*=NULL*/)
	: CDialog(CDialogParticleEditor::IDD, pParent)
	, matName(_T(""))
	, animFrames(_T(""))
	, animRate(_T(""))
	, color(_T(""))
	, fadeColor(_T(""))
	, fadeIn(_T(""))
	, fadeOut(_T(""))
	, fadeFraction(_T(""))
	, count(_T(""))
	, time(_T(""))
	, timeOffset(_T(""))
	, deadTime(_T(""))
	, gravity(_T(""))
	, bunching(_T(""))
	, offset(_T(""))
	, xSize(_T(""))
	, ySize(_T(""))
	, zSize(_T(""))
	, ringOffset(_T(""))
	, directionParm(_T(""))
	, direction(0)
	, orientation(0)
	, distribution(0)
	, viewOrigin(_T(""))
	, speedFrom(_T(""))
	, speedTo(_T(""))
	, rotationFrom(_T(""))
	, rotationTo(_T(""))
	, sizeFrom(_T(""))
	, sizeTo(_T(""))
	, aspectFrom(_T(""))
	, aspectTo(_T(""))
	, customPath(_T(""))
	, customParms(_T(""))
	, trails(_T(""))
	, trailTime(_T(""))
	, worldGravity(TRUE)
	, entityColor(TRUE)
	, randomDistribution(TRUE)
	, initialAngle(_T(""))
	, boundsExpansion(_T(""))
	, customDesc(_T(""))
	, particleMode(FALSE)
{
	visualization = TESTMODEL;
	mapModified = false;
}

CDialogParticleEditor::~CDialogParticleEditor() {
}

void CDialogParticleEditor::DoDataExchange(CDataExchange* pDX) {
	CDialog::DoDataExchange(pDX);
	DDX_Text(pDX, IDC_EDIT_DEPTHHACK, depthHack);
	DDX_Check(pDX, IDC_CHECK_WORLDGRAVITY, worldGravity);
	DDX_Check(pDX, IDC_CHECK_ENTITYCOLOR, entityColor);
	DDX_Control(pDX, IDC_COMBO_PARTICLES, comboParticle);
	DDX_Control(pDX, IDC_LIST_STAGES, listStages);
	DDX_Text(pDX, IDC_COMBO_CUSTOMPATH, customPath );
	DDX_Text(pDX, IDC_EDIT_CUSTOMPARMS, customParms );
	DDX_Text(pDX, IDC_EDIT_MATERIAL, matName);
	DDX_Text(pDX, IDC_EDIT_ANIMFRAMES, animFrames);
	DDX_Text(pDX, IDC_EDIT_ANIMRATE, animRate);
	DDX_Text(pDX, IDC_EDIT_COLOR, color);
	DDX_Text(pDX, IDC_EDIT_FADECOLOR, fadeColor);
	DDX_Text(pDX, IDC_EDIT_FADEIN, fadeIn);
	DDX_Text(pDX, IDC_EDIT_FADEOUT, fadeOut);
	DDX_Text(pDX, IDC_EDIT_FADEFRACTION, fadeFraction);
	DDX_Text(pDX, IDC_EDIT_COUNT, count);
	DDX_Text(pDX, IDC_EDIT_TIME, time);
	DDX_Text(pDX, IDC_EDIT_TIMEOFFSET, timeOffset);
	DDX_Text(pDX, IDC_EDIT_DEADTIME, deadTime);
	DDX_Text(pDX, IDC_EDIT_GRAVITY, gravity);
	DDX_Text(pDX, IDC_EDIT_BUNCHING, bunching);
	DDX_Text(pDX, IDC_EDIT_OFFSET, offset);
	DDX_Text(pDX, IDC_EDIT_XSIZE, xSize);
	DDX_Text(pDX, IDC_EDIT_YSIZE, ySize);
	DDX_Text(pDX, IDC_EDIT_ZSIZE, zSize);
	DDX_Text(pDX, IDC_EDIT_RINGOFFSET, ringOffset);
	DDX_Text(pDX, IDC_EDIT_CYCLES, cycles);
	DDX_Control(pDX, IDC_STATIC_DIRPARM, staticDirectionParm);
	DDX_Text(pDX, IDC_EDIT_DIRECTIONPARM, directionParm);
	DDX_Text(pDX, IDC_EDIT_SPEEDFROM, speedFrom);
	DDX_Text(pDX, IDC_EDIT_SPEEDTO, speedTo);
	DDX_Text(pDX, IDC_EDIT_ROTATIONFROM, rotationFrom);
	DDX_Text(pDX, IDC_EDIT_ROTATIONTO, rotationTo);
	DDX_Text(pDX, IDC_EDIT_SIZEFROM, sizeFrom);
	DDX_Text(pDX, IDC_EDIT_SIZETO, sizeTo);
	DDX_Text(pDX, IDC_EDIT_ASPECTFROM, aspectFrom);
	DDX_Text(pDX, IDC_EDIT_ASPECTTO, aspectTo);
	DDX_Text(pDX, IDC_EDIT_ORIENTATIONPARM1, trails);
	DDX_Text(pDX, IDC_EDIT_ORIENTATIONPARM2, trailTime);
	DDX_Check(pDX, IDC_CHECK_RANDOMDISTRIBUTION, randomDistribution);
	DDX_Text(pDX, IDC_EDIT_INITIALANGLE, initialAngle);
	DDX_Text(pDX, IDC_EDIT_BOUNDSEXPANSION, boundsExpansion);
	DDX_Text(pDX, IDC_STATIC_DESC, customDesc);
	DDX_Control(pDX, IDC_EDIT_RINGOFFSET, editRingOffset);
	DDX_Radio(pDX, IDC_RADIO_RECT, distribution);
	DDX_Radio(pDX, IDC_RADIO_CONE, direction);
	DDX_Radio(pDX, IDC_RADIO_VIEW, orientation);
	DDX_Control(pDX, IDC_SLIDER_BUNCHING, sliderBunching);
	DDX_Control(pDX, IDC_SLIDER_FADEIN, sliderFadeIn);
	DDX_Control(pDX, IDC_SLIDER_FADEOUT, sliderFadeOut);
	DDX_Control(pDX, IDC_SLIDER_FADEFRACTION, sliderFadeFraction);
	DDX_Control(pDX, IDC_SLIDER_COUNT, sliderCount);
	DDX_Control(pDX, IDC_SLIDER_TIME, sliderTime);
	DDX_Control(pDX, IDC_SLIDER_GRAVITY, sliderGravity);
	DDX_Control(pDX, IDC_SLIDER_SPEEDFROM, sliderSpeedFrom);
	DDX_Control(pDX, IDC_SLIDER_SPEEDTO, sliderSpeedTo);
	DDX_Control(pDX, IDC_SLIDER_ROTATIONFROM, sliderRotationFrom);
	DDX_Control(pDX, IDC_SLIDER_ROTATIONTO, sliderRotationTo);
	DDX_Control(pDX, IDC_SLIDER_SIZEFROM, sliderSizeFrom);
	DDX_Control(pDX, IDC_SLIDER_SIZETO, sliderSizeTo);
	DDX_Control(pDX, IDC_SLIDER_ASPECTFROM, sliderAspectFrom);
	DDX_Control(pDX, IDC_SLIDER_ASPECTTO, sliderAspectTo);
	DDX_Control(pDX, IDC_BUTTON_VECTOR, vectorControl);
}


BEGIN_MESSAGE_MAP(CDialogParticleEditor, CDialog)
	ON_BN_CLICKED(IDC_BUTTON_ADDSTAGE, OnBnClickedButtonAddstage)
	ON_BN_CLICKED(IDC_BUTTON_REMOVESTAGE, OnBnClickedButtonRemovestage)
	ON_BN_CLICKED(IDC_BUTTON_BROWSEMATERIAL, OnBnClickedButtonBrowsematerial)
	ON_BN_CLICKED(IDC_BUTTON_BROWSECOLOR, OnBnClickedButtonBrowsecolor)
	ON_BN_CLICKED(IDC_BUTTON_BROWSEFADECOLOR, OnBnClickedButtonBrowsefadecolor)
	ON_BN_CLICKED(IDC_BUTTON_BROWSECOLOR_ENTITY, OnBnClickedButtonBrowseEntitycolor)
	ON_BN_CLICKED(IDC_BUTTON_UPDATE, OnBnClickedButtonUpdate)
	ON_CBN_SELCHANGE(IDC_COMBO_PARTICLES, OnCbnSelchangeComboParticles)
	ON_CBN_SELCHANGE(IDC_COMBO_CUSTOMPATH, OnCbnSelchangeComboPath)
	ON_BN_CLICKED(IDC_RADIO_RECT, OnBnClickedRadioRect)
	ON_BN_CLICKED(IDC_RADIO_SPHERE, OnBnClickedRadioSphere)
	ON_BN_CLICKED(IDC_RADIO_CYLINDER, OnBnClickedRadioCylinder)
	ON_BN_CLICKED(IDC_RADIO_CONE, OnBnClickedRadioCone)
	ON_BN_CLICKED(IDC_RADIO_OUTWARD, OnBnClickedRadioOutward)
	ON_BN_CLICKED(IDC_RADIO_VIEW, OnBnClickedRadioView)
	ON_BN_CLICKED(IDC_RADIO_AIMED, OnBnClickedRadioAimed)
	ON_BN_CLICKED(IDC_RADIO_X, OnBnClickedRadioX)
	ON_BN_CLICKED(IDC_RADIO_Y, OnBnClickedRadioY)
	ON_BN_CLICKED(IDC_RADIO_Z, OnBnClickedRadioZ)
	ON_BN_CLICKED(IDC_BUTTON_HIDESTAGE, OnBnClickedButtonHidestage)
	ON_BN_CLICKED(IDC_BUTTON_SHOWSTAGE, OnBnClickedButtonShowstage)
	ON_BN_CLICKED(IDC_CHECK_WORLDGRAVITY, OnBnClickedWorldGravity)
	ON_BN_CLICKED(IDC_CHECK_ENTITYCOLOR, OnBnClickedEntityColor)
	ON_LBN_SELCHANGE(IDC_LIST_STAGES, OnLbnSelchangeListStages)
	ON_BN_CLICKED(IDC_BUTTON_NEW, OnBnClickedButtonNew)
	ON_BN_CLICKED(IDC_BUTTON_SAVE_PARTICLE, OnBnClickedButtonSave)
	ON_BN_CLICKED(IDC_BUTTON_SAVE_PARTICLE_AS, OnBnClickedButtonSaveAs)
	ON_BN_CLICKED(IDC_BUTTON_SAVE_PARTICLEENTITIES, OnBnClickedButtonSaveParticles)
	ON_BN_CLICKED(IDC_BUTTON_TESTMODEL, OnBnClickedTestModel)
	ON_BN_CLICKED(IDC_BUTTON_IMPACT, OnBnClickedImpact)
	ON_BN_CLICKED(IDC_BUTTON_MUZZLE, OnBnClickedMuzzle)
	ON_BN_CLICKED(IDC_BUTTON_FLIGHT, OnBnClickedFlight)
	ON_BN_CLICKED(IDC_BUTTON_SELECTED, OnBnClickedSelected)
	ON_BN_CLICKED(IDC_BUTTON_DOOM, OnBnClickedDoom)
	ON_BN_CLICKED(IDC_CHECK_EDITPARTICLEMODE, OnBnClickedParticleMode)
	ON_BN_CLICKED(IDC_BUTTON_DROPEMITTER, OnBtnDrop)
	ON_BN_CLICKED(IDC_BUTTON_YUP, OnBtnYup)
	ON_BN_CLICKED(IDC_BUTTON_YDN, OnBtnYdn)
	ON_BN_CLICKED(IDC_BUTTON_XDN, OnBtnXdn)
	ON_BN_CLICKED(IDC_BUTTON_XUP, OnBtnXup)
	ON_BN_CLICKED(IDC_BUTTON_ZUP, OnBtnZup)
	ON_BN_CLICKED(IDC_BUTTON_ZDN, OnBtnZdn)
	ON_WM_HSCROLL()
END_MESSAGE_MAP()


// CDialogParticleEditor message handlers

void CDialogParticleEditor::OnBnClickedParticleMode() {
	particleMode = !particleMode;
	cvarSystem->SetCVarInteger( "g_editEntityMode", ( particleMode ) ? 4 : 0 );
	EnableEditControls();
}


void CDialogParticleEditor::OnBnClickedButtonSaveAs() {
	idDeclParticle *idp = GetCurParticle();
	if ( idp == NULL ) {
		return;
	}
	DialogName dlg("New Particle");
	if (dlg.DoModal() == IDOK) {
		if ( declManager->FindType( DECL_PARTICLE, dlg.m_strName, false ) ) {
			MessageBox( "Particle already exists!", "Particle exists", MB_OK );
			return;
		}
		CFileDialog dlgSave( TRUE, "prt", NULL, OFN_CREATEPROMPT, "Particle Files (*.prt)|*.prt||All Files (*.*)|*.*||", AfxGetMainWnd() );
		if ( dlgSave.DoModal() == IDOK ) {
			idStr fileName;
			fileName = fileSystem->OSPathToRelativePath( dlgSave.m_ofn.lpstrFile );
			idDeclParticle *decl = dynamic_cast<idDeclParticle*>( declManager->CreateNewDecl( DECL_PARTICLE, dlg.m_strName, fileName ) );
			if ( decl ) {
				decl->stages.DeleteContents( true );
				decl->depthHack = idp->depthHack;
				for ( int i = 0; i < idp->stages.Num(); i++ ) {
					idParticleStage *stage = new idParticleStage();
					*stage = *idp->stages[i];
					decl->stages.Append( stage );
				}
				EnumParticles();
				int index = comboParticle.FindStringExact( -1, dlg.m_strName );
				if ( index >= 0 ) {
					comboParticle.SetCurSel( index );
				}
				OnBnClickedButtonSave();
				OnCbnSelchangeComboParticles();
				OnBnClickedButtonUpdate();
			}
		}
	}
}


void CDialogParticleEditor::OnBnClickedButtonSaveParticles() {
	cmdSystem->BufferCommandText( CMD_EXEC_NOW, "saveParticles" );
	CWnd *wnd = GetDlgItem( IDC_BUTTON_SAVE_PARTICLEENTITIES );
	if ( wnd ) {
		wnd->EnableWindow( FALSE );
	}
}

void CDialogParticleEditor::OnBnClickedButtonAddstage() {
	AddStage();
}

void CDialogParticleEditor::OnBnClickedButtonRemovestage() {
	RemoveStage();
}

void CDialogParticleEditor::OnBnClickedButtonBrowsematerial() {
	CPreviewDlg matDlg( this );
	matDlg.SetMode(CPreviewDlg::MATERIALS, "particles" );
	matDlg.SetDisablePreview( true );
	if ( matDlg.DoModal() == IDOK ) {
		matName = matDlg.mediaName;
		DlgVarsToCurStage();
		CurStageToDlgVars();
	}
}

void CDialogParticleEditor::OnBnClickedButtonBrowsecolor() {
	int r, g, b;
	float ob;
	idParticleStage *ps = GetCurStage();
	if ( ps == NULL ) {
		return;
	}
	r = ps->color.x * 255.0f;
	g = ps->color.y * 255.0f;
	b = ps->color.z * 255.0f;
	ob = 1.0f;
	if ( DoNewColor( &r, &g, &b, &ob ) ) {
		color.Format( "%f %f %f %f", (float)r / 255.0f, (float)g / 255.0f, (float)b / 255.0f, 1.0f );
		DlgVarsToCurStage();
		CurStageToDlgVars();
	}
}

void CDialogParticleEditor::OnBnClickedButtonBrowseEntitycolor() {
	int r, g, b;
	float ob;
	idList<idEntity*> list;
	idDict dict2;
	idStr str;
	list.SetNum( 128 );
	int count = gameEdit->GetSelectedEntities( list.Ptr(), list.Num() );
	list.SetNum( count );

	if ( count ) {
		const idDict *dict = gameEdit->EntityGetSpawnArgs( list[0] );
		if ( dict ) {
			idVec3 clr = dict->GetVector( "_color", "1 1 1" );
			r = clr.x * 255.0f;
			g = clr.y * 255.0f;
			b = clr.z * 255.0f;
			ob = 1.0f;
			if ( DoNewColor( &r, &g, &b, &ob ) ) {
				for ( int i = 0; i < count; i++ ) {
					dict = gameEdit->EntityGetSpawnArgs( list[i] );
					const char *name = dict->GetString( "name" );
					idEntity *ent = gameEdit->FindEntity( name );
					if ( ent ) {
						gameEdit->EntitySetColor( ent, idVec3( (float)r / 255.0f, (float)g / 255.0f, (float)b / 255.0f ) );
						str = va( "%f %f %f", (float)r / 255.0f, (float)g / 255.0f, (float)b / 255.0f );
						dict2.Clear();
						dict2.Set( "_color", str );
						gameEdit->EntityChangeSpawnArgs( ent, &dict2 );
						gameEdit->MapSetEntityKeyVal( name, "_color",  str );
					}
				}
			}
		}
		CWnd *wnd = GetDlgItem( IDC_BUTTON_SAVE_PARTICLEENTITIES );
		if ( wnd ) {
			wnd->EnableWindow( TRUE );
		}
	}

}

void CDialogParticleEditor::OnBnClickedButtonBrowsefadecolor() {
	int r, g, b;
	float ob;
	idParticleStage *ps = GetCurStage();
	if ( ps == NULL ) {
		return;
	}
	r = ps->fadeColor.x * 255.0f;
	g = ps->fadeColor.y * 255.0f;
	b = ps->fadeColor.z * 255.0f;
	ob = 1.0f;
	if ( DoNewColor( &r, &g, &b, &ob ) ) {
		fadeColor.Format( "%f %f %f %f", (float)r / 255.0f, (float)g / 255.0f, (float)b / 255.0f, 1.0f );
		DlgVarsToCurStage();
		CurStageToDlgVars();
	}
}

void CDialogParticleEditor::OnBnClickedButtonUpdate() {
	UpdateData( TRUE );
	DlgVarsToCurStage();
	CurStageToDlgVars();
}

void CDialogParticleEditor::SelectParticle( const char *name ) {
	int index = comboParticle.FindString( 0, name );
	if ( index >= 0 ) {
		comboParticle.SetCurSel( index );
		UpdateParticleData();
	}
}

idDeclParticle *CDialogParticleEditor::GetCurParticle() {
	int sel = comboParticle.GetCurSel();
	if ( sel == CB_ERR ) {
		return NULL;
	}
	int index = comboParticle.GetItemData( sel );
	return static_cast<idDeclParticle *>( const_cast<idDecl *>( declManager->DeclByIndex( DECL_PARTICLE, index ) ) );
}

void CDialogParticleEditor::UpdateParticleData() {

	listStages.ResetContent();
	idDeclParticle *idp = GetCurParticle();
	if ( idp == NULL ) {
		return;
	}
	for ( int i = 0; i < idp->stages.Num(); i++ ) {
		int index = listStages.AddString( va( "stage %i", i ) );
		if ( index >= 0 ) {
			listStages.SetItemData( index, i );
		}
	}
	listStages.SetCurSel( 0 );
	OnLbnSelchangeListStages();
	CWnd *wnd = GetDlgItem( IDC_STATIC_INFILE );
	if ( wnd ) {
		wnd->SetWindowText( va( "Particle file: %s", idp->GetFileName() ) );
	}

	SetParticleView();
}

void CDialogParticleEditor::OnCbnSelchangeComboParticles() {
	UpdateParticleData();
}


void CDialogParticleEditor::OnCbnSelchangeComboPath() {
	DlgVarsToCurStage();
	CurStageToDlgVars();
	UpdateControlInfo();
}

void CDialogParticleEditor::UpdateControlInfo() {
	CWnd *wnd = GetDlgItem( IDC_EDIT_RINGOFFSET );
	if ( wnd ) {
		wnd->EnableWindow( distribution == 2 );
	}
	wnd = GetDlgItem( IDC_STATIC_DIRPARM );
	if ( wnd ) {
		wnd->SetWindowText( (direction == 0 ) ? "Angle" : "Upward Bias" );
	}
	wnd = GetDlgItem( IDC_EDIT_ORIENTATIONPARM1 );
	if ( wnd ) {
		wnd->EnableWindow( orientation == 1 );
	}
	wnd = GetDlgItem( IDC_EDIT_ORIENTATIONPARM2 );
	if ( wnd ) {
		wnd->EnableWindow( orientation == 1 );
	}

	idParticleStage *ps = GetCurStage();
	if ( ps == NULL ) {
		return;
	}
	sliderBunching.SetValuePos( ps->spawnBunching );
	sliderFadeIn.SetValuePos( ps->fadeInFraction );
	sliderFadeOut.SetValuePos( ps->fadeOutFraction );
	sliderFadeFraction.SetValuePos( ps->fadeIndexFraction );
	sliderCount.SetValuePos( ps->totalParticles );
	sliderTime.SetValuePos( ps->particleLife );
	sliderGravity.SetValuePos( ps->gravity );
	sliderSpeedFrom.SetValuePos( ps->speed.from );
	sliderSpeedTo.SetValuePos( ps->speed.to );
	sliderRotationFrom.SetValuePos( ps->rotationSpeed.from );
	sliderRotationTo.SetValuePos( ps->rotationSpeed.to );
	sliderSizeFrom.SetValuePos( ps->size.from );
	sliderSizeTo.SetValuePos( ps->size.to );
	sliderAspectFrom.SetValuePos( ps->aspect.from );
	sliderAspectTo.SetValuePos( ps->aspect.to );
}

void CDialogParticleEditor::OnBnClickedRadioRect() {
	distribution = 0;
	DlgVarsToCurStage();
	CurStageToDlgVars();
	UpdateControlInfo();
}

void CDialogParticleEditor::OnBnClickedRadioSphere() {
	distribution = 2;
	DlgVarsToCurStage();
	CurStageToDlgVars();
	UpdateControlInfo();
}

void CDialogParticleEditor::OnBnClickedRadioCylinder() {
	distribution = 1;
	DlgVarsToCurStage();
	CurStageToDlgVars();
	UpdateControlInfo();
}

void CDialogParticleEditor::OnBnClickedRadioCone() {
	direction = 0;
	DlgVarsToCurStage();
	CurStageToDlgVars();
	UpdateControlInfo();
}

void CDialogParticleEditor::OnBnClickedRadioOutward() {
	direction = 1;
	DlgVarsToCurStage();
	CurStageToDlgVars();
	UpdateControlInfo();
}

void CDialogParticleEditor::OnBnClickedRadioView() {
	orientation = 0;
	DlgVarsToCurStage();
	CurStageToDlgVars();
	UpdateControlInfo();
}

void CDialogParticleEditor::OnBnClickedRadioAimed() {
	orientation = 1;
	DlgVarsToCurStage();
	CurStageToDlgVars();
	UpdateControlInfo();
}

void CDialogParticleEditor::OnBnClickedRadioX() {
	orientation = 2;
	DlgVarsToCurStage();
	CurStageToDlgVars();
	UpdateControlInfo();
}

void CDialogParticleEditor::OnBnClickedRadioY() {
	orientation = 3;
	DlgVarsToCurStage();
	CurStageToDlgVars();
	UpdateControlInfo();
}

void CDialogParticleEditor::OnBnClickedRadioZ() {
	orientation = 4;
	DlgVarsToCurStage();
	CurStageToDlgVars();
	UpdateControlInfo();
}

void CDialogParticleEditor::OnBnClickedDoom() {
	::SetFocus(win32.hWnd);
}


void CDialogParticleEditor::OnBnClickedTestModel() {
	visualization = TESTMODEL;
	SetParticleView();
}

void CDialogParticleEditor::OnBnClickedImpact() {
	visualization = IMPACT;
	SetParticleView();
}

void CDialogParticleEditor::OnBnClickedMuzzle(){
	visualization = MUZZLE;
	SetParticleView();
}

void CDialogParticleEditor::OnBnClickedFlight() {
	visualization = FLIGHT;
	SetParticleView();
}

void CDialogParticleEditor::OnBnClickedSelected() {
	visualization = SELECTED;
	SetParticleView();
}

void CDialogParticleEditor::SetParticleVisualization( int i ) {
	visualization = i;
	SetParticleView();
}

void CDialogParticleEditor::SetParticleView() {
	idDeclParticle *idp = GetCurParticle();
	if ( idp == NULL ) {
		return;
	}
	cmdSystem->BufferCommandText( CMD_EXEC_NOW, "testmodel" );
	idStr str;
	switch ( visualization ) {
		case TESTMODEL :
			str = idp->GetName();
			str.SetFileExtension( ".prt" );
			cmdSystem->BufferCommandText( CMD_EXEC_NOW, va("testmodel %s\n", str.c_str() ) );
		break;
		case IMPACT :
			str = idp->GetName();
			str.SetFileExtension( ".prt" );
			cvarSystem->SetCVarInteger( "g_testParticle", TEST_PARTICLE_IMPACT );
			cvarSystem->SetCVarString( "g_testParticleName", str );
		break;
		case MUZZLE :
			str = idp->GetName();
			str.SetFileExtension( ".prt" );
			cvarSystem->SetCVarInteger( "g_testParticle", TEST_PARTICLE_MUZZLE );
			cvarSystem->SetCVarString( "g_testParticleName", str );
		break;
		case FLIGHT :
			str = idp->GetName();
			str.SetFileExtension( ".prt" );
			cvarSystem->SetCVarInteger( "g_testParticle", TEST_PARTICLE_FLIGHT );
			cvarSystem->SetCVarString( "g_testParticleName", str );
		break;
		case SELECTED :
			str = idp->GetName();
			str.SetFileExtension( ".prt" );
			cvarSystem->SetCVarInteger( "g_testParticle", TEST_PARTICLE_FLIGHT );
			SetSelectedModel( str );
		break;
	}
}

void CDialogParticleEditor::SetSelectedModel( const char *val ) {
	idList<idEntity*> list;
	idMat3 axis;

	list.SetNum( 128 );
	int count = gameEdit->GetSelectedEntities( list.Ptr(), list.Num() );
	list.SetNum( count );

	if ( count ) {
		for ( int i = 0; i < count; i++ ) {
			const idDict *dict = gameEdit->EntityGetSpawnArgs( list[i] );
			if ( dict == NULL ) {
				continue;
			}
			const char *name = dict->GetString( "name" );
			gameEdit->EntitySetModel( list[i], val );
			gameEdit->EntityUpdateVisuals( list[i] );
			gameEdit->EntityGetAxis( list[i], axis );
			vectorControl.SetidAxis( axis );
			gameEdit->MapSetEntityKeyVal( name, "model", val );
		}
		CWnd *wnd = GetDlgItem( IDC_BUTTON_SAVE_PARTICLEENTITIES );
		if ( wnd ) {
			wnd->EnableWindow( TRUE );
		}
	}
}


void CDialogParticleEditor::OnBnClickedButtonHidestage() {
	HideStage();
}

void CDialogParticleEditor::OnBnClickedButtonShowstage() {
	ShowStage();
}


void CDialogParticleEditor::OnBnClickedWorldGravity() {
	worldGravity = !worldGravity;
	DlgVarsToCurStage();
	CurStageToDlgVars();
}

void CDialogParticleEditor::OnBnClickedEntityColor() {
	entityColor = !entityColor;
	DlgVarsToCurStage();
	CurStageToDlgVars();
}


void CDialogParticleEditor::AddStage() {

	idDeclParticle *idp = GetCurParticle();
	if ( idp == NULL ) {
		return;
	}

	idParticleStage *stage = new idParticleStage;

	if ((GetAsyncKeyState(VK_CONTROL) & 0x8000)) {
		idParticleStage *source = GetCurStage();
		if ( source == NULL ) {
			delete stage;
			return;
		}
		*stage = *source;
	} else {
		stage->Default();
	}
	int newIndex = idp->stages.Append( stage );
	int index = listStages.AddString( va( "stage %i", newIndex ) );
	listStages.SetCurSel( index );
	listStages.SetItemData( index, newIndex );
	ShowCurrentStage();
	EnableStageControls();
}

void CDialogParticleEditor::RemoveStage() {
	idDeclParticle *idp = GetCurParticle();
	if ( idp == NULL ) {
		return;
	}

	if ( MessageBox( "Are you sure you want to remove this stage?", "Remove Stage", MB_YESNO | MB_ICONQUESTION ) != IDYES ) {
		return;
	}

	int index = listStages.GetCurSel();
	if ( index >= 0 ) {
		int newIndex = listStages.GetItemData( index );
		if ( newIndex >= 0 && newIndex < idp->stages.Num() ) {
			idp->stages.RemoveIndex( newIndex );
			index += ( index >= 1 ) ? -1 : 1;
			newIndex = comboParticle.FindStringExact( -1, idp->GetName() );
			EnumParticles();
			if ( newIndex >= 0 ) {
				comboParticle.SetCurSel( newIndex );
			}
			OnCbnSelchangeComboParticles();
			listStages.SetCurSel( index );
			ShowCurrentStage();
		}
	}
	EnableStageControls();
}

void CDialogParticleEditor::ShowStage() {
	idParticleStage *ps = GetCurStage();
	if ( ps == NULL ) {
		return;
	}
	ps->hidden = false;
	int index = listStages.GetCurSel();
	int newIndex = listStages.GetItemData( index );
	listStages.DeleteString ( index );
	listStages.InsertString( index, va("stage %i", index ) );
	listStages.SetItemData( index, newIndex );
	listStages.SetCurSel( index );
	EnableStageControls();
}

void CDialogParticleEditor::HideStage() {
	idParticleStage *ps = GetCurStage();
	if ( ps == NULL ) {
		return;
	}
	ps->hidden = true;
	int index = listStages.GetCurSel();
	int newIndex = listStages.GetItemData( index );
	listStages.DeleteString ( index );
	listStages.InsertString( index, va("stage %i (H) ", index ) );
	listStages.SetItemData( index, newIndex );
	listStages.SetCurSel( index );
	EnableStageControls();
}

idParticleStage *CDialogParticleEditor::GetCurStage() {
	idDeclParticle *idp = GetCurParticle();
	int sel = listStages.GetCurSel();
	int index = listStages.GetItemData( sel );
	if ( idp == NULL || sel == LB_ERR || index >= idp->stages.Num() ) {
		return NULL;
	}
	return idp->stages[index];
}

void CDialogParticleEditor::ClearDlgVars() {
	matName = "";
	animFrames = "";
	animRate = "";
	color = "";
	fadeColor = "";
	fadeIn = "";
	fadeOut = "";
	fadeFraction = "";
	count = "";
	time = "";
	timeOffset = "";
	deadTime = "";
	gravity = "";
	bunching = "";
	offset = "";
	xSize = "";
	ySize = "";
	zSize = "";
	ringOffset = "";
	directionParm = "";
	direction = 1;
	orientation = 1;
	distribution = 1;
	speedFrom = "";
	speedTo = "";
	rotationFrom = "";
	rotationTo = "";
	sizeFrom = "";
	sizeTo = "";
	aspectFrom = "";
	aspectTo = "";
	customPath = "";
	customParms = "";
	trails = "";
	trailTime = "";
	worldGravity = FALSE;
	entityColor = FALSE;
	randomDistribution = TRUE;
	initialAngle = "";
	customDesc = "";
	UpdateData( FALSE );
}

void CDialogParticleEditor::CurStageToDlgVars() {

	// go ahead and get the two system vars too
	idDeclParticle *idp = GetCurParticle();
	if ( idp == NULL ) {
		return;
	}

	depthHack = va( "%.3f", idp->depthHack );

	idParticleStage *ps = GetCurStage();
	if ( ps == NULL ) {
		return;
	}
	matName = ps->material->GetName();
	animFrames = va( "%i", ps->animationFrames );
	animRate = va( "%i", ps->animationRate );
	color = ps->color.ToString();
	fadeColor = ps->fadeColor.ToString();
	fadeIn = va( "%.3f", ps->fadeInFraction );
	fadeOut = va( "%.3f", ps->fadeOutFraction );
	fadeFraction = va( "%.3f", ps->fadeIndexFraction );
	count = va( "%i", ps->totalParticles );
	time = va( "%.3f", ps->particleLife );
	timeOffset = va( "%.3f", ps->timeOffset );
	deadTime = va( "%.3f", ps->deadTime );
	gravity = va( "%.3f", ps->gravity );
	bunching = va( "%.3f", ps->spawnBunching );
	offset = ps->offset.ToString( 0 );
	xSize = va( "%.3f", ps->distributionParms[0] );
	ySize = va( "%.3f", ps->distributionParms[1] );
	zSize = va( "%.3f", ps->distributionParms[2] );
	ringOffset = va( "%.3f", ps->distributionParms[3] );
	directionParm = va( "%.3f", ps->directionParms[0] );
	direction = ps->directionType;
	orientation = ps->orientation;
	distribution = ps->distributionType;
	speedFrom = va( "%.3f", ps->speed.from );
	speedTo = va( "%.3f", ps->speed.to );
	rotationFrom = va( "%.3f", ps->rotationSpeed.from );
	rotationTo = va( "%.3f", ps->rotationSpeed.to );
	sizeFrom = va( "%.3f", ps->size.from );
	sizeTo = va( "%.3f", ps->size.to );
	aspectFrom = va( "%.3f", ps->aspect.from );
	aspectTo = va( "%.3f", ps->aspect.to );
	trails = va( "%f", ps->orientationParms[0] );
	trailTime = va( "%.3f", ps->orientationParms[1] );
	cycles = va( "%.3f", ps->cycles );
	customPath = ps->GetCustomPathName();
	customParms = "";
	customDesc = ps->GetCustomPathDesc();
	if ( ps->customPathType != PPATH_STANDARD ) {
		for ( int i = 0; i < ps->NumCustomPathParms(); i++ ) {
			customParms += va( "%.1f ", ps->customPathParms[i] );
		}
	}
	worldGravity = ps->worldGravity;
	initialAngle = va( "%.3f", ps->initialAngle );
	boundsExpansion = va( "%.3f", ps->boundsExpansion );
	randomDistribution = ps->randomDistribution;
	entityColor = ps->entityColor;
	UpdateData( FALSE );
}

void CDialogParticleEditor::DlgVarsToCurStage() {

	// go ahead and set the two system vars too
	idDeclParticle *idp = GetCurParticle();
	if ( idp == NULL ) {
		return;
	}
	idp->depthHack = atof( depthHack );

	idParticleStage *ps = GetCurStage();
	if ( ps == NULL ) {
		return;
	}
	ps->material = declManager->FindMaterial( matName );
	ps->animationFrames = atoi( animFrames );
	ps->animationRate = atoi( animRate );
	sscanf( color, "%f %f %f %f", &ps->color.x, &ps->color.y, &ps->color.z, &ps->color.w );
	sscanf( fadeColor, "%f %f %f %f", &ps->fadeColor.x, &ps->fadeColor.y, &ps->fadeColor.z, &ps->fadeColor.w );
	ps->fadeInFraction = atof( fadeIn );
	ps->fadeOutFraction = atof( fadeOut );
	ps->fadeIndexFraction = atof( fadeFraction );
	ps->totalParticles = atoi( count );
	ps->particleLife = atof( time );
	ps->timeOffset = atof( timeOffset );
	ps->deadTime = atof( deadTime );
	ps->gravity = atof( gravity );
	ps->spawnBunching = atof( bunching );
	sscanf( offset, "%f %f %f", &ps->offset.x, &ps->offset.y, &ps->offset.z );
	ps->distributionParms[0] = atof( xSize );
	ps->distributionParms[1] = atof( ySize );
	ps->distributionParms[2] = atof( zSize );
	ps->distributionParms[3] = atof( ringOffset );
	ps->directionParms[0] = atof( directionParm );
	ps->directionType = static_cast<prtDirection_t>( direction );
	ps->orientation = static_cast<prtOrientation_t>( orientation );
	ps->distributionType = static_cast<prtDistribution_t>( distribution );
	ps->speed.from = atof( speedFrom );
	ps->speed.to = atof( speedTo );
	ps->rotationSpeed.from = atof( rotationFrom );
	ps->rotationSpeed.to = atof( rotationTo );
	ps->size.from = atof( sizeFrom );
	ps->size.to = atof( sizeTo );
	ps->aspect.from = atof( aspectFrom );
	ps->aspect.to = atof( aspectTo );
	ps->orientationParms[0] = atof( trails );
	ps->orientationParms[1] = atof( trailTime );
	ps->worldGravity = ( worldGravity == TRUE );
	ps->cycles = atof( cycles );
	ps->cycleMsec = ( ps->particleLife + ps->deadTime ) * 1000;

	sscanf( customParms, "%f %f %f %f %f %f %f %f", &ps->customPathParms[0], &ps->customPathParms[1], &ps->customPathParms[2],
		   &ps->customPathParms[3], &ps->customPathParms[4], &ps->customPathParms[5],
		   &ps->customPathParms[6], &ps->customPathParms[7] );

	ps->SetCustomPathType( customPath );

	ps->initialAngle = atof( initialAngle );
	ps->boundsExpansion = atof( boundsExpansion );
	ps->randomDistribution = ( randomDistribution != FALSE );
	ps->entityColor = ( entityColor == TRUE );

}

void CDialogParticleEditor::ShowCurrentStage() {
	ClearDlgVars();
	idParticleStage *ps = GetCurStage();
	if ( ps == NULL ) {
		return;
	}
	CurStageToDlgVars();
	UpdateControlInfo();
}

void CDialogParticleEditor::OnLbnSelchangeListStages() {
	ShowCurrentStage();
	EnableStageControls();
}

void CDialogParticleEditor::OnBnClickedButtonNew() {
	DialogName dlg("New Particle");
	if (dlg.DoModal() == IDOK) {
		CFileDialog dlgSave( TRUE, "prt", NULL, OFN_CREATEPROMPT, "Particle Files (*.prt)|*.prt||All Files (*.*)|*.*||", AfxGetMainWnd() );
		if ( dlgSave.DoModal() == IDOK ) {
			if ( declManager->FindType( DECL_PARTICLE, dlg.m_strName, false ) ) {
				MessageBox( "Particle already exists!", "Particle exists", MB_OK );
				return;
			}
			idStr fileName;
			fileName = fileSystem->OSPathToRelativePath( dlgSave.m_ofn.lpstrFile );
			idDecl *decl = declManager->CreateNewDecl( DECL_PARTICLE, dlg.m_strName, fileName );
			if ( decl ) {
				if ( MessageBox( "Copy current particle?", "Copy current", MB_YESNO | MB_ICONQUESTION ) == IDYES ) {
					MessageBox( "Copy current particle not implemented yet.. Stay tuned" );
				}
				EnumParticles();
				int index = comboParticle.FindStringExact( -1, dlg.m_strName );
				if ( index >= 0 ) {
					comboParticle.SetCurSel( index );
				}
				OnBnClickedButtonSave();
				OnCbnSelchangeComboParticles();
			}
		}
	}
}

void CDialogParticleEditor::OnBnClickedButtonSave() {
	idDeclParticle *idp = GetCurParticle();
	if ( idp == NULL ) {
		return;
	}

	if ( strstr( idp->GetFileName(), "implicit" ) ) {
		// defaulted, need to choose a file
		CFileDialog dlgSave( FALSE, "prt", NULL, OFN_OVERWRITEPROMPT, "Particle Files (*.prt)|*.prt||All Files (*.*)|*.*||", AfxGetMainWnd() );
		if ( dlgSave.DoModal() == IDOK ) {
			idStr fileName;
			fileName = fileSystem->OSPathToRelativePath( dlgSave.m_ofn.lpstrFile );
			idp->Save( fileName );
			EnumParticles();
		}
	} else {
		idp->Save();
	}

}

void CDialogParticleEditor::EnumParticles() {
	CWaitCursor cursor;
	comboParticle.ResetContent();
	for ( int i = 0; i < declManager->GetNumDecls( DECL_PARTICLE ); i++ ) {
		const idDecl *idp = declManager->DeclByIndex( DECL_PARTICLE, i );
		int index = comboParticle.AddString( idp->GetName() );
		if ( index >= 0 ) {
			comboParticle.SetItemData( index, i );
		}
	}
	comboParticle.SetCurSel( 0 );
	OnCbnSelchangeComboParticles();
}

void CDialogParticleEditor::OnDestroy() {
	com_editors &= ~EDITOR_PARTICLE;
	return CDialog::OnDestroy();
}

void VectorCallBack( idQuat rotation ) {
	if ( g_ParticleDialog && g_ParticleDialog->GetSafeHwnd() ) {
		g_ParticleDialog->SetVectorControlUpdate( rotation );
	}
}

void CDialogParticleEditor::SetVectorControlUpdate( idQuat rotation ) {
	if ( particleMode ) {
		idList<idEntity*> list;

		list.SetNum( 128 );
		int count = gameEdit->GetSelectedEntities( list.Ptr(), list.Num() );
		list.SetNum( count );

		if ( count ) {
			for ( int i = 0; i < count; i++ ) {
				const idDict *dict = gameEdit->EntityGetSpawnArgs( list[i] );
				if ( dict == NULL ) {
					continue;
				}
				const char *name = dict->GetString( "name" );
				gameEdit->EntitySetAxis( list[i], rotation.ToMat3() );
				gameEdit->EntityUpdateVisuals( list[i] );
				gameEdit->MapSetEntityKeyVal( name, "rotation", rotation.ToMat3().ToString() );
			}
			CWnd *wnd = GetDlgItem( IDC_BUTTON_SAVE_PARTICLEENTITIES );
			if ( wnd ) {
				wnd->EnableWindow( TRUE );
			}
		}
	}
}

BOOL CDialogParticleEditor::OnInitDialog() {

	com_editors |= EDITOR_PARTICLE;

	particleMode = ( cvarSystem->GetCVarInteger( "g_editEntityMode" ) == 4 );
	mapModified = false;

	CDialog::OnInitDialog();

	sliderBunching.SetRange( 0, 20 );
	sliderBunching.SetValueRange( 0.0f, 1.0f );
	sliderFadeIn.SetRange( 0, 20 );
	sliderFadeIn.SetValueRange( 0.0f, 1.0f );
	sliderFadeOut.SetRange( 0, 20 );
	sliderFadeOut.SetValueRange( 0.0f, 1.0f );
	sliderCount.SetRange( 0, 1024 );
	sliderCount.SetValueRange( 0, 4096 );
	sliderTime.SetRange( 0, 200 );
	sliderTime.SetValueRange( 0.0f, 10.0f );
	sliderGravity.SetRange( 0, 600 );
	sliderGravity.SetValueRange( -300.0f, 300.0f );
	sliderSpeedFrom.SetRange( 0, 600 );
	sliderSpeedFrom.SetValueRange( -300.0f, 300.0f );
	sliderSpeedTo.SetRange( 0, 600 );
	sliderSpeedTo.SetValueRange( -300.0f, 300.0f );
	sliderRotationFrom.SetRange( 0, 100 );
	sliderRotationFrom.SetValueRange( 0.0f, 100.0f );
	sliderRotationTo.SetRange( 0, 100 );
	sliderRotationTo.SetValueRange( 0.0f, 100.0f );
	sliderSizeFrom.SetRange( 0, 256 );
	sliderSizeFrom.SetValueRange( 0.0f, 128.0f );
	sliderSizeTo.SetRange( 0, 256 );
	sliderSizeTo.SetValueRange( 0.0f, 128.0f );
	sliderAspectFrom.SetRange( 0, 256 );
	sliderAspectFrom.SetValueRange( 0.0f, 128.0f );
	sliderAspectTo.SetRange( 0, 256 );
	sliderAspectTo.SetValueRange( 0.0f, 128.0f );
	sliderFadeFraction.SetRange( 0, 20 );
	sliderFadeFraction.SetValueRange( 0.0f, 1.0f );

	EnumParticles();
	SetParticleView();

	toolTipCtrl.Create( this );
	toolTipCtrl.Activate( TRUE );

	CWnd* wnd = GetWindow( GW_CHILD );
	CString str;
	while ( wnd ) {
		if ( str.LoadString( wnd->GetDlgCtrlID() ) ) {
			toolTipCtrl.AddTool( wnd, str );
		}
		wnd = wnd->GetWindow( GW_HWNDNEXT );
	}

	wnd = GetDlgItem( IDC_BUTTON_SAVE_PARTICLEENTITIES );
	if ( wnd ) {
		wnd->EnableWindow( FALSE );
	}
	EnableEditControls();

	vectorControl.SetVectorChangingCallback( VectorCallBack );

	return TRUE;  // return TRUE unless you set the focus to a control
	// EXCEPTION: OCX Property Pages should return FALSE
}

void CDialogParticleEditor::OnHScroll( UINT nSBCode, UINT nPos, CScrollBar* pScrollBar ) {
	CDialog::OnHScroll( nSBCode, nPos, pScrollBar );
	CSliderCtrl *ctrl = dynamic_cast< CSliderCtrl* >( pScrollBar );
	if ( !ctrl ) {
		return;
	}
	if ( ctrl == &sliderBunching ) {
		// handle bunching
		bunching = va( "%.3f", sliderBunching.GetValue() );
		DlgVarsToCurStage();
		CurStageToDlgVars();
	} else if ( ctrl == &sliderFadeIn ) {
		fadeIn = va( "%.3f", sliderFadeIn.GetValue() );
		DlgVarsToCurStage();
		CurStageToDlgVars();
	} else if ( ctrl == &sliderFadeOut ) {
		fadeOut = va( "%.3f", sliderFadeOut.GetValue() );
		DlgVarsToCurStage();
		CurStageToDlgVars();
	} else if ( ctrl == &sliderFadeFraction ) {
		fadeFraction = va( "%.3f", sliderFadeFraction.GetValue() );
		DlgVarsToCurStage();
		CurStageToDlgVars();
	} else if ( ctrl == &sliderCount ) {
		count = va( "%i", (int)sliderCount.GetValue() );
		DlgVarsToCurStage();
		CurStageToDlgVars();
	} else if ( ctrl == &sliderTime ) {
		time = va( "%.3f", sliderTime.GetValue() );
		DlgVarsToCurStage();
		CurStageToDlgVars();
	} else if ( ctrl == &sliderGravity ) {
		gravity = va( "%.3f", sliderGravity.GetValue() );
		DlgVarsToCurStage();
		CurStageToDlgVars();
	} else if ( ctrl == &sliderSpeedFrom ) {
		speedFrom = va( "%.3f", sliderSpeedFrom.GetValue() );
		DlgVarsToCurStage();
		CurStageToDlgVars();
	} else if ( ctrl == &sliderSpeedTo ) {
		speedTo = va( "%.3f", sliderSpeedTo.GetValue() );
		DlgVarsToCurStage();
		CurStageToDlgVars();
	} else if ( ctrl == &sliderRotationFrom ) {
		rotationFrom = va( "%.3f", sliderRotationFrom.GetValue() );
		DlgVarsToCurStage();
		CurStageToDlgVars();
	} else if ( ctrl == &sliderRotationTo ) {
		rotationTo = va( "%.3f", sliderRotationTo.GetValue() );
		DlgVarsToCurStage();
		CurStageToDlgVars();
	} else if ( ctrl == &sliderSizeFrom ) {
		sizeFrom = va( "%.3f", sliderSizeFrom.GetValue() );
		DlgVarsToCurStage();
		CurStageToDlgVars();
	} else if ( ctrl == &sliderSizeTo ) {
		sizeTo = va( "%.3f", sliderSizeTo.GetValue() );
		DlgVarsToCurStage();
		CurStageToDlgVars();
	} else if ( ctrl == &sliderAspectFrom ) {
		aspectFrom = va( "%.3f", sliderAspectFrom.GetValue() );
		DlgVarsToCurStage();
		CurStageToDlgVars();
	} else if ( ctrl == &sliderAspectTo ) {
		aspectTo = va( "%.3f", sliderAspectTo.GetValue() );
		DlgVarsToCurStage();
		CurStageToDlgVars();
	}
}


BOOL CDialogParticleEditor::PreTranslateMessage(MSG *pMsg) {
	if ( pMsg->message >= WM_MOUSEFIRST && pMsg->message <= WM_MOUSELAST ) {
		toolTipCtrl.RelayEvent( pMsg );
	}
	return CDialog::PreTranslateMessage(pMsg);
}

void CDialogParticleEditor::EnableStageControls() {
	idParticleStage *stage = GetCurStage();
	bool b = ( stage && stage->hidden ) ? false : true;
	for ( int i = 0; i < StageIDCount; i++ ) {
		CWnd *wnd = GetDlgItem( StageEnableID[ i ] );
		if ( wnd ) {
			wnd->EnableWindow( b );
		}
	}
}

void CDialogParticleEditor::EnableEditControls() {
	for ( int i = 0; i < EditIDCount; i++ ) {
		CWnd *wnd = GetDlgItem( EditEnableID[ i ] );
		if ( wnd ) {
			wnd->EnableWindow( particleMode );
		}
	}
}

void CDialogParticleEditor::UpdateSelectedOrigin( float x, float y, float z ) {
	idList<idEntity*> list;
	idVec3 origin;
	idVec3 vec(x, y, z);

	list.SetNum( 128 );
	int count = gameEdit->GetSelectedEntities( list.Ptr(), list.Num() );
	list.SetNum( count );

	if ( count ) {
		for ( int i = 0; i < count; i++ ) {
			const idDict *dict = gameEdit->EntityGetSpawnArgs( list[i] );
			if ( dict == NULL ) {
				continue;
			}
			const char *name = dict->GetString( "name" );
			gameEdit->EntityTranslate( list[i], vec );
			gameEdit->EntityUpdateVisuals( list[i] );
			gameEdit->MapEntityTranslate( name, vec );
		}
		CWnd *wnd = GetDlgItem( IDC_BUTTON_SAVE_PARTICLEENTITIES );
		if ( wnd ) {
			wnd->EnableWindow( TRUE );
		}
	}
}

void CDialogParticleEditor::OnBtnYup()
{
	UpdateSelectedOrigin(0, 8, 0);
}

void CDialogParticleEditor::OnBtnYdn()
{
	UpdateSelectedOrigin(0, -8, 0);
}

void CDialogParticleEditor::OnBtnXdn()
{
	UpdateSelectedOrigin(-8, 0, 0);
}

void CDialogParticleEditor::OnBtnXup()
{
	UpdateSelectedOrigin(8, 0, 0);
}

void CDialogParticleEditor::OnBtnZup()
{
	UpdateSelectedOrigin(0, 0, 8);
}

void CDialogParticleEditor::OnBtnZdn()
{
	UpdateSelectedOrigin(0, 0, -8);
}

void CDialogParticleEditor::OnBtnDrop()
{
	idStr		classname;
	idStr		key;
	idStr		value;
	idVec3		org;
	idDict		args;
	idAngles	viewAngles;

	if ( !gameEdit->PlayerIsValid() ) {
		return;
	}

	gameEdit->PlayerGetViewAngles( viewAngles );
	gameEdit->PlayerGetEyePosition( org );

	org += idAngles( 0, viewAngles.yaw, 0 ).ToForward() * 80 + idVec3( 0, 0, 1 );
	args.Set("origin", org.ToString());
	args.Set("classname", "func_emitter");
	args.Set("angle", va( "%f", viewAngles.yaw + 180 ));

	idDeclParticle *idp = GetCurParticle();
	if ( idp == NULL ) {
		return;
	}
	idStr str = idp->GetName();
	str.SetFileExtension( ".prt" );

	args.Set("model", str);

	idStr name = gameEdit->GetUniqueEntityName( "func_emitter" );
	bool nameValid = false;
	while (!nameValid) {
		DialogName dlg("Name Particle", this);
		dlg.m_strName = name;
		if (dlg.DoModal() == IDOK) {
			idEntity *gameEnt = gameEdit->FindEntity( dlg.m_strName );
			if (gameEnt) {
				if (MessageBox("Please choose another name", "Duplicate Entity Name!", MB_OKCANCEL) == IDCANCEL) {
					return;
				}
			} else {
				nameValid = true;
				name = dlg.m_strName;
			}
		}
	}

	args.Set("name", name.c_str());

	idEntity *ent = NULL;
	gameEdit->SpawnEntityDef( args, &ent );
	if (ent) {
		gameEdit->EntityUpdateChangeableSpawnArgs( ent, NULL );
		gameEdit->ClearEntitySelection();
		gameEdit->AddSelectedEntity( ent );
	}

	gameEdit->MapAddEntity( &args );
}

void CDialogParticleEditor::OnOK()
{
	// never return on OK as windows will map this at times when you don't want
	// ENTER closing the dialog
	// CDialog::OnOK();
}