windows-xp/Source/XPSP1/NT/shell/osshell/control/scrnsave/swoosh/swoosh.cpp

#include	"Swoosh.h"
#include	"Resource.h"
#include	<commdlg.h>
#include	<commctrl.h>

#define	SAFE_RELEASE(p) if(p){(p)->Release();(p)=NULL;};

struct	SimpleVertex
{
	D3DXVECTOR3	pos;
	D3DCOLOR	colour;
	float		u,v;
};
#define	FVF_SimpleVertex	(D3DFVF_XYZ|D3DFVF_DIFFUSE|D3DFVF_TEX1)

#define	PARTICLES_PER_VB	256

typedef	unsigned char UBYTE;

CSwoosh	g_Swoosh;	

const float	pi = 3.1415926536f;
const float	pi2 = pi * 2.0f;

const float	TUBE_LENGTH = 20.0f;
const float	TUBE_RADIUS = 5.0f;
const float	FALLOFF_FACTOR = (255.0f/((TUBE_LENGTH*TUBE_LENGTH)+(TUBE_RADIUS*TUBE_RADIUS)))*0.98f;

const float	MAX_FLOW_RATE = 8.0f;
const float MAX_ROLL_RATE = 4.0f;
const float MAX_YAW_RATE = 5.0f;
const float MIN_PARTICLE_SIZE = 0.01f;
const float MAX_PARTICLE_SIZE = 0.5f;

//**********************************************************************************
int WINAPI	WinMain( HINSTANCE hInstance , HINSTANCE , LPSTR lpCmdLine , int )
{
	if ( FAILED(g_Swoosh.Create( hInstance )) )
		return -1;

	return	g_Swoosh.Run();
}

//**********************************************************************************
CSwoosh::CSwoosh()
{
	D3DXMatrixLookAtLH( &m_Camera , &D3DXVECTOR3(0,0,0) , &D3DXVECTOR3(0,0,1) ,
						&D3DXVECTOR3(0,1,0) );
	m_fCameraYaw = m_fCameraRoll = 0;
	m_fYawDirection = 0;
	m_fYawPause = 6.0f;

	m_fParticleSize = 0.15f;
	m_dwNumParticles = MAX_PARTICLES;
	m_dwColourMix = 0x2000;
	m_dwColour1 = 0xffffff;
	m_dwColour2 = 0x0000ff;
	m_fFlowRate = 4.0f;
	m_fRollRate = 1.0f;
	m_fYawRate = 1.0f;
	m_dwFixedColour1 = 0xffffff;
	m_dwFixedColour2 = 0x1111ff;
}

//**********************************************************************************
HRESULT	CSwoosh::Create( HINSTANCE hInstance )
{
	// Do base class Create
	HRESULT	rc = CD3DScreensaver::Create( hInstance );
	if ( FAILED(rc) )
		return rc;

	// Initialise particles
	InitParticles();

	return S_OK;
}

//**********************************************************************************
CSwoosh::DeviceObjects::DeviceObjects()
{
	pBlobTexture = NULL;
}

//**********************************************************************************
HRESULT CSwoosh::RegisterSoftwareDevice()
{ 
    m_pD3D->RegisterSoftwareDevice( D3D8RGBRasterizer );

    return S_OK; 
}


//**********************************************************************************
void	CSwoosh::InitParticles()
{
	// Initialise particles, by evenly distributing them in a cylinder along the
	// z-axis [-30,30] with radius 3.0. Choose colours based on colour settings

	Particle*	pparticle = m_Particles;
	for ( int i = 0 ; i < MAX_PARTICLES ; i++ )
	{
		// Pick z position for particle, evenly distribute in range [-TUBE_LENGTH,TUBE_LENGTH]
		pparticle->pos.z = (float(rand()&0x7fff) * (TUBE_LENGTH*2.0f/32767.0f)) - TUBE_LENGTH;

		// Pick (x,y) position for particle. We evenly distribute in a circle radius 3.0f
		float	rad = (float(rand()&0x7fff) * (1.0f/32767.0f));
		rad = sqrtf(rad);
		rad *= TUBE_RADIUS;
		float	angle = float(rand()&0x7fff) * (pi2/32767.0f);
		pparticle->pos.x = rad * sinf(angle);
		pparticle->pos.y = rad * cosf(angle);

		// Pick colour for particle. It's one of the two colour sets. Each colour set is
		// either one particular colour, or random (denoted by 0xffffffff)
		if ( DWORD(rand()&0x3fff) > m_dwColourMix )
		{
			if ( m_dwColour1 != 0xffffffff )
				pparticle->colour = m_dwColour1;
			else
				pparticle->colour = (rand()&0xff)|((rand()&0xff)<<8)|((rand()&0xff)<<16);
		}
		else
		{
			if ( m_dwColour2 != 0xffffffff )
				pparticle->colour = m_dwColour2;
			else
				pparticle->colour = (rand()&0xff)|((rand()&0xff)<<8)|((rand()&0xff)<<16);
		}

		pparticle++;
	}
}

