1042 lines
25 KiB
C++
1042 lines
25 KiB
C++
//========= Copyright Valve Corporation, All rights reserved. ============//
|
|
//
|
|
// Purpose:
|
|
//
|
|
//=============================================================================
|
|
|
|
#include "stdafx.h"
|
|
#include "hammer.h"
|
|
#include "ObjectBar.h"
|
|
#include "Options.h"
|
|
#include "ControlBarIDs.h"
|
|
#include "Prefabs.h"
|
|
#include "Prefab3D.h"
|
|
#include "StockSolids.h"
|
|
#include "mainfrm.h"
|
|
#include "MapSolid.h"
|
|
#include "MapWorld.h"
|
|
#include "MapDoc.h"
|
|
#include "GlobalFunctions.h"
|
|
#include "ArchDlg.h"
|
|
#include "TorusDlg.h"
|
|
#include "ToolManager.h"
|
|
#include "mathlib/vector.h"
|
|
#include "mapview2d.h"
|
|
|
|
// memdbgon must be the last include file in a .cpp file!!!
|
|
#include <tier0/memdbgon.h>
|
|
|
|
|
|
#pragma warning( disable : 4355 )
|
|
|
|
|
|
CMapClass *CreateArch(BoundBox *pBox, float fStartAngle, int iSides, float fArc,
|
|
int iWallWidth, int iAddHeight, BOOL bPreview);
|
|
|
|
CMapClass *CreateTorus(BoundBox *pBox, float fStartAngle, int iSides, float fArc, int iWallWidth, float flCrossSectionalRadius,
|
|
float fRotationStartAngle, int iRotationSides, float fRotationArc, int iAddHeight, BOOL bPreview);
|
|
|
|
|
|
static int _iNewObjIndex = 0;
|
|
static char _szNewObjName[128];
|
|
|
|
struct SolidTypeInfo_t
|
|
{
|
|
LPCTSTR pszName;
|
|
UINT nFaces;
|
|
UINT nFacesMin;
|
|
UINT nFacesMax;
|
|
bool bEnableFaceControl;
|
|
};
|
|
|
|
|
|
SolidTypeInfo_t SolidTypes[] =
|
|
{
|
|
{"block", 0, 6, 6, false},
|
|
{"wedge", 0, 5, 5, false},
|
|
{"cylinder", 8, 3, 32, true},
|
|
{"spike", 4, 3, 32, true},
|
|
{"sphere", 8, 3, 16, true},
|
|
{"arch", 8, 3, 128, true},
|
|
{"torus", 0, 4, 128, false},
|
|
};
|
|
|
|
|
|
BEGIN_MESSAGE_MAP(CObjectBar, CHammerBar)
|
|
ON_UPDATE_COMMAND_UI(IDC_CREATELIST, UpdateControl)
|
|
ON_UPDATE_COMMAND_UI(IDC_CATEGORYLIST, UpdateControl)
|
|
ON_UPDATE_COMMAND_UI(IDC_FACES, UpdateFaceControl)
|
|
ON_UPDATE_COMMAND_UI(IDC_FACESSPIN, UpdateFaceControl)
|
|
ON_UPDATE_COMMAND_UI(ID_TOOLS_CREATEPREFAB, UpdateControl)
|
|
ON_UPDATE_COMMAND_UI(ID_CREATEOBJECT, UpdateControl)
|
|
ON_CBN_SELCHANGE(IDC_CATEGORYLIST, OnChangeCategory)
|
|
END_MESSAGE_MAP()
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Get the index of the specified solid type.
|
|
//-----------------------------------------------------------------------------
|
|
static int FindSolidType( const char *pName )
|
|
{
|
|
for ( int i=0; i < ARRAYSIZE( SolidTypes ); i++ )
|
|
{
|
|
if ( Q_stricmp( pName, SolidTypes[i].pszName ) == 0 )
|
|
return i;
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Get the index of the specified GDClass.
|
|
//-----------------------------------------------------------------------------
|
|
static int FindGameDataClass( const char *pName )
|
|
{
|
|
extern GameData *pGD;
|
|
if( pGD != NULL )
|
|
{
|
|
int nCount = pGD->GetClassCount();
|
|
for (int i = 0; i < nCount; i++)
|
|
{
|
|
GDclass *pc = pGD->GetClass(i);
|
|
if ( Q_stricmp( pName, pc->GetName() ) == 0 )
|
|
return i;
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
CObjectBar::CObjectBar()
|
|
: CHammerBar(), m_CreateList( this )
|
|
{
|
|
for(int i = 0; i < MAX_PREV_SEL; i++)
|
|
{
|
|
m_PrevSel[i].dwGameID = 0;
|
|
}
|
|
|
|
m_dwPrevGameID = (unsigned long)-1;
|
|
}
|
|
|
|
|
|
bool CObjectBar::UseRandomYawOnEntityPlacement()
|
|
{
|
|
return ::SendMessage( ::GetDlgItem( GetSafeHwnd(), IDC_RANDOMYAW ), BM_GETCHECK, 0, 0 ) == BST_CHECKED;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : pDX -
|
|
//-----------------------------------------------------------------------------
|
|
void CObjectBar::DoDataExchange(CDataExchange *pDX)
|
|
{
|
|
CHammerBar::DoDataExchange(pDX);
|
|
//{{AFX_DATA_MAP(COP_Entity)
|
|
DDX_Control(pDX, IDC_CREATELIST, m_CreateList);
|
|
//}}AFX_DATA_MAP
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Returns the bounds of the current 3D prefab object.
|
|
// Input : *pBox -
|
|
// Output : Returns TRUE on success, FALSE on failure.
|
|
//-----------------------------------------------------------------------------
|
|
BOOL CObjectBar::GetPrefabBounds(BoundBox *pBox)
|
|
{
|
|
if (ListType != listPrefabs)
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
CPrefab3D *pPrefab = (CPrefab3D *)CPrefab::FindID(_iNewObjIndex);
|
|
if (pPrefab != NULL)
|
|
{
|
|
if (pPrefab->GetType() != pt3D)
|
|
{
|
|
return(FALSE);
|
|
}
|
|
|
|
if (!pPrefab->IsLoaded())
|
|
{
|
|
pPrefab->Load();
|
|
}
|
|
|
|
if (!pPrefab->IsLoaded())
|
|
{
|
|
return(FALSE);
|
|
}
|
|
|
|
CMapWorld *pWorld = pPrefab->GetWorld();
|
|
|
|
Vector mins;
|
|
Vector maxs;
|
|
pWorld->GetRender2DBox(mins, maxs);
|
|
pBox->SetBounds(mins, maxs);
|
|
|
|
return(TRUE);
|
|
}
|
|
|
|
return(FALSE);
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Find the specified prefab.
|
|
//-----------------------------------------------------------------------------
|
|
CPrefab* CObjectBar::FindPrefabByName( const char *pName )
|
|
{
|
|
CPrefabLibrary *pLibrary = CPrefabLibrary::FindID( m_CategoryList.GetItemData(m_CategoryList.GetCurSel() ) );
|
|
if ( pLibrary )
|
|
{
|
|
POSITION p = ENUM_START;
|
|
CPrefab *pPrefab = pLibrary->EnumPrefabs( p );
|
|
while( pPrefab )
|
|
{
|
|
if ( Q_stricmp( pName, pPrefab->GetName() ) == 0 )
|
|
return pPrefab;
|
|
|
|
pPrefab = pLibrary->EnumPrefabs( p );
|
|
}
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : pBox -
|
|
// pAxes -
|
|
// Output :
|
|
//-----------------------------------------------------------------------------
|
|
CMapClass *CObjectBar::CreateInBox(BoundBox *pBox, CMapView *pView)
|
|
{
|
|
// primitives:
|
|
|
|
int axHorz = 0;
|
|
int axVert = 1;
|
|
|
|
CMapView2D *pView2D = dynamic_cast<CMapView2D*>(pView);
|
|
|
|
if ( pView2D )
|
|
{
|
|
axHorz = pView2D->axHorz;
|
|
axVert = pView2D->axVert;
|
|
}
|
|
|
|
if(ListType == listPrimitives)
|
|
{
|
|
int nFaces;
|
|
char szBuf[128];
|
|
m_Faces.GetWindowText(szBuf, 128);
|
|
nFaces = atoi(szBuf);
|
|
|
|
//
|
|
// The index into the solid types array is stored in the item data.
|
|
//
|
|
int nSolidIndex = _iNewObjIndex;
|
|
|
|
int nFacesMin = SolidTypes[nSolidIndex].nFacesMin;
|
|
int nFacesMax = SolidTypes[nSolidIndex].nFacesMax;
|
|
|
|
//
|
|
// Insure that the face count is within legal range (if applicable).
|
|
//
|
|
if ((SolidTypes[nSolidIndex].bEnableFaceControl) && (nFaces < nFacesMin || nFaces > nFacesMax))
|
|
{
|
|
CString str;
|
|
str.Format("The face count for a %s must be in the range of %d to %d.",
|
|
SolidTypes[nSolidIndex].pszName, nFacesMin, nFacesMax);
|
|
AfxMessageBox(str);
|
|
return NULL;
|
|
}
|
|
|
|
if(nSolidIndex < 5)
|
|
{
|
|
StockSolid *pStock = NULL;
|
|
|
|
switch(nSolidIndex)
|
|
{
|
|
case 0:
|
|
pStock = new StockBlock;
|
|
break;
|
|
case 1:
|
|
pStock = new StockWedge;
|
|
break;
|
|
case 2:
|
|
pStock = new StockCylinder;
|
|
pStock->SetFieldData(StockCylinder::fieldSideCount, nFaces);
|
|
break;
|
|
case 3:
|
|
pStock = new StockSpike;
|
|
pStock->SetFieldData(StockSpike::fieldSideCount, nFaces);
|
|
break;
|
|
default:
|
|
pStock = new StockSphere;
|
|
pStock->SetFieldData(StockSphere::fieldSideCount, nFaces);
|
|
break;
|
|
}
|
|
|
|
// create a solid
|
|
CMapSolid *pSolid = new CMapSolid;
|
|
pStock->SetFromBox(pBox);
|
|
pStock->CreateMapSolid(pSolid, Options.GetTextureAlignment());
|
|
pSolid->SetTexture(GetDefaultTextureName());
|
|
delete pStock; // done with you! done!
|
|
|
|
// return new solid
|
|
return pSolid;
|
|
}
|
|
else if (nSolidIndex == 5)
|
|
{
|
|
// arch
|
|
CArchDlg dlg(pBox->bmins, pBox->bmaxs);
|
|
Vector sizebounds;
|
|
pBox->GetBoundsSize(sizebounds);
|
|
dlg.m_iSides = nFaces;
|
|
dlg.SetMaxWallWidth(min((int)sizebounds[axHorz], (int)sizebounds[axVert]));
|
|
if(dlg.DoModal() != IDOK)
|
|
return NULL;
|
|
|
|
// save values for next use of arch
|
|
dlg.SaveValues();
|
|
|
|
CMapClass *pArch = CreateArch(pBox, dlg.m_fAngle,
|
|
dlg.m_iSides, dlg.m_fArc, dlg.m_iWallWidth,
|
|
dlg.m_iAddHeight, FALSE);
|
|
|
|
const CMapObjectList &SolidList = *pArch->GetChildren();
|
|
FOR_EACH_OBJ( SolidList, nSolid )
|
|
{
|
|
CMapSolid *pSolid = dynamic_cast<CMapSolid *>(SolidList[nSolid]);
|
|
if ( pSolid )
|
|
pSolid->SetTexture(GetDefaultTextureName());
|
|
}
|
|
|
|
return pArch;
|
|
}
|
|
else
|
|
{
|
|
// Torus
|
|
CTorusDlg dlg( pBox->bmins, pBox->bmaxs );
|
|
Vector sizebounds;
|
|
pBox->GetBoundsSize( sizebounds );
|
|
dlg.SetMaxWallWidth(min((int)sizebounds[axHorz], (int)sizebounds[axVert]));
|
|
if(dlg.DoModal() != IDOK)
|
|
return NULL;
|
|
|
|
// save values for next use of arch
|
|
dlg.SaveValues();
|
|
|
|
CMapClass *pTorus = CreateTorus(pBox, dlg.m_fAngle, dlg.m_iSides, dlg.m_fArc, dlg.m_iWallWidth,
|
|
dlg.GetTorusCrossSectionRadius(),
|
|
dlg.m_fRotationAngle, dlg.m_iRotationSides, dlg.m_fRotationArc, dlg.m_iAddHeight, FALSE);
|
|
|
|
const CMapObjectList &SolidList = *pTorus->GetChildren();
|
|
FOR_EACH_OBJ( SolidList, nSolid )
|
|
{
|
|
CMapSolid *pSolid = dynamic_cast<CMapSolid *>(SolidList[nSolid]);
|
|
if ( pSolid )
|
|
pSolid->SetTexture(GetDefaultTextureName());
|
|
}
|
|
|
|
return pTorus;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
CPrefab *pPrefab = CPrefab::FindID(_iNewObjIndex);
|
|
if (pPrefab != NULL)
|
|
{
|
|
return(pPrefab->CreateInBox(pBox));
|
|
}
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Returns the classname of the default entity for the entity creation tool.
|
|
//-----------------------------------------------------------------------------
|
|
LPCTSTR CObjectBar::GetDefaultEntityClass(void)
|
|
{
|
|
return _szNewObjName;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
CMapClass *CObjectBar::BuildPrefabObjectAtPoint( Vector const &HitPos )
|
|
{
|
|
//
|
|
// find prefab
|
|
//
|
|
CPrefab3D *pPrefab = ( CPrefab3D* )CPrefab::FindID( _iNewObjIndex );
|
|
if( !pPrefab )
|
|
return NULL;
|
|
|
|
//
|
|
// create prefab bounding box -- centered at hit pos
|
|
//
|
|
return pPrefab->CreateAtPointAroundOrigin( HitPos );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
bool CObjectBar::IsEntityToolCreatingPrefab( void )
|
|
{
|
|
if( ( m_iLastTool == TOOL_ENTITY ) && ( m_CategoryList.GetCurSel() != 0 ) )
|
|
return true;
|
|
|
|
return false;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
bool CObjectBar::IsEntityToolCreatingEntity( void )
|
|
{
|
|
if( ( m_iLastTool == TOOL_ENTITY ) && ( m_CategoryList.GetCurSel() == 0 ) )
|
|
return true;
|
|
|
|
return false;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CObjectBar::OnChangeCategory()
|
|
{
|
|
switch (ListType)
|
|
{
|
|
case listPrimitives:
|
|
{
|
|
iBlockSel = -1;
|
|
LoadBlockItems();
|
|
break;
|
|
}
|
|
|
|
case listPrefabs:
|
|
{
|
|
if (m_iLastTool == TOOL_BLOCK)
|
|
{
|
|
iBlockSel = -1;
|
|
LoadBlockItems();
|
|
}
|
|
else if (m_iLastTool == TOOL_ENTITY)
|
|
{
|
|
iEntitySel = -1;
|
|
LoadEntityItems();
|
|
}
|
|
break;
|
|
}
|
|
|
|
case listEntities:
|
|
{
|
|
iEntitySel = -1;
|
|
LoadEntityItems();
|
|
break;
|
|
}
|
|
|
|
default:
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
DoHideControls();
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : pParentWnd -
|
|
// Output : Returns TRUE on success, FALSE on failure.
|
|
//-----------------------------------------------------------------------------
|
|
BOOL CObjectBar::Create(CWnd *pParentWnd)
|
|
{
|
|
if (!CHammerBar::Create(pParentWnd, IDD_OBJECTBAR, CBRS_RIGHT, IDCB_OBJECTBAR))
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
SetWindowText("New Objects");
|
|
|
|
|
|
// set up controls
|
|
|
|
// We only want it to return values that are in our list of suggestions.
|
|
m_CreateList.SubclassDlgItem(IDC_CREATELIST, this);
|
|
m_CreateList.SetOnlyProvideSuggestions( true );
|
|
|
|
m_CategoryList.SubclassDlgItem(IDC_CATEGORYLIST, this);
|
|
m_Faces.SubclassDlgItem(IDC_FACES, this);
|
|
m_FacesSpin.SubclassDlgItem(IDC_FACESSPIN, this);
|
|
m_FacesSpin.SetBuddy(&m_Faces);
|
|
|
|
iBlockSel = -1;
|
|
iEntitySel = -1;
|
|
m_iLastTool = -1;
|
|
|
|
LoadBlockCategories();
|
|
|
|
// outta here
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Load the category list with the list of primitives and object libraries.
|
|
//-----------------------------------------------------------------------------
|
|
void CObjectBar::LoadBlockCategories( void )
|
|
{
|
|
m_CategoryList.SetRedraw(FALSE);
|
|
|
|
// first item is the primitive list
|
|
m_CategoryList.ResetContent();
|
|
m_CategoryList.AddString("Primitives");
|
|
|
|
// the next items are the prefab categories (libraries)
|
|
LoadPrefabCategories();
|
|
|
|
// redraw category list
|
|
m_CategoryList.SetRedraw(TRUE);
|
|
m_CategoryList.Invalidate();
|
|
|
|
// set initial state
|
|
m_CategoryList.SetCurSel( 0 );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CObjectBar::LoadEntityCategories( void )
|
|
{
|
|
m_CategoryList.SetRedraw( FALSE );
|
|
|
|
// first item is the primitive list
|
|
m_CategoryList.ResetContent();
|
|
m_CategoryList.AddString( "Entities" );
|
|
|
|
// the next items are the prefab categories (libraries)
|
|
LoadPrefabCategories();
|
|
|
|
// redraw category list
|
|
m_CategoryList.SetRedraw( TRUE );
|
|
m_CategoryList.Invalidate();
|
|
|
|
// set initial state
|
|
m_CategoryList.SetCurSel( 0 );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CObjectBar::LoadPrefabCategories( void )
|
|
{
|
|
//
|
|
// if a long list -- don't update every time
|
|
//
|
|
m_CategoryList.SetRedraw( FALSE );
|
|
|
|
//
|
|
// add all prefab object libraries to the category list
|
|
//
|
|
POSITION p = ENUM_START;
|
|
CPrefabLibrary *pLibrary = CPrefabLibrary::EnumLibraries( p );
|
|
while( pLibrary )
|
|
{
|
|
int iIndex = m_CategoryList.AddString( pLibrary->GetName() );
|
|
m_CategoryList.SetItemData( iIndex, pLibrary->GetID() );
|
|
pLibrary = CPrefabLibrary::EnumLibraries( p );
|
|
}
|
|
|
|
m_CategoryList.SetRedraw(TRUE);
|
|
m_CategoryList.Invalidate();
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CObjectBar::LoadBlockItems( void )
|
|
{
|
|
//
|
|
// verify the block categories are loaded
|
|
//
|
|
if( m_CategoryList.GetCurSel() == CB_ERR )
|
|
{
|
|
LoadBlockCategories();
|
|
}
|
|
|
|
//
|
|
// load primitive items
|
|
//
|
|
if( m_CategoryList.GetCurSel() == 0 )
|
|
{
|
|
// set list type (primitives)
|
|
ListType = listPrimitives;
|
|
|
|
// set list type (primitives)
|
|
CUtlVector<CString> suggestions;
|
|
for( int i = 0; i < sizeof( SolidTypes ) / sizeof( SolidTypes[0] ); i++)
|
|
suggestions.AddToTail( SolidTypes[i].pszName );
|
|
|
|
m_CreateList.SetSuggestions( suggestions );
|
|
}
|
|
else
|
|
{
|
|
LoadPrefabItems();
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CObjectBar::LoadEntityItems( void )
|
|
{
|
|
//
|
|
// verify the block categories are loaded
|
|
//
|
|
if( m_CategoryList.GetCurSel() == CB_ERR )
|
|
{
|
|
LoadEntityCategories();
|
|
}
|
|
|
|
//
|
|
// load entity items
|
|
//
|
|
if( m_CategoryList.GetCurSel() == 0 )
|
|
{
|
|
// set list type (markers)???
|
|
ListType = listEntities;
|
|
|
|
CUtlVector<CString> suggestions;
|
|
extern GameData *pGD;
|
|
if( pGD != NULL )
|
|
{
|
|
int nCount = pGD->GetClassCount();
|
|
for (int i = 0; i < nCount; i++)
|
|
{
|
|
GDclass *pc = pGD->GetClass(i);
|
|
if( !pc->IsBaseClass() && !pc->IsSolidClass() )
|
|
{
|
|
suggestions.AddToTail( pc->GetName() );
|
|
}
|
|
}
|
|
}
|
|
|
|
m_CreateList.SetSuggestions( suggestions );
|
|
}
|
|
else
|
|
{
|
|
LoadPrefabItems();
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CObjectBar::LoadPrefabItems( void )
|
|
{
|
|
// set list type (prefabs)
|
|
ListType = listPrefabs;
|
|
|
|
CUtlVector<CString> suggestions;
|
|
|
|
// get the active library and add the prefabs from it
|
|
CPrefabLibrary *pLibrary = CPrefabLibrary::FindID( m_CategoryList.GetItemData(m_CategoryList.GetCurSel() ) );
|
|
|
|
POSITION p = ENUM_START;
|
|
CPrefab *pPrefab = pLibrary->EnumPrefabs( p );
|
|
while( pPrefab )
|
|
{
|
|
suggestions.AddToTail( pPrefab->GetName() );
|
|
pPrefab = pLibrary->EnumPrefabs( p );
|
|
}
|
|
|
|
m_CreateList.SetSuggestions( suggestions );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CObjectBar::DoHideControls()
|
|
{
|
|
// hide controls based on which mode is selected...
|
|
if(ListType == listPrimitives)
|
|
{
|
|
GetDlgItem(ID_INSERTPREFAB_ORIGINAL)->ShowWindow(SW_HIDE);
|
|
m_Faces.ShowWindow(SW_SHOW);
|
|
m_FacesSpin.ShowWindow(SW_SHOW);
|
|
GetDlgItem(IDC_FACESPROMPT)->ShowWindow(SW_SHOW);
|
|
}
|
|
else if(ListType == listPrefabs)
|
|
{
|
|
m_Faces.ShowWindow(SW_HIDE);
|
|
m_FacesSpin.ShowWindow(SW_HIDE);
|
|
GetDlgItem(IDC_FACESPROMPT)->ShowWindow(SW_HIDE);
|
|
GetDlgItem(ID_INSERTPREFAB_ORIGINAL)->ShowWindow(SW_SHOW);
|
|
}
|
|
else if(ListType == listEntities)
|
|
{
|
|
m_Faces.ShowWindow(SW_HIDE);
|
|
m_FacesSpin.ShowWindow(SW_HIDE);
|
|
GetDlgItem(IDC_FACESPROMPT)->ShowWindow(SW_HIDE);
|
|
GetDlgItem(ID_INSERTPREFAB_ORIGINAL)->ShowWindow(SW_HIDE);
|
|
}
|
|
|
|
// Show the "random yaw" button?
|
|
bool bShow = (ListType == listEntities);
|
|
GetDlgItem( IDC_RANDOMYAW )->ShowWindow( bShow ? SW_SHOW : SW_HIDE );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : *pCmdUI -
|
|
//-----------------------------------------------------------------------------
|
|
void CObjectBar::UpdateControl(CCmdUI *pCmdUI)
|
|
{
|
|
CMapDoc *pDoc = CMapDoc::GetActiveMapDoc();
|
|
|
|
switch (pCmdUI->m_nID)
|
|
{
|
|
case ID_INSERTPREFAB_ORIGINAL:
|
|
{
|
|
pCmdUI->Enable(ListType == listPrefabs);
|
|
break;
|
|
}
|
|
|
|
case IDC_CREATELIST:
|
|
case IDC_CATEGORYLIST:
|
|
{
|
|
BOOL bEnable = FALSE;
|
|
if (pDoc)
|
|
{
|
|
int nTool = pDoc->GetTools()->GetActiveToolID();
|
|
if ((nTool == TOOL_ENTITY) || (nTool == TOOL_BLOCK))
|
|
{
|
|
bEnable = TRUE;
|
|
}
|
|
}
|
|
pCmdUI->Enable(bEnable);
|
|
break;
|
|
}
|
|
|
|
default:
|
|
{
|
|
pCmdUI->Enable( pDoc ? TRUE : FALSE);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : *pWnd -
|
|
// bModifyWnd -
|
|
// Output : Returns TRUE on success, FALSE on failure.
|
|
//-----------------------------------------------------------------------------
|
|
BOOL CObjectBar::EnableFaceControl(CWnd *pWnd, BOOL bModifyWnd)
|
|
{
|
|
BOOL bEnable = CMapDoc::GetActiveMapDoc() ? TRUE : FALSE;
|
|
|
|
if(bEnable)
|
|
{
|
|
bEnable = FALSE;
|
|
|
|
//
|
|
// Enable the control only if we are dealing with an object the
|
|
// that has adjustable faces.
|
|
//
|
|
if (ListType == listPrimitives)
|
|
{
|
|
int nSolidIndex = iBlockSel;
|
|
if (SolidTypes[nSolidIndex].bEnableFaceControl)
|
|
{
|
|
bEnable = TRUE;
|
|
}
|
|
}
|
|
}
|
|
|
|
if(bModifyWnd)
|
|
pWnd->EnableWindow(bEnable);
|
|
|
|
return bEnable;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : *pCmdUI -
|
|
//-----------------------------------------------------------------------------
|
|
void CObjectBar::UpdateFaceControl(CCmdUI *pCmdUI)
|
|
{
|
|
pCmdUI->Enable(EnableFaceControl(GetDlgItem(pCmdUI->m_nID), FALSE));
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Called when a new item has been selected in the combo box.
|
|
//-----------------------------------------------------------------------------
|
|
void CObjectBar::OnTextChanged( const char *pSelection )
|
|
{
|
|
char szBuf[128];
|
|
|
|
switch (ListType)
|
|
{
|
|
case listPrimitives:
|
|
{
|
|
_iNewObjIndex = FindSolidType( pSelection );
|
|
Assert( _iNewObjIndex != -1 );
|
|
|
|
//
|
|
// Save current value from the faces edit control. The next time this primitive is
|
|
// selected the value will be restored.
|
|
//
|
|
if (iBlockSel != -1)
|
|
{
|
|
int nSolidIndex = iBlockSel;
|
|
m_Faces.GetWindowText(szBuf, 128);
|
|
SolidTypes[nSolidIndex].nFaces = atoi(szBuf);
|
|
}
|
|
iBlockSel = _iNewObjIndex;
|
|
break;
|
|
}
|
|
|
|
case listPrefabs:
|
|
{
|
|
CPrefab *pPrefab = FindPrefabByName( pSelection );
|
|
Assert( pPrefab );
|
|
if ( pPrefab )
|
|
{
|
|
_iNewObjIndex = pPrefab->GetID();
|
|
|
|
if (m_iLastTool == TOOL_BLOCK )
|
|
{
|
|
iBlockSel = _iNewObjIndex;
|
|
}
|
|
else if( m_iLastTool == TOOL_ENTITY )
|
|
{
|
|
iEntitySel = _iNewObjIndex;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
|
|
case listEntities:
|
|
{
|
|
_iNewObjIndex = FindGameDataClass( pSelection );
|
|
Assert( _iNewObjIndex != -1 );
|
|
if ( _iNewObjIndex != -1 )
|
|
{
|
|
Q_strncpy( _szNewObjName, pSelection, sizeof( _szNewObjName ) );
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (ListType != listPrimitives)
|
|
return;
|
|
|
|
EnableFaceControl(&m_Faces, TRUE);
|
|
EnableFaceControl(&m_FacesSpin, TRUE);
|
|
|
|
int nSolidIndex = _iNewObjIndex;
|
|
|
|
m_FacesSpin.SetRange(SolidTypes[nSolidIndex].nFacesMin, SolidTypes[nSolidIndex].nFacesMax);
|
|
m_FacesSpin.SetPos(SolidTypes[nSolidIndex].nFaces);
|
|
|
|
itoa(SolidTypes[nSolidIndex].nFaces, szBuf, 10);
|
|
m_Faces.SetWindowText(szBuf);
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : dwGameID -
|
|
// piNewIndex -
|
|
// Output :
|
|
//-----------------------------------------------------------------------------
|
|
int CObjectBar::GetPrevSelIndex(DWORD dwGameID, int *piNewIndex)
|
|
{
|
|
for(int i = 0; i < MAX_PREV_SEL; i++)
|
|
{
|
|
if(m_PrevSel[i].dwGameID == 0 && piNewIndex)
|
|
*piNewIndex = i;
|
|
|
|
if(m_PrevSel[i].dwGameID == dwGameID)
|
|
return i;
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : pMsg -
|
|
// Output : Returns TRUE on success, FALSE on failure.
|
|
//-----------------------------------------------------------------------------
|
|
BOOL CObjectBar::PreTranslateMessage(MSG* pMsg)
|
|
{
|
|
//
|
|
// See if the message is a keydown and the current focus window is the
|
|
// ComboBox in the ObjectBar!
|
|
//
|
|
/*static BOOL bRecurse = FALSE;
|
|
|
|
if (pMsg->message == WM_KEYDOWN && !bRecurse)
|
|
{
|
|
if (GetFocus() == &m_CreateList)
|
|
{
|
|
//AfxMessageBox("Ok");
|
|
bRecurse = TRUE;
|
|
m_CreateList.SendMessage(WM_CHAR, pMsg->wParam, pMsg->lParam);
|
|
bRecurse = FALSE;
|
|
return TRUE;
|
|
}
|
|
}
|
|
*/
|
|
return CHammerBar::PreTranslateMessage(pMsg);
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : iTool -
|
|
//-----------------------------------------------------------------------------
|
|
void CObjectBar::UpdateListForTool( int iTool )
|
|
{
|
|
//
|
|
// initialize for new "game config"
|
|
//
|
|
int iPrevSel = 0;
|
|
if (m_dwPrevGameID != g_pGameConfig->dwID)
|
|
{
|
|
//
|
|
// save current game id and save
|
|
//
|
|
m_dwPrevGameID = g_pGameConfig->dwID;
|
|
GetPrevSelIndex( g_pGameConfig->dwID, &iPrevSel );
|
|
m_PrevSel[iPrevSel].dwGameID = g_pGameConfig->dwID;
|
|
|
|
m_PrevSel[iPrevSel].block.strCategory = "Primitives";
|
|
m_PrevSel[iPrevSel].block.strItem = "block";
|
|
|
|
m_PrevSel[iPrevSel].entity.strCategory = "Entities";
|
|
m_PrevSel[iPrevSel].entity.strItem = g_pGameConfig->szDefaultPoint;
|
|
}
|
|
|
|
// get game id previously selected data index
|
|
iPrevSel = GetPrevSelIndex( m_dwPrevGameID );
|
|
if (iPrevSel == -1)
|
|
return;
|
|
|
|
//
|
|
// Save last known selection state for previous tool
|
|
//
|
|
if (m_iLastTool == TOOL_BLOCK)
|
|
{
|
|
int iCategory = m_CategoryList.GetCurSel();
|
|
if( iCategory != -1 )
|
|
{
|
|
m_CategoryList.GetLBText( iCategory, m_PrevSel[iPrevSel].block.strCategory );
|
|
m_PrevSel[iPrevSel].block.strItem = m_CreateList.GetCurrentItem();
|
|
}
|
|
else
|
|
{
|
|
m_PrevSel[iPrevSel].block.strCategory = "";
|
|
m_PrevSel[iPrevSel].block.strItem = "";
|
|
}
|
|
}
|
|
else if (m_iLastTool == TOOL_ENTITY)
|
|
{
|
|
int iCategory = m_CategoryList.GetCurSel();
|
|
if( iCategory != -1 )
|
|
{
|
|
m_CategoryList.GetLBText( iCategory, m_PrevSel[iPrevSel].entity.strCategory );
|
|
m_PrevSel[iPrevSel].entity.strItem = m_CreateList.GetCurrentItem();
|
|
}
|
|
else
|
|
{
|
|
m_PrevSel[iPrevSel].entity.strCategory = "";
|
|
m_PrevSel[iPrevSel].entity.strItem = "";
|
|
}
|
|
}
|
|
|
|
// save tool for next pass
|
|
m_iLastTool = iTool;
|
|
|
|
//
|
|
// update new for new tool
|
|
//
|
|
if (iTool == TOOL_BLOCK)
|
|
{
|
|
//
|
|
// load block categories and items
|
|
//
|
|
LoadBlockCategories();
|
|
m_CategoryList.SelectString( -1, m_PrevSel[iPrevSel].block.strCategory );
|
|
LoadBlockItems();
|
|
|
|
m_CreateList.SelectItem( m_PrevSel[iPrevSel].block.strItem );
|
|
OnTextChanged( m_PrevSel[iPrevSel].block.strItem );
|
|
iBlockSel = FindSolidType( m_PrevSel[iPrevSel].block.strItem );
|
|
Assert( iBlockSel >= 0 );
|
|
|
|
// hide/show appropriate controls
|
|
DoHideControls();
|
|
|
|
//
|
|
// enable/disable face controls
|
|
//
|
|
EnableFaceControl( &m_Faces, TRUE );
|
|
EnableFaceControl( &m_FacesSpin, TRUE );
|
|
}
|
|
else if (iTool == TOOL_ENTITY)
|
|
{
|
|
//
|
|
// load entity categories and items
|
|
//
|
|
LoadEntityCategories();
|
|
m_CategoryList.SelectString( -1, m_PrevSel[iPrevSel].entity.strCategory );
|
|
LoadEntityItems();
|
|
|
|
m_CreateList.SelectItem( m_PrevSel[iPrevSel].entity.strItem );
|
|
OnTextChanged( m_PrevSel[iPrevSel].entity.strItem );
|
|
iEntitySel = FindGameDataClass( m_PrevSel[iPrevSel].entity.strItem );
|
|
|
|
// hide/show appropriate controls
|
|
DoHideControls();
|
|
|
|
//
|
|
// enable/disable face controls
|
|
//
|
|
EnableFaceControl( &m_Faces, TRUE );
|
|
EnableFaceControl( &m_FacesSpin, TRUE );
|
|
}
|
|
else
|
|
{
|
|
m_CategoryList.ResetContent();
|
|
m_CreateList.Clear();
|
|
DoHideControls();
|
|
}
|
|
}
|