//**********************************************************************************
void    CSwoosh::SetDevice( UINT iDevice )
{
	// Point at the correct set of device data
	m_pDeviceObjects = &m_DeviceObjects[iDevice];

	// Figure out if vertices for this device should be software VP or not
	if ( m_RenderUnits[iDevice].dwBehavior & D3DCREATE_HARDWARE_VERTEXPROCESSING )
		m_dwVertMemType = 0;
	else
		m_dwVertMemType = D3DUSAGE_SOFTWAREPROCESSING;
}

//**********************************************************************************
HRESULT CSwoosh::RestoreDeviceObjects()
{
	HRESULT	rc;

	// Create "blob" texture
	rc = D3DXCreateTextureFromResource( m_pd3dDevice , NULL , MAKEINTRESOURCE(IDB_BLOB) ,
										&m_pDeviceObjects->pBlobTexture );
	if ( FAILED(rc) )
		return rc;

	// Create vertex buffer to hold particles
	rc = m_pd3dDevice->CreateVertexBuffer( sizeof(SimpleVertex)*4*PARTICLES_PER_VB ,
										   D3DUSAGE_DYNAMIC|D3DUSAGE_WRITEONLY|m_dwVertMemType ,
										   FVF_SimpleVertex , D3DPOOL_DEFAULT ,
										   &m_pDeviceObjects->pParticleVB );
	if ( FAILED(rc) )
		return rc;

	// Create index buffer to hold particle indices
	rc = m_pd3dDevice->CreateIndexBuffer( sizeof(WORD)*6*PARTICLES_PER_VB ,
										  D3DUSAGE_WRITEONLY|m_dwVertMemType ,
										  D3DFMT_INDEX16 , D3DPOOL_DEFAULT ,
										  &m_pDeviceObjects->pParticleIB );
	if ( FAILED(rc) )
		return rc;

	// Populate index buffer with indices for a series of disjoint quads
	WORD*	pidx;
	m_pDeviceObjects->pParticleIB->Lock( 0 , sizeof(WORD)*6*PARTICLES_PER_VB , (BYTE**)&pidx ,
										 D3DLOCK_NOSYSLOCK );
	WORD	index = 0;
	for ( int i = 0 ; i < PARTICLES_PER_VB ; i++ )
	{
		*pidx++ = index; *pidx++ = index+1; *pidx++ = index+3;
		*pidx++ = index; *pidx++ = index+3; *pidx++ = index+2;
		index += 4;
	}
	m_pDeviceObjects->pParticleIB->Unlock();

	// Set up world and view matrices
	D3DXMATRIX	world;
	D3DXMatrixIdentity( &world );
	m_pd3dDevice->SetTransform( D3DTS_WORLDMATRIX(0) , &world );
	m_pd3dDevice->SetTransform( D3DTS_VIEW , &m_Camera );

	// Set alpha blending mode to SRCALPHA:ONE
	m_pd3dDevice->SetRenderState( D3DRS_ALPHABLENDENABLE , TRUE );
	m_pd3dDevice->SetRenderState( D3DRS_SRCBLEND , D3DBLEND_SRCALPHA );
	m_pd3dDevice->SetRenderState( D3DRS_DESTBLEND , D3DBLEND_ONE );

	// Set pixel pipe to single texture modulated by diffuse colour
	m_pd3dDevice->SetTextureStageState( 0 , D3DTSS_COLOROP , D3DTOP_MODULATE );
	m_pd3dDevice->SetTextureStageState( 0 , D3DTSS_COLORARG1 , D3DTA_TEXTURE );
	m_pd3dDevice->SetTextureStageState( 0 , D3DTSS_COLORARG2 , D3DTA_DIFFUSE );
	m_pd3dDevice->SetTextureStageState( 1 , D3DTSS_COLOROP , D3DTOP_DISABLE );
	m_pd3dDevice->SetTextureStageState( 0 , D3DTSS_ALPHAOP , D3DTOP_SELECTARG2 );
	m_pd3dDevice->SetTextureStageState( 0 , D3DTSS_ALPHAARG1 , D3DTA_TEXTURE );
	m_pd3dDevice->SetTextureStageState( 0 , D3DTSS_ALPHAARG2 , D3DTA_DIFFUSE );
	m_pd3dDevice->SetTextureStageState( 1 , D3DTSS_ALPHAOP , D3DTOP_DISABLE );

	// Bind "blob" texture to stage 0, and set filter mode to bilinear
	m_pd3dDevice->SetTexture( 0 , m_pDeviceObjects->pBlobTexture );
	m_pd3dDevice->SetTextureStageState( 0 , D3DTSS_MAGFILTER , D3DTEXF_LINEAR );
	m_pd3dDevice->SetTextureStageState( 0 , D3DTSS_MINFILTER , D3DTEXF_LINEAR );
	m_pd3dDevice->SetTextureStageState( 0 , D3DTSS_MIPFILTER , D3DTEXF_POINT );

	// Disable culling, lighting, and specular
	m_pd3dDevice->SetRenderState( D3DRS_CULLMODE , D3DCULL_NONE );
	m_pd3dDevice->SetRenderState( D3DRS_LIGHTING , FALSE );
	m_pd3dDevice->SetRenderState( D3DRS_SPECULARENABLE , FALSE );

	// Set vertex shader to fixed-function pipeline for SimpleVertex
	m_pd3dDevice->SetVertexShader( FVF_SimpleVertex );

	// Bind vertex stream 0 and index source to the particle VB/IB
	m_pd3dDevice->SetStreamSource( 0 , m_pDeviceObjects->pParticleVB , sizeof(SimpleVertex) );
	m_pd3dDevice->SetIndices( m_pDeviceObjects->pParticleIB , 0 );

	return S_OK;
}

//**********************************************************************************
HRESULT CSwoosh::InvalidateDeviceObjects()
{
	SAFE_RELEASE(m_pDeviceObjects->pParticleVB);
	SAFE_RELEASE(m_pDeviceObjects->pParticleIB);
	SAFE_RELEASE(m_pDeviceObjects->pBlobTexture);

	return S_OK;
}

//**********************************************************************************
HRESULT CSwoosh::FrameMove()
{
	UpdateParticles();
	UpdateCamera();
	return S_OK;
}

//**********************************************************************************
void	CSwoosh::UpdateCamera()
{
	// Adjust camera roll
	m_fCameraRoll += m_fElapsedTime * m_fRollRate;

	// Adjust camera yaw. If we're not yawing, then countdown pause timer
	if ( m_fYawDirection == 0.0f )
	{
		m_fYawPause -= m_fElapsedTime;
		if ( m_fYawPause <= 0.0f )
		{
			// Done pausing, so reset timer and pick yaw direction
			m_fYawPause = 6.0f;

			if ( m_fCameraYaw == 0.0f )
				m_fYawDirection = m_fYawRate;
			else
				m_fYawDirection = -m_fYawRate;
		}
	}
	else
	{
		// Yawing, so adjust yaw parameter
		m_fCameraYaw += m_fElapsedTime * m_fYawDirection;

		// If we've hit the end, stop yawing
		if ( m_fYawDirection == m_fYawRate )
		{
			if ( m_fCameraYaw >= pi )
			{
				m_fCameraYaw = pi;
				m_fYawDirection = 0.0f;
			}
		}
		else
		{
			if ( m_fCameraYaw <= 0.0f )
			{
				m_fCameraYaw = 0.0f;
				m_fYawDirection = 0.0f;
			}
		}
	}

	// Compute matrices for roll and yaw components of orientation
	// We smooth out the yaw via a cos to give a nice slow rolloff at each end
	D3DXMATRIX	roll,yaw;
	D3DXMatrixRotationZ( &roll , m_fCameraRoll );
	D3DXMatrixRotationY( &yaw , pi * 0.5f * (1.0f - cosf(m_fCameraYaw)) );
	D3DXMatrixLookAtLH( &m_Camera , &D3DXVECTOR3(0,0,0) , &D3DXVECTOR3(0,0,1) ,
						&D3DXVECTOR3(0,1,0) );

	// Compute final camera matrix
	m_Camera = m_Camera * yaw * roll;
}

//**********************************************************************************
void	CSwoosh::UpdateParticles()
{
	Particle*	pparticle = m_Particles;
	for ( DWORD i = 0 ; i < m_dwNumParticles ; i++ )
	{
		// Flow particle along cylinder
		pparticle->pos.z -= m_fElapsedTime * m_fFlowRate;

		// If we reached the end, warp to other end of cylinder
		if ( pparticle->pos.z < -TUBE_LENGTH )
			pparticle->pos.z += TUBE_LENGTH*2.0f;			

		// Compute particle distance to camera and scale alpha
		// value by distance (to give slight fade out)
		float	dist = (pparticle->pos.x * pparticle->pos.x) +
					   (pparticle->pos.y * pparticle->pos.y) +
					   (pparticle->pos.z * pparticle->pos.z);
		UBYTE	alpha = UBYTE(255.0f - (dist * FALLOFF_FACTOR));
		pparticle->colour |= (alpha<<24);

		pparticle++;
	}
}

//**********************************************************************************
HRESULT CSwoosh::Render()
{
	// Clear the buffer, and set up projection matrix for this device
	m_pd3dDevice->Clear( 0 , NULL , D3DCLEAR_TARGET , 0 , 1.0f , 0 );
	SetProjectionMatrix( 0.1f , 200.0f );

	// Set camera
	m_pd3dDevice->SetTransform( D3DTS_VIEW , &m_Camera );

	m_pd3dDevice->BeginScene();

	RenderParticles();

	m_pd3dDevice->EndScene();

	return S_OK;
}

//**********************************************************************************
void	CSwoosh::RenderParticles()
{
	DWORD		particles_left = m_dwNumParticles;
	Particle*	pparticle = m_Particles;

	// Compute offsets from particle center to make camera facing billboard
	// We cheat a little and use the same offsets for all the particles, orienting
	// them to be perpendicular to the view direction rather than to the view vector
	// to the particle centre. It's faster and the effect is close enough.
	D3DXVECTOR3	offset[4];
	D3DXVECTOR3	dx,dy;
	dx.x = m_Camera._11; dx.y = m_Camera._21; dx.z = m_Camera._31;
	dy.x = m_Camera._12; dy.y = m_Camera._22; dy.z = m_Camera._32;
	dx *= m_fParticleSize;
	dy *= m_fParticleSize;
	offset[0] = -dx+dy;
	offset[1] =  dx+dy;
	offset[2] = -dx-dy;
	offset[3] =  dx-dy;

	D3DXVECTOR3	look;
	look.x = m_Camera._13; look.y = m_Camera._23; look.z = m_Camera._33;

	DWORD			batch_size = 0;
	SimpleVertex*	pverts;
	m_pDeviceObjects->pParticleVB->Lock( 0 , 0 , (BYTE**)&pverts ,
										 D3DLOCK_DISCARD|D3DLOCK_NOSYSLOCK );
	for ( DWORD i = 0 ; i < m_dwNumParticles ; i++ , pparticle++ )
	{
		// Don't render if it's behind us
		if ( ((pparticle->pos.x*look.x) + (pparticle->pos.y*look.y) +
			  (pparticle->pos.z*look.z)) <= 0 )
			  continue;

		// Tack particle onto buffer
		pverts->pos = pparticle->pos + offset[0];
		pverts->colour = pparticle->colour;
		pverts->u = 0; pverts->v = 0;
		pverts++;
		pverts->pos = pparticle->pos + offset[1];
		pverts->colour = pparticle->colour;
		pverts->u = 1; pverts->v = 0;
		pverts++;
		pverts->pos = pparticle->pos + offset[2];
		pverts->colour = pparticle->colour;
		pverts->u = 0; pverts->v = 1;
		pverts++;
		pverts->pos = pparticle->pos + offset[3];
		pverts->colour = pparticle->colour;
		pverts->u = 1; pverts->v = 1;
		pverts++;

		// If we've hit the buffer max, then flush it
		if ( ++batch_size == PARTICLES_PER_VB )
		{
			m_pDeviceObjects->pParticleVB->Unlock();
			m_pd3dDevice->DrawIndexedPrimitive( D3DPT_TRIANGLELIST , 0 , 4*PARTICLES_PER_VB ,
											   0 , 2*PARTICLES_PER_VB );
			m_pDeviceObjects->pParticleVB->Lock( 0 , 0 , (BYTE**)&pverts ,
												 D3DLOCK_DISCARD|D3DLOCK_NOSYSLOCK );
			batch_size = 0;
		}
	}

	// Flush last batch
	m_pDeviceObjects->pParticleVB->Unlock();
	if ( batch_size > 0 )
	{
		m_pd3dDevice->DrawIndexedPrimitive( D3DPT_TRIANGLELIST , 0 , 4*batch_size ,
											0 , 2*batch_size );
	}
}

//**********************************************************************************
void	CSwoosh::ReadSettings()
{
    HKEY hkey;
    DWORD dwType = REG_DWORD;
    DWORD dwLength = sizeof(DWORD);

// Couple of macros to reduce typing. We just want to check if the registry read was okay, if it wasn't
// then we set a default value, if it was then we check against valid boundaries. For floats we also make
// sure the float is finite (not NaN or +/-INF).
#define	DEFAULT_AND_BOUND(v,d,l,h) if (rc!=ERROR_SUCCESS){v=d;}else if(v<=l){v=l;}else if(v>h){v=h;};
#define	DEFAULT_AND_BOUND_FLOAT(v,d,l,h) if (rc!=ERROR_SUCCESS||!_finite(v)){v=d;}else if(v<l){v=l;}else if(v>h){v=h;};

	// Open our reg key
    if( ERROR_SUCCESS == RegCreateKeyEx( HKEY_CURRENT_USER, TEXT("Software\\Microsoft\\Swoosh"), 
        0, NULL, REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, &hkey, NULL ) )
    {
		LONG	rc;

		// Read NumParticles
        rc = RegQueryValueEx( hkey, TEXT("NumParticles"), NULL, &dwType, (BYTE*)&m_dwNumParticles, &dwLength);
		DEFAULT_AND_BOUND(m_dwNumParticles,MAX_PARTICLES/2,1,MAX_PARTICLES);

		// Read FlowRate (float, but we munge into DWORD datatype)
        rc = RegQueryValueEx( hkey, TEXT("fFlowRate"), NULL, &dwType, (BYTE*)&m_fFlowRate, &dwLength);
		DEFAULT_AND_BOUND_FLOAT(m_fFlowRate,4.0f,0,MAX_FLOW_RATE);

		// Read RollRate (float, but we munge into DWORD datatype)
        rc = RegQueryValueEx( hkey, TEXT("fRollRate"), NULL, &dwType, (BYTE*)&m_fRollRate, &dwLength);
		DEFAULT_AND_BOUND_FLOAT(m_fRollRate,1.0f,0,MAX_ROLL_RATE);

		// Read YawRate (float, but we munge into DWORD datatype)
        rc = RegQueryValueEx( hkey, TEXT("fYawRate"), NULL, &dwType, (BYTE*)&m_fYawRate, &dwLength);
		DEFAULT_AND_BOUND_FLOAT(m_fYawRate,1.0f,0,MAX_YAW_RATE);

		// Read ParticleSize (float, but we munge into DWORD datatype)
        rc = RegQueryValueEx( hkey, TEXT("fParticleSize"), NULL, &dwType, (BYTE*)&m_fParticleSize, &dwLength);
		DEFAULT_AND_BOUND_FLOAT(m_fParticleSize,0.15f,MIN_PARTICLE_SIZE,MAX_PARTICLE_SIZE);

		// Read ColourMix
        rc = RegQueryValueEx( hkey, TEXT("ColourMix"), NULL, &dwType, (BYTE*)&m_dwColourMix, &dwLength);
		DEFAULT_AND_BOUND(m_dwColourMix,0x2000,0,0x4000);

		// Read Colours
        rc = RegQueryValueEx( hkey, TEXT("Colour1"), NULL, &dwType, (BYTE*)&m_dwColour1, &dwLength);
		if ( rc != ERROR_SUCCESS )
			m_dwColour1 = 0xffffff;
		else if ( m_dwColour1 != 0xffffffff )
			m_dwColour1 &= 0x00ffffff;
        rc = RegQueryValueEx( hkey, TEXT("Colour2"), NULL, &dwType, (BYTE*)&m_dwColour2, &dwLength);
		if ( rc != ERROR_SUCCESS )
			m_dwColour2 = 0xffffffff;
		else if ( m_dwColour2 != 0xffffffff )
			m_dwColour2 &= 0x00ffffff;
        rc = RegQueryValueEx( hkey, TEXT("FixedColour1"), NULL, &dwType, (BYTE*)&m_dwFixedColour1, &dwLength);
		if ( rc != ERROR_SUCCESS )
			m_dwFixedColour1 = 0xffffff;
		else
			m_dwFixedColour1 &= 0x00ffffff;
        rc = RegQueryValueEx( hkey, TEXT("FixedColour2"), NULL, &dwType, (BYTE*)&m_dwFixedColour2, &dwLength);
		if ( rc != ERROR_SUCCESS )
			m_dwFixedColour2 = 0xffffff;
		else
			m_dwFixedColour2 &= 0x00ffffff;

		// Read settings for screen setup (multimon gubbins)
        ReadScreenSettings( hkey );

		// Done
        RegCloseKey( hkey );
    }
}

//**********************************************************************************
void	CSwoosh::WriteSettings()
{
    HKEY hkey;
    DWORD dwType = REG_DWORD;
    DWORD dwLength = sizeof(DWORD);

	// Open our reg key
    if( ERROR_SUCCESS == RegCreateKeyEx( HKEY_CURRENT_USER, TEXT("Software\\Microsoft\\Swoosh"), 
        0, NULL, REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, &hkey, NULL ) )
    {
		// Write out all the settings (we munge floats into DWORDs)
        RegSetValueEx( hkey, TEXT("NumParticles"), NULL, REG_DWORD, (BYTE*)&m_dwNumParticles, sizeof(DWORD) );
        RegSetValueEx( hkey, TEXT("ColourMix"), NULL, REG_DWORD, (BYTE*)&m_dwColourMix, sizeof(DWORD) );
        RegSetValueEx( hkey, TEXT("Colour1"), NULL, REG_DWORD, (BYTE*)&m_dwColour1, sizeof(DWORD) );
        RegSetValueEx( hkey, TEXT("Colour2"), NULL, REG_DWORD, (BYTE*)&m_dwColour2, sizeof(DWORD) );
        RegSetValueEx( hkey, TEXT("fFlowRate"), NULL, REG_DWORD, (BYTE*)&m_fFlowRate, sizeof(DWORD) );
        RegSetValueEx( hkey, TEXT("fRollRate"), NULL, REG_DWORD, (BYTE*)&m_fRollRate, sizeof(DWORD) );
        RegSetValueEx( hkey, TEXT("fYawRate"), NULL, REG_DWORD, (BYTE*)&m_fYawRate, sizeof(DWORD) );
        RegSetValueEx( hkey, TEXT("fParticleSize"), NULL, REG_DWORD, (BYTE*)&m_fParticleSize, sizeof(DWORD) );
        RegSetValueEx( hkey, TEXT("FixedColour1"), NULL, REG_DWORD, (BYTE*)&m_dwFixedColour1, sizeof(DWORD) );
        RegSetValueEx( hkey, TEXT("FixedColour2"), NULL, REG_DWORD, (BYTE*)&m_dwFixedColour2, sizeof(DWORD) );

		// Write screen settings out (multimon gubbins)
        WriteScreenSettings( hkey );

		// Done
        RegCloseKey( hkey );
    }
}

//**********************************************************************************
void	CSwoosh::DoConfig()
{
	// Make sure we've got the common controls we need loaded
    InitCommonControls();

	// Do the dialog box
	DialogBox( m_hInstance , MAKEINTRESOURCE(IDD_SETTINGS) , NULL , ConfigDlgProcStub );
}

//**********************************************************************************
BOOL CALLBACK CSwoosh::ConfigDlgProcStub( HWND hDlg , UINT msg , WPARAM wParam , LPARAM lParam )
{
	return g_Swoosh.ConfigDlgProc( hDlg , msg , wParam , lParam );
}

//**********************************************************************************
BOOL	CSwoosh::ConfigDlgProc( HWND hDlg , UINT msg , WPARAM wParam , LPARAM lParam )
{
	HWND	hNumParticles = GetDlgItem( hDlg , IDC_NUM_PARTICLES );
	HWND	hColourMix = GetDlgItem( hDlg , IDC_COLOUR_MIX );
	HWND	hFlowRate = GetDlgItem( hDlg , IDC_FLOW_RATE );
	HWND	hRollRate = GetDlgItem( hDlg , IDC_ROLL_RATE );
	HWND	hYawRate = GetDlgItem( hDlg , IDC_YAW_RATE );
	HWND	hParticleSize = GetDlgItem( hDlg , IDC_PARTICLE_SIZE );

	switch ( msg )
	{
		case WM_INITDIALOG:
			// Set up ranges on the sliders. Map floats into integer range [0,10000]
			SendMessage( hNumParticles , TBM_SETRANGE , FALSE , MAKELONG(0,MAX_PARTICLES) );
			SendMessage( hColourMix , TBM_SETRANGE , FALSE , MAKELONG(0,0x4000) );
			SendMessage( hFlowRate , TBM_SETRANGE , FALSE , MAKELONG(0,10000) );
			SendMessage( hRollRate , TBM_SETRANGE , FALSE , MAKELONG(0,10000) );
			SendMessage( hYawRate , TBM_SETRANGE , FALSE , MAKELONG(0,10000) );
			SendMessage( hParticleSize , TBM_SETRANGE , FALSE , MAKELONG(0,10000) );

			// Set initial values on the sliders
			SendMessage( hNumParticles , TBM_SETPOS , TRUE , m_dwNumParticles );
			SendMessage( hColourMix , TBM_SETPOS , TRUE , m_dwColourMix );
			SendMessage( hFlowRate , TBM_SETPOS , TRUE , DWORD(m_fFlowRate * (10000.0f/MAX_FLOW_RATE)) );
			SendMessage( hRollRate , TBM_SETPOS , TRUE , DWORD(m_fRollRate * (10000.0f/MAX_ROLL_RATE)) );
			SendMessage( hYawRate , TBM_SETPOS , TRUE , DWORD(m_fYawRate * (10000.0f/MAX_YAW_RATE)) );
			SendMessage( hParticleSize , TBM_SETPOS , TRUE ,
						 DWORD((m_fParticleSize-MIN_PARTICLE_SIZE)*(10000.0f/(MAX_PARTICLE_SIZE-MIN_PARTICLE_SIZE))) );

			// Set up radio buttons for colour sets. Disable "pick.." button if multicoloured is selected
			if ( m_dwColour1 == 0xffffffff )
			{
				CheckRadioButton( hDlg , IDC_COLOUR1_MULTI , IDC_COLOUR1_FIXED , IDC_COLOUR1_MULTI );
				EnableWindow( GetDlgItem( hDlg , IDC_COLOUR1_PICK ) , FALSE );
			}
			else
				CheckRadioButton( hDlg , IDC_COLOUR1_MULTI , IDC_COLOUR1_FIXED , IDC_COLOUR1_FIXED );

			if ( m_dwColour2 == 0xffffffff )
			{
				CheckRadioButton( hDlg , IDC_COLOUR2_MULTI , IDC_COLOUR2_FIXED , IDC_COLOUR2_MULTI );
				EnableWindow( GetDlgItem( hDlg , IDC_COLOUR2_PICK ) , FALSE );
			}
			else
				CheckRadioButton( hDlg , IDC_COLOUR2_MULTI , IDC_COLOUR2_FIXED , IDC_COLOUR2_FIXED );

			return FALSE;

		case WM_COMMAND:
			switch ( LOWORD(wParam) )
			{
				case IDOK:
					ExtractDialogSettings( hDlg );
					WriteSettings();
					EndDialog( hDlg , IDOK );
					break;

				case IDCANCEL:
					EndDialog( hDlg , IDCANCEL );
					break;

				case IDC_SCREEN_SETTINGS:
					DoScreenSettingsDialog( hDlg );
					break;

				case IDC_COLOUR1_MULTI:
					EnableWindow( GetDlgItem( hDlg , IDC_COLOUR1_PICK ) , FALSE );
					break;

				case IDC_COLOUR2_MULTI:
					EnableWindow( GetDlgItem( hDlg , IDC_COLOUR2_PICK ) , FALSE );
					break;

				case IDC_COLOUR1_FIXED:
					EnableWindow( GetDlgItem( hDlg , IDC_COLOUR1_PICK ) , TRUE );
					break;

				case IDC_COLOUR2_FIXED:
					EnableWindow( GetDlgItem( hDlg , IDC_COLOUR2_PICK ) , TRUE );
					break;

				case IDC_COLOUR1_PICK:
					m_dwFixedColour1 = PickColour( hDlg , m_dwFixedColour1 );
					break;

				case IDC_COLOUR2_PICK:
					m_dwFixedColour2 = PickColour( hDlg , m_dwFixedColour2 );
					break;
			}
			return TRUE;

		default:
			return FALSE;
	}
}

//**********************************************************************************
DWORD	CSwoosh::PickColour( HWND hParent , DWORD defcolour )
{
	CHOOSECOLOR		choose;
	static COLORREF	custom[16];

	choose.lStructSize = sizeof(choose);
	choose.hwndOwner = hParent;
	choose.rgbResult = ((defcolour&0xff)<<16)|((defcolour&0xff00))|((defcolour&0xff0000)>>16);
	choose.lpCustColors = custom;
	choose.Flags = CC_ANYCOLOR|CC_FULLOPEN|CC_RGBINIT;

	if ( ChooseColor( &choose ) )
		return ((choose.rgbResult&0xff)<<16)|((choose.rgbResult&0xff00)|(choose.rgbResult&0xff0000)>>16);
	else
		return defcolour;
}

//**********************************************************************************
void	CSwoosh::ExtractDialogSettings( HWND hDlg )
{
	HWND	hNumParticles = GetDlgItem( hDlg , IDC_NUM_PARTICLES );
	HWND	hColourMix = GetDlgItem( hDlg , IDC_COLOUR_MIX );
	HWND	hFlowRate = GetDlgItem( hDlg , IDC_FLOW_RATE );
	HWND	hRollRate = GetDlgItem( hDlg , IDC_ROLL_RATE );
	HWND	hYawRate = GetDlgItem( hDlg , IDC_YAW_RATE );
	HWND	hParticleSize = GetDlgItem( hDlg , IDC_PARTICLE_SIZE );

	float	f;

	m_dwNumParticles = SendMessage( hNumParticles , TBM_GETPOS , 0 , 0 );
	m_dwColourMix = SendMessage( hColourMix , TBM_GETPOS , 0 , 0 );

	f = (float)SendMessage( hFlowRate , TBM_GETPOS , 0 , 0 );
	m_fFlowRate = f * (MAX_FLOW_RATE/10000.0f);

	f = (float)SendMessage( hRollRate , TBM_GETPOS , 0 , 0 );
	m_fRollRate = f * (MAX_ROLL_RATE/10000.0f);

	f = (float)SendMessage( hYawRate , TBM_GETPOS , 0 , 0 );
	m_fYawRate = f * (MAX_YAW_RATE/10000.0f);

	f = (float)SendMessage( hParticleSize , TBM_GETPOS , 0 , 0 );
	m_fParticleSize = (f * ((MAX_PARTICLE_SIZE-MIN_PARTICLE_SIZE)/10000.0f)) + MIN_PARTICLE_SIZE;

	if ( IsDlgButtonChecked( hDlg , IDC_COLOUR1_MULTI ) )
		m_dwColour1 = 0xffffffff;
	else
		m_dwColour1 = m_dwFixedColour1;

	if ( IsDlgButtonChecked( hDlg , IDC_COLOUR2_MULTI ) )
		m_dwColour2 = 0xffffffff;
	else
		m_dwColour2 = m_dwFixedColour2;
